557 lines
20 KiB
TypeScript
557 lines
20 KiB
TypeScript
import {
|
||
Injectable,
|
||
NotFoundException,
|
||
BadRequestException,
|
||
ConflictException,
|
||
} from '@nestjs/common';
|
||
import { InjectRepository } from '@nestjs/typeorm';
|
||
import { Repository, Not, LessThanOrEqual, MoreThanOrEqual } from 'typeorm';
|
||
import { ClassroomRental } from '../entities/classroom-rental.entity';
|
||
import { Classroom } from '../entities/classroom.entity';
|
||
import { Organization } from '../entities/organization.entity';
|
||
import { ClassSchedule } from '../entities/class-schedule.entity';
|
||
import { CreateRentalDto, UpdateRentalDto } from './dto/rental.dto';
|
||
|
||
import * as path from 'path';
|
||
import * as fs from 'fs';
|
||
|
||
// 预设色板（与 organizations.service 保持一致，作为颜色兜底）
|
||
const COLOR_PALETTE = [
|
||
'#ff7875',
|
||
'#ffa940',
|
||
'#ffc53d',
|
||
'#73d13d',
|
||
'#36cfc9',
|
||
'#40a9ff',
|
||
'#597ef7',
|
||
'#9254de',
|
||
'#f759ab',
|
||
'#8c8c8c',
|
||
];
|
||
|
||
@Injectable()
|
||
export class ClassroomRentalsService {
|
||
constructor(
|
||
@InjectRepository(ClassroomRental) private repo: Repository<ClassroomRental>,
|
||
@InjectRepository(Classroom) private classroomRepo: Repository<Classroom>,
|
||
@InjectRepository(Organization) private organizationRepo: Repository<Organization>,
|
||
@InjectRepository(ClassSchedule) private scheduleRepo: Repository<ClassSchedule>,
|
||
) {}
|
||
|
||
get uploadDir(): string {
|
||
const base = process.env.UPLOAD_DIR || './uploads';
|
||
return path.resolve(base, 'contracts');
|
||
}
|
||
|
||
ensureUploadDir() {
|
||
if (!fs.existsSync(this.uploadDir)) {
|
||
fs.mkdirSync(this.uploadDir, { recursive: true });
|
||
}
|
||
}
|
||
|
||
async findAll(query?: {
|
||
classroomId?: number;
|
||
lesseeOrganizationId?: number;
|
||
month?: string;
|
||
includeEnded?: boolean;
|
||
}) {
|
||
const qb = this.repo
|
||
.createQueryBuilder('r')
|
||
.leftJoinAndSelect('r.classroom', 'classroom')
|
||
.leftJoinAndSelect('r.lesseeOrganization', 'lesseeOrganization')
|
||
.orderBy('r.startDate', 'DESC');
|
||
if (query?.classroomId) qb.andWhere('r.classroomId = :cid', { cid: query.classroomId });
|
||
if (query?.lesseeOrganizationId)
|
||
qb.andWhere('r.lesseeOrganizationId = :oid', { oid: query.lesseeOrganizationId });
|
||
if (query?.month) {
|
||
const [y, m] = query.month.split('-').map(Number);
|
||
const first = `${y}-${String(m).padStart(2, '0')}-01`;
|
||
const lastDay = new Date(y, m, 0).getDate();
|
||
const last = `${y}-${String(m).padStart(2, '0')}-${String(lastDay).padStart(2, '0')}`;
|
||
qb.andWhere('r.startDate <= :last AND r.endDate >= :first', { first, last });
|
||
}
|
||
if (!query?.includeEnded) qb.andWhere('r.status != :cancelled', { cancelled: 'cancelled' });
|
||
return qb.getMany();
|
||
}
|
||
|
||
async findOne(id: number) {
|
||
const rental = await this.repo.findOne({
|
||
where: { id },
|
||
relations: ['classroom', 'lessorOrganization', 'lesseeOrganization'],
|
||
});
|
||
if (!rental) throw new NotFoundException('租赁订单不存在');
|
||
return rental;
|
||
}
|
||
|
||
async getUnavailableDates(classroomId: number, year: number, month: number, excludeId?: number) {
|
||
const lastDay = new Date(Date.UTC(year, month, 0)).getUTCDate();
|
||
const monthStart = `${year}-${String(month).padStart(2, '0')}-01`;
|
||
const monthEnd = `${year}-${String(month).padStart(2, '0')}-${String(lastDay).padStart(2, '0')}`;
|
||
|
||
const [rentals, schedules] = await Promise.all([
|
||
this.repo.find({
|
||
where: {
|
||
...(excludeId ? { id: Not(excludeId) } : {}),
|
||
classroomId,
|
||
status: Not('cancelled'),
|
||
startDate: LessThanOrEqual(monthEnd),
|
||
endDate: MoreThanOrEqual(monthStart),
|
||
},
|
||
}),
|
||
this.scheduleRepo.find({
|
||
where: {
|
||
classroomId,
|
||
status: 'active',
|
||
scheduleType: 'INTERNAL',
|
||
startDate: LessThanOrEqual(monthEnd),
|
||
endDate: MoreThanOrEqual(monthStart),
|
||
},
|
||
}),
|
||
]);
|
||
|
||
const unavailableDates = new Set<string>();
|
||
for (const rental of rentals) {
|
||
this.addDateRange(
|
||
unavailableDates,
|
||
rental.startDate > monthStart ? rental.startDate : monthStart,
|
||
rental.endDate < monthEnd ? rental.endDate : monthEnd,
|
||
);
|
||
}
|
||
for (const schedule of schedules) {
|
||
this.addScheduleOccurrences(unavailableDates, schedule, monthStart, monthEnd);
|
||
}
|
||
|
||
return { dates: Array.from(unavailableDates).sort() };
|
||
}
|
||
|
||
/**
|
||
* 查找与给定区间冲突的租赁订单，同时检测同一教室同一日期段的内部排课
|
||
* 重叠判定：start1 <= end2 AND start2 <= end1
|
||
*/
|
||
async findConflicts(classroomId: number, startDate: string, endDate: string, excludeId?: number) {
|
||
const qb = this.repo
|
||
.createQueryBuilder('r')
|
||
.leftJoinAndSelect('r.lesseeOrganization', 'lesseeOrganization')
|
||
.where('r.classroomId = :cid', { cid: classroomId })
|
||
.andWhere('r.status != :cancelled', { cancelled: 'cancelled' })
|
||
.andWhere('r.startDate <= :end', { end: endDate })
|
||
.andWhere('r.endDate >= :start', { start: startDate });
|
||
if (excludeId) qb.andWhere('r.id != :excludeId', { excludeId });
|
||
const rentals = await qb.getMany();
|
||
|
||
// 检测同一教室同一日期段是否存在内部排课
|
||
const scheduleCandidates = await this.scheduleRepo
|
||
.createQueryBuilder('cs')
|
||
.where('cs.classroomId = :cid', { cid: classroomId })
|
||
.andWhere('cs.status = :status', { status: 'active' })
|
||
.andWhere('cs.scheduleType = :scheduleType', { scheduleType: 'INTERNAL' })
|
||
.andWhere('cs.startDate <= :end', { end: endDate })
|
||
.andWhere('cs.endDate >= :start', { start: startDate })
|
||
.getMany();
|
||
const scheduleConflicts = scheduleCandidates.filter((schedule) =>
|
||
this.hasScheduleOccurrence(schedule, startDate, endDate),
|
||
);
|
||
|
||
if (scheduleConflicts.length > 0) {
|
||
throw new ConflictException({
|
||
message: '该教室在此时间段已有排课',
|
||
conflicts: scheduleConflicts.map((s) => ({
|
||
id: s.id,
|
||
startDate: s.startDate,
|
||
endDate: s.endDate,
|
||
organizationName: `[内部排课] ${s.subject}`,
|
||
})),
|
||
});
|
||
}
|
||
|
||
return rentals;
|
||
}
|
||
|
||
private hasScheduleOccurrence(
|
||
schedule: ClassSchedule,
|
||
startDate: string,
|
||
endDate: string,
|
||
): boolean {
|
||
const overlapStart = schedule.startDate > startDate ? schedule.startDate : startDate;
|
||
const overlapEnd = schedule.endDate < endDate ? schedule.endDate : endDate;
|
||
if (overlapStart > overlapEnd) return false;
|
||
|
||
const startUtc = this.toUtcDate(overlapStart);
|
||
const endUtc = this.toUtcDate(overlapEnd);
|
||
const startWeekDay = startUtc.getUTCDay() || 7;
|
||
const daysUntilOccurrence = (schedule.weekDay - startWeekDay + 7) % 7;
|
||
startUtc.setUTCDate(startUtc.getUTCDate() + daysUntilOccurrence);
|
||
return startUtc <= endUtc;
|
||
}
|
||
|
||
private toUtcDate(date: string): Date {
|
||
const [year, month, day] = date.split('-').map(Number);
|
||
return new Date(Date.UTC(year, month - 1, day));
|
||
}
|
||
|
||
private addDateRange(dates: Set<string>, startDate: string, endDate: string) {
|
||
const current = this.toUtcDate(startDate);
|
||
const end = this.toUtcDate(endDate);
|
||
while (current <= end) {
|
||
dates.add(current.toISOString().slice(0, 10));
|
||
current.setUTCDate(current.getUTCDate() + 1);
|
||
}
|
||
}
|
||
|
||
private addScheduleOccurrences(
|
||
dates: Set<string>,
|
||
schedule: ClassSchedule,
|
||
startDate: string,
|
||
endDate: string,
|
||
) {
|
||
const overlapStart = schedule.startDate > startDate ? schedule.startDate : startDate;
|
||
const overlapEnd = schedule.endDate < endDate ? schedule.endDate : endDate;
|
||
if (overlapStart > overlapEnd) return;
|
||
|
||
const current = this.toUtcDate(overlapStart);
|
||
const end = this.toUtcDate(overlapEnd);
|
||
const startWeekDay = current.getUTCDay() || 7;
|
||
current.setUTCDate(current.getUTCDate() + ((schedule.weekDay - startWeekDay + 7) % 7));
|
||
while (current <= end) {
|
||
dates.add(current.toISOString().slice(0, 10));
|
||
current.setUTCDate(current.getUTCDate() + 7);
|
||
}
|
||
}
|
||
|
||
async create(dto: CreateRentalDto, userId?: number) {
|
||
if (dto.startDate > dto.endDate) throw new BadRequestException('起始日期不能晚于结束日期');
|
||
const classroom = await this.classroomRepo.findOne({ where: { id: dto.classroomId } });
|
||
if (!classroom) throw new NotFoundException('教室不存在');
|
||
const lessorOrganization = dto.lessorOrganizationId
|
||
? await this.organizationRepo.findOne({
|
||
where: { id: dto.lessorOrganizationId, status: 'active' },
|
||
})
|
||
: await this.organizationRepo.findOne({ where: { isHost: true, status: 'active' } });
|
||
if (!lessorOrganization) throw new NotFoundException('出租机构不存在或未启用');
|
||
const lesseeOrganization = await this.organizationRepo.findOne({
|
||
where: { id: dto.lesseeOrganizationId, status: 'active' },
|
||
});
|
||
if (!lesseeOrganization) throw new NotFoundException('承租机构不存在或未启用');
|
||
if (lessorOrganization.id === lesseeOrganization.id) {
|
||
throw new BadRequestException('出租机构和承租机构不能相同');
|
||
}
|
||
|
||
const conflicts = await this.findConflicts(dto.classroomId, dto.startDate, dto.endDate);
|
||
if (conflicts.length > 0) {
|
||
throw new ConflictException({
|
||
message: '该教室在此时间段已有租赁',
|
||
conflicts: conflicts.map((c) => ({
|
||
id: c.id,
|
||
startDate: c.startDate,
|
||
endDate: c.endDate,
|
||
organizationName: c.lesseeOrganization?.name,
|
||
})),
|
||
});
|
||
}
|
||
const rental = this.repo.create({
|
||
...dto,
|
||
lessorOrganizationId: lessorOrganization.id,
|
||
lesseeOrganizationId: lesseeOrganization.id,
|
||
createdBy: userId,
|
||
status: 'active',
|
||
});
|
||
const saved = await this.repo.save(rental);
|
||
await this.syncScheduleFromRental(saved, lesseeOrganization.name);
|
||
return saved;
|
||
}
|
||
|
||
async update(id: number, dto: UpdateRentalDto) {
|
||
const rental = await this.findOne(id);
|
||
// 若修改了教室/日期，重新冲突检查
|
||
const newClassroomId = dto.classroomId ?? rental.classroomId;
|
||
const newStart = dto.startDate ?? rental.startDate;
|
||
const newEnd = dto.endDate ?? rental.endDate;
|
||
if (newStart > newEnd) throw new BadRequestException('起始日期不能晚于结束日期');
|
||
if (dto.classroomId || dto.startDate || dto.endDate) {
|
||
const conflicts = await this.findConflicts(newClassroomId, newStart, newEnd, id);
|
||
if (conflicts.length > 0) {
|
||
throw new ConflictException({
|
||
message: '修改后时间段与已有租赁冲突',
|
||
conflicts: conflicts.map((c) => ({
|
||
id: c.id,
|
||
startDate: c.startDate,
|
||
endDate: c.endDate,
|
||
organizationName: c.lesseeOrganization?.name,
|
||
})),
|
||
});
|
||
}
|
||
}
|
||
const newLessorId = dto.lessorOrganizationId ?? rental.lessorOrganizationId;
|
||
const newLesseeId = dto.lesseeOrganizationId ?? rental.lesseeOrganizationId;
|
||
if (newLessorId === newLesseeId) {
|
||
throw new BadRequestException('出租机构和承租机构不能相同');
|
||
}
|
||
if (dto.lessorOrganizationId) {
|
||
const lessor = await this.organizationRepo.findOne({
|
||
where: { id: dto.lessorOrganizationId, status: 'active' },
|
||
});
|
||
if (!lessor) throw new NotFoundException('出租机构不存在或未启用');
|
||
}
|
||
if (dto.lesseeOrganizationId) {
|
||
const lessee = await this.organizationRepo.findOne({
|
||
where: { id: dto.lesseeOrganizationId, status: 'active' },
|
||
});
|
||
if (!lessee) throw new NotFoundException('承租机构不存在或未启用');
|
||
}
|
||
await this.repo.update(id, dto);
|
||
const updated = await this.findOne(id);
|
||
if (dto.status === 'cancelled') {
|
||
await this.scheduleRepo.delete({ rentalId: id, scheduleType: 'RENTAL' });
|
||
} else {
|
||
await this.syncScheduleFromRental(updated);
|
||
}
|
||
return updated;
|
||
}
|
||
|
||
async remove(id: number) {
|
||
const rental = await this.findOne(id);
|
||
// 同步删除对应排课记录
|
||
await this.scheduleRepo.delete({ rentalId: id, scheduleType: 'RENTAL' });
|
||
// 同时删除合同文件
|
||
if (rental.contractPath) {
|
||
const full = path.join(this.uploadDir, rental.contractPath);
|
||
if (fs.existsSync(full)) {
|
||
try {
|
||
fs.unlinkSync(full);
|
||
} catch {
|
||
/* ignore */
|
||
}
|
||
}
|
||
}
|
||
await this.repo.delete(id);
|
||
return { message: '删除成功' };
|
||
}
|
||
|
||
/**
|
||
* 同步租赁订单到 class_schedules（schedule_type = 'RENTAL'）
|
||
*/
|
||
private async syncScheduleFromRental(rental: ClassroomRental, organizationName?: string) {
|
||
const name = organizationName || rental.lesseeOrganization?.name || '承租机构';
|
||
const weekDay = this.dateToWeekDay(rental.startDate);
|
||
let schedule = await this.scheduleRepo.findOne({
|
||
where: { rentalId: rental.id, scheduleType: 'RENTAL' },
|
||
});
|
||
const data = {
|
||
classroomId: rental.classroomId,
|
||
classId: null,
|
||
weekDay,
|
||
startTime: '00:00',
|
||
endTime: '23:59',
|
||
startDate: rental.startDate,
|
||
endDate: rental.endDate,
|
||
subject: `${name} 租赁`,
|
||
teacherId: null,
|
||
scheduleType: 'RENTAL',
|
||
rentalId: rental.id,
|
||
status: 'active',
|
||
notes: rental.notes,
|
||
};
|
||
if (schedule) {
|
||
await this.scheduleRepo.update(schedule.id, data);
|
||
} else {
|
||
schedule = this.scheduleRepo.create(data);
|
||
await this.scheduleRepo.save(schedule);
|
||
}
|
||
}
|
||
|
||
private dateToWeekDay(date: string): number {
|
||
const d = new Date(date);
|
||
const day = d.getDay();
|
||
return day === 0 ? 7 : day;
|
||
}
|
||
|
||
async attachContract(id: number, file: Express.Multer.File) {
|
||
const rental = await this.findOne(id);
|
||
this.ensureUploadDir();
|
||
// 安全校验：MIME + 扩展名
|
||
if (file.mimetype !== 'application/pdf') {
|
||
throw new BadRequestException('仅支持 PDF 文件');
|
||
}
|
||
const ext = path.extname(file.originalname).toLowerCase();
|
||
if (ext !== '.pdf') throw new BadRequestException('文件扩展名必须为 .pdf');
|
||
// UUID 文件名
|
||
const uuid =
|
||
(globalThis as any).crypto?.randomUUID?.() ||
|
||
require('crypto').randomBytes(16).toString('hex');
|
||
const filename = `${uuid}.pdf`;
|
||
const fullPath = path.join(this.uploadDir, filename);
|
||
// 路径遍历防护
|
||
if (!fullPath.startsWith(this.uploadDir)) throw new BadRequestException('路径非法');
|
||
// 删除旧文件
|
||
if (rental.contractPath) {
|
||
const oldPath = path.join(this.uploadDir, rental.contractPath);
|
||
if (fs.existsSync(oldPath)) {
|
||
try {
|
||
fs.unlinkSync(oldPath);
|
||
} catch {
|
||
/* ignore */
|
||
}
|
||
}
|
||
}
|
||
fs.writeFileSync(fullPath, file.buffer);
|
||
await this.repo.update(id, {
|
||
contractPath: filename,
|
||
contractOriginalName: file.originalname,
|
||
});
|
||
return this.findOne(id);
|
||
}
|
||
|
||
async removeContract(id: number) {
|
||
const rental = await this.findOne(id);
|
||
if (!rental.contractPath) throw new BadRequestException('该租赁未上传合同');
|
||
const fullPath = path.join(this.uploadDir, rental.contractPath);
|
||
if (fs.existsSync(fullPath)) {
|
||
try {
|
||
fs.unlinkSync(fullPath);
|
||
} catch {
|
||
/* ignore */
|
||
}
|
||
}
|
||
await this.repo.update(id, { contractPath: null as any, contractOriginalName: null as any });
|
||
return { message: '合同已删除' };
|
||
}
|
||
|
||
/**
|
||
* 获取合同文件的绝对路径（供控制器流式返回），严格校验路径安全
|
||
*/
|
||
async getContractPath(id: number): Promise<{ fullPath: string; originalName: string }> {
|
||
const rental = await this.findOne(id);
|
||
if (!rental.contractPath) throw new NotFoundException('该租赁未上传合同');
|
||
const fullPath = path.join(this.uploadDir, rental.contractPath);
|
||
if (!fullPath.startsWith(this.uploadDir)) throw new BadRequestException('路径非法');
|
||
if (!fs.existsSync(fullPath)) throw new NotFoundException('合同文件丢失');
|
||
return { fullPath, originalName: rental.contractOriginalName || 'contract.pdf' };
|
||
}
|
||
|
||
/**
|
||
* 获取月度排期矩阵
|
||
*/
|
||
async getSchedule(year: number, month: number) {
|
||
const lastDay = new Date(year, month, 0).getDate();
|
||
const first = `${year}-${String(month).padStart(2, '0')}-01`;
|
||
const last = `${year}-${String(month).padStart(2, '0')}-${String(lastDay).padStart(2, '0')}`;
|
||
|
||
const classrooms = await this.classroomRepo.find({
|
||
where: { status: Not('archived') },
|
||
order: { building: 'ASC', name: 'ASC' },
|
||
});
|
||
const rentals = await this.repo
|
||
.createQueryBuilder('r')
|
||
.leftJoinAndSelect('r.lesseeOrganization', 'lesseeOrganization')
|
||
.leftJoinAndSelect('r.classroom', 'classroom')
|
||
.where('r.status != :cancelled', { cancelled: 'cancelled' })
|
||
.andWhere('r.startDate <= :last AND r.endDate >= :first', { first, last })
|
||
.getMany();
|
||
|
||
const organizationMap = new Map<number, any>();
|
||
const matrix: Record<number, Record<number, any>> = {};
|
||
const summary: Record<
|
||
number,
|
||
{ totalDays: number; rentedDays: number; idleDays: number; occupancyRate: number }
|
||
> = {};
|
||
|
||
for (const cls of classrooms) {
|
||
matrix[cls.id] = {};
|
||
summary[cls.id] = { totalDays: lastDay, rentedDays: 0, idleDays: lastDay, occupancyRate: 0 };
|
||
}
|
||
|
||
for (const rental of rentals) {
|
||
const start = new Date(rental.startDate);
|
||
const end = new Date(rental.endDate);
|
||
const monthStart = new Date(first);
|
||
const monthEnd = new Date(last);
|
||
const effStart = start < monthStart ? monthStart : start;
|
||
const effEnd = end > monthEnd ? monthEnd : end;
|
||
if (rental.lesseeOrganization && !organizationMap.has(rental.lesseeOrganization.id)) {
|
||
organizationMap.set(rental.lesseeOrganization.id, {
|
||
id: rental.lesseeOrganization.id,
|
||
name: rental.lesseeOrganization.name,
|
||
color:
|
||
rental.lesseeOrganization.color ||
|
||
COLOR_PALETTE[rental.lesseeOrganization.id % COLOR_PALETTE.length],
|
||
});
|
||
}
|
||
for (let d = new Date(effStart); d <= effEnd; d.setDate(d.getDate() + 1)) {
|
||
const day = d.getDate();
|
||
if (!matrix[rental.classroomId]) continue;
|
||
matrix[rental.classroomId][day] = {
|
||
scheduleType: 'RENTAL',
|
||
rentalId: rental.id,
|
||
organizationId: rental.lesseeOrganizationId,
|
||
organizationName: rental.lesseeOrganization?.name || '未知',
|
||
color:
|
||
rental.lesseeOrganization?.color ||
|
||
COLOR_PALETTE[(rental.lesseeOrganizationId || 0) % COLOR_PALETTE.length],
|
||
hasContract: !!rental.contractPath,
|
||
};
|
||
}
|
||
}
|
||
|
||
// ── Overlay internal class schedules ──
|
||
const schedules = await this.scheduleRepo
|
||
.createQueryBuilder('s')
|
||
.leftJoinAndSelect('s.class', 'class')
|
||
.leftJoinAndSelect('s.teacher', 'teacher')
|
||
.where('s.status = :active', { active: 'active' })
|
||
.andWhere('s.scheduleType = :type', { type: 'INTERNAL' })
|
||
.andWhere('s.startDate <= :last AND s.endDate >= :first', { first, last })
|
||
.getMany();
|
||
|
||
for (const sched of schedules) {
|
||
if (!sched.classroomId) continue;
|
||
const schedStart = new Date(
|
||
Math.max(new Date(sched.startDate).getTime(), new Date(first).getTime()),
|
||
);
|
||
const schedEnd = new Date(
|
||
Math.min(new Date(sched.endDate).getTime(), new Date(last).getTime()),
|
||
);
|
||
for (let d = new Date(schedStart); d <= schedEnd; d.setDate(d.getDate() + 1)) {
|
||
const dow = d.getDay() === 0 ? 7 : d.getDay();
|
||
if (dow !== sched.weekDay) continue;
|
||
const day = d.getDate();
|
||
if (!matrix[sched.classroomId]) continue;
|
||
matrix[sched.classroomId][day] = {
|
||
scheduleType: 'INTERNAL',
|
||
scheduleId: sched.id,
|
||
className: (sched.class as any)?.name || '',
|
||
subject: sched.subject,
|
||
teacherName: (sched.teacher as any)?.name || '',
|
||
startTime: sched.startTime,
|
||
endTime: sched.endTime,
|
||
color: '#52c41a',
|
||
};
|
||
}
|
||
}
|
||
// 统计
|
||
for (const cls of classrooms) {
|
||
const rented = Object.keys(matrix[cls.id]).length;
|
||
summary[cls.id].rentedDays = rented;
|
||
summary[cls.id].idleDays = lastDay - rented;
|
||
summary[cls.id].occupancyRate = lastDay > 0 ? Math.round((rented / lastDay) * 100) / 100 : 0;
|
||
}
|
||
|
||
return {
|
||
year,
|
||
month,
|
||
days: lastDay,
|
||
classrooms: classrooms.map((c) => ({
|
||
id: c.id,
|
||
name: c.name,
|
||
building: c.building,
|
||
floor: c.floor,
|
||
roomType: c.roomType,
|
||
capacity: c.capacity,
|
||
supervisor: c.supervisor,
|
||
})),
|
||
organizations: Array.from(organizationMap.values()),
|
||
matrix,
|
||
summary,
|
||
};
|
||
}
|
||
}
|