@dssp/project 0.0.2

package/server/service/index.ts

@@ -0,0 +1,35 @@
+/* EXPORT ENTITY TYPES */
+export * from './resource/resource'
+export * from './check-item/check-item'
+export * from './checklist/checklist'
+export * from './task/task'
+export * from './project/project'
+
+/* IMPORT ENTITIES AND RESOLVERS */
+import { entities as ResourceEntities, resolvers as ResourceResolvers } from './resource'
+import { entities as CheckItemEntities, resolvers as CheckItemResolvers } from './check-item'
+import { entities as ChecklistEntities, resolvers as ChecklistResolvers } from './checklist'
+import { entities as TaskEntities, resolvers as TaskResolvers } from './task'
+import { entities as ProjectEntities, resolvers as ProjectResolvers, types as ProjectTypes } from './project'
+
+export const entities = [
+  /* ENTITIES */
+  ...ResourceEntities,
+  ...CheckItemEntities,
+  ...ChecklistEntities,
+  ...TaskEntities,
+  ...ProjectEntities
+]
+
+export const schema = {
+  resolverClasses: [
+    /* RESOLVER CLASSES */
+    ...ResourceResolvers,
+    ...CheckItemResolvers,
+    ...ChecklistResolvers,
+    ...TaskResolvers,
+    ...ProjectResolvers
+  ]
+}
+
+export const types = [...ProjectTypes]

package/server/service/project/index.ts

@@ -0,0 +1,8 @@
+import { Project } from './project'
+import { ProjectQuery } from './project-query'
+import { ProjectMutation } from './project-mutation'
+import { InspectionSummary } from './project-type'
+
+export const entities = [Project]
+export const resolvers = [ProjectQuery, ProjectMutation]
+export const types = [InspectionSummary]

package/server/service/project/project-mutation.ts

@@ -0,0 +1,201 @@
+import { Resolver, Mutation, Arg, Args, Ctx, Directive } from 'type-graphql'
+import { In, Not } from 'typeorm'
+
+import { createAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
+
+import { Project } from './project'
+import { NewProject, ProjectPatch } from './project-type'
+import { BuildingComplex, Building, BuildingLevel } from '@dssp/building-complex'
+
+@Resolver(Project)
+export class ProjectMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Project, { description: '프로젝트 생성' })
+  async createProject(@Arg('project') project: NewProject, @Ctx() context: ResolverContext): Promise<Project> {
+    const { domain, user, tx } = context.state
+    const projectRepo = tx.getRepository(Project)
+    const buildingComplexRepo = tx.getRepository(BuildingComplex)
+
+    const newBuildingComplex = await buildingComplexRepo.save({
+      domain,
+      creator: user,
+      updater: user
+    })
+
+    const result = await projectRepo.save({
+      name: project.name,
+      buildingComplex: newBuildingComplex,
+      domain,
+      creator: user,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Project, { description: '프로젝트 업데이트' })
+  async updateProject(@Arg('project') project: ProjectPatch, @Ctx() context: ResolverContext): Promise<Project> {
+    const { user, tx } = context.state
+    const projectRepo = tx.getRepository(Project)
+    const buildingComplexRepo = tx.getRepository(BuildingComplex)
+    const buildingRepo = tx.getRepository(Building)
+    const buildingLevelRepo = tx.getRepository(BuildingLevel)
+
+    const buildingComplex = project.buildingComplex
+    const buildings = project.buildingComplex?.buildings || []
+
+    // 1. 프로젝트 수정
+    const projectResult = await projectRepo.save({ ...project, updater: user })
+
+    // 2. 단지 정보 수정
+    await buildingComplexRepo.save({ ...buildingComplex, updater: user })
+
+    // 2-1. 프로젝트 메인 이미지 첨부파일 나머지 삭제 후 저장 (null로 오면 삭제만)
+    if (project.mainPhotoUpload !== undefined) {
+      await deleteAttachmentsByRef(null, { refBys: [project.id] }, context)
+
+      if (project.mainPhotoUpload) {
+        await createAttachment(
+          null,
+          {
+            attachment: {
+              file: project.mainPhotoUpload,
+              refType: Project.name,
+              refBy: project.id
+            }
+          },
+          context
+        )
+      }
+    }
+
+    // 2-2. 단지 BIM 이미지 첨부파일 나머지 삭제 후 저장 (null로 오면 삭제만)
+    if (buildingComplex.drawingUpload !== undefined) {
+      await deleteAttachmentsByRef(null, { refBys: [buildingComplex.id] }, context)
+
+      if (buildingComplex.drawingUpload) {
+        await createAttachment(
+          null,
+          {
+            attachment: {
+              file: buildingComplex.drawingUpload,
+              refType: BuildingComplex.name,
+              refBy: buildingComplex.id
+            }
+          },
+          context
+        )
+      }
+    }
+
+    // 3. 동의 층 정보가 바뀌었으면 층 초기화 후 다시 생성
+    const originBuilding = await buildingRepo.findBy({ buildingComplex: { id: buildingComplex.id } }) // 이전 동 정보 가져오기
+    const afterBuilding = buildings.reduce((acc, building) => ({ ...acc, [building.name]: building.floorCount }), {}) // 비교용으로 수정된 동 정보 데이터 파싱
+    const isBuidlingChanged = originBuilding.some(building => afterBuilding[building.name] !== building.floorCount) // 층 개수가 달라진 동이 있는지 확인
+
+    // 동의 층 개수가 달라지면 모든 층의 데이터 제거 후 생성
+    if (isBuidlingChanged || originBuilding.length !== buildings.length) {
+      // 3-1. 기존 동/층 첨부파일 및 데이터 제거
+      const buildingIds = originBuilding.map((building: Building) => building.id)
+      const buildingLevels = await buildingLevelRepo.findBy({ building: { id: In(buildingIds) } })
+      const buildingLevelIds = buildingLevels.map((buildingLevel: BuildingLevel) => buildingLevel.id)
+
+      await buildingLevelRepo.softDelete({ building: { id: In(buildingIds) } })
+      await buildingRepo.softDelete({ id: In(buildingIds) })
+      await deleteAttachmentsByRef(null, { refBys: [...buildingIds, ...buildingLevelIds] }, context)
+
+      buildings.forEach(async (building: Building) => {
+        // 3-2. 단지 내 동 정보들 생성
+        const newBuilding = await buildingRepo.save({
+          buildingComplex: buildingComplex,
+          name: building.name,
+          floorCount: building.floorCount,
+          creator: user
+        })
+
+        // 3-3. 동별로 for문 돌면서 층 데이터 개수대로 생성
+        for (let i = 1; i <= building.floorCount; i++) {
+          await buildingLevelRepo.save({ building: newBuilding, floor: i, creator: user })
+        }
+      })
+    }
+
+    return projectResult
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Project, { description: '프로젝트 도면 업데이트' })
+  async updateProjectPlan(@Arg('project') project: ProjectPatch, @Ctx() context: ResolverContext): Promise<Project> {
+    const { user, tx } = context.state
+    const projectRepo = tx.getRepository(Project)
+    const buildingComplexRepo = tx.getRepository(BuildingComplex)
+    const buildingComplex = project.buildingComplex
+    const buildings: Building[] = project.buildingComplex?.buildings || []
+
+    // 1. 프로젝트 수정 시간 업데이트
+    const projectResult = await projectRepo.save({ ...project, updater: user })
+
+    // 2. 단지 축척 정보 수정
+    await buildingComplexRepo.save({ ...buildingComplex, updater: user })
+
+    for (let buildingKey in buildings) {
+      const building = buildings[buildingKey]
+
+      for (let buildingLevelKey in building.buildingLevels) {
+        const buildingLevel = building.buildingLevels[buildingLevelKey]
+
+        // 3. 층별 도면 이미지 저장 (null로 오면 삭제만)
+        if (buildingLevel?.mainDrawingUpload !== undefined) {
+          await deleteAttachmentsByRef(null, { refBys: [buildingLevel.id] }, context)
+
+          if (buildingLevel?.mainDrawingUpload) {
+            await createAttachment(
+              null,
+              {
+                attachment: {
+                  file: buildingLevel.mainDrawingUpload,
+                  refType: BuildingLevel.name,
+                  refBy: buildingLevel.id
+                }
+              },
+              context
+            )
+          }
+        }
+      }
+
+      // 4. 동별 도면 이미지 저장 (null로 오면 삭제만)
+      if (building?.drawingUpload !== undefined) {
+        await deleteAttachmentsByRef(null, { refBys: [building.id] }, context)
+
+        if (building?.drawingUpload) {
+          await createAttachment(
+            null,
+            {
+              attachment: {
+                file: building.drawingUpload,
+                refType: Building.name,
+                refBy: building.id
+              }
+            },
+            context
+          )
+        }
+      }
+    }
+
+    return projectResult
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete Project' })
+  async deleteProject(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Project).delete({ domain: { id: domain.id }, id })
+    await deleteAttachmentsByRef(null, { refBys: [id] }, context)
+
+    return true
+  }
+}

package/server/service/project/project-query.ts

@@ -0,0 +1,103 @@
+import { Resolver, Query, FieldResolver, Root, Arg, Ctx } from 'type-graphql'
+import { Domain, getRepository } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { Project } from './project'
+import { InspectionSummary, ProjectList } from './project-type'
+import { BuildingComplex, InspectionType } from '@dssp/building-complex'
+import { Attachment } from '@things-factory/attachment-base'
+
+@Resolver(Project)
+export class ProjectQuery {
+  @Query(returns => Project!, { nullable: true, description: 'To fetch a Project' })
+  async project(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Project> {
+    const { domain } = context.state
+
+    return await getRepository(Project).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Query(returns => ProjectList, { description: '프로젝트 리스트' })
+  async projects(@Arg('projectName') projectName: string, @Ctx() context: ResolverContext): Promise<ProjectList> {
+    const { domain } = context.state
+    // const { page = 1, limit = 0 } = params.pagination || {}
+
+    const queryBuilder = await getRepository(Project)
+      .createQueryBuilder('p')
+      .innerJoinAndSelect('p.buildingComplex', 'bc')
+      .where('p.domain = :domain', { domain: domain.id })
+      .orderBy('p.created_at', 'DESC')
+    // .offset((page - 1) * limit)
+    // .limit(limit)
+
+    if (projectName) {
+      projectName = `%${projectName}%`
+      queryBuilder.andWhere('p.name LIKE :projectName', { projectName })
+    }
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @Query(returns => InspectionSummary, { description: '프로젝트의 검측상태 별 카운트' })
+  async inspectionSummary(
+    @Arg('projectId') projectId: string,
+    @Ctx() context: ResolverContext
+  ): Promise<InspectionSummary> {
+    const { domain } = context.state
+
+    const queryBuilder = getRepository(Project)
+      .createQueryBuilder('p')
+      .select(`COUNT(CASE WHEN bi.type="${InspectionType.REQUEST}" THEN 1 ELSE NULL END) AS request`)
+      .addSelect(`COUNT(CASE WHEN bi.type="${InspectionType.PASS}" THEN 1 ELSE NULL END) AS pass`)
+      .addSelect(`COUNT(CASE WHEN bi.type="${InspectionType.FAIL}" THEN 1 ELSE NULL END) AS fail`)
+      .innerJoin('p.buildingComplex', 'bc')
+      .innerJoin('bc.buildings', 'b')
+      .innerJoin('b.buildingLevels', 'bl')
+      .innerJoin('bl.buildingInspections', 'bi')
+      .where('p.domain = :domain', { domain: domain.id })
+      .andWhere('p.id = :projectId', { projectId })
+      .groupBy('p.id')
+
+    const result = (await queryBuilder.getRawOne()) || {}
+    return {
+      request: result.request || 0,
+      pass: result.pass || 0,
+      fail: result.fail || 0
+    }
+  }
+
+  @FieldResolver(type => Attachment)
+  async mainPhoto(@Root() project: Project): Promise<string | Attachment> {
+    const attachment: Attachment = await getRepository(Attachment).findOne({
+      where: {
+        domain: { id: project.domainId },
+        refBy: project.id
+      },
+      order: { createdAt: 'ASC' }
+    })
+
+    return attachment
+  }
+
+  @FieldResolver(type => BuildingComplex)
+  async buildingComplex(@Root() project: Project): Promise<BuildingComplex> {
+    return await getRepository(BuildingComplex).findOneBy({ id: project.buildingComplexId })
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() project: Project): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: project.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() project: Project): Promise<User> {
+    return await getRepository(User).findOneBy({ id: project.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() project: Project): Promise<User> {
+    return await getRepository(User).findOneBy({ id: project.creatorId })
+  }
+}

package/server/service/project/project-type.ts

@@ -0,0 +1,71 @@
+import { ObjectType, Field, InputType, Int, Float } from 'type-graphql'
+import { Project } from './project'
+import { BuildingComplexPatch } from '@dssp/building-complex'
+import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
+import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
+
+@InputType()
+export class NewProject {
+  @Field({ nullable: false })
+  name: string
+}
+
+@InputType()
+export class ProjectPatch {
+  @Field({ nullable: false })
+  id: string
+
+  @Field({ nullable: false })
+  name: string
+
+  @Field({ nullable: true })
+  startDate?: string
+
+  @Field({ nullable: true })
+  endDate?: string
+
+  @Field(type => GraphQLUpload, { nullable: true })
+  mainPhotoUpload?: FileUpload
+
+  @Field(type => Float, { nullable: true })
+  totalProgress?: number
+
+  @Field(type => Float, { nullable: true })
+  weeklyProgress?: number
+
+  @Field(type => Float, { nullable: true })
+  kpi?: number
+
+  @Field(type => Float, { nullable: true })
+  inspPassRate?: number
+
+  @Field(type => Float, { nullable: true })
+  robotProgressRate?: number
+
+  @Field(type => Float, { nullable: true })
+  structuralSafetyRate?: number
+
+  @Field({ nullable: true })
+  buildingComplex?: BuildingComplexPatch
+}
+
+@ObjectType()
+export class ProjectList {
+  @Field(type => [Project])
+  items: Project[]
+
+  @Field(type => Int)
+  total: number
+}
+
+@ObjectType()
+export class InspectionSummary {
+  @Field(type => Int)
+  request: number
+
+  @Field(type => Int)
+  pass: number
+
+  @Field(type => Int)
+  fail: number
+}

package/server/service/project/project.ts

@@ -0,0 +1,131 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  DeleteDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  OneToOne,
+  OneToMany,
+  JoinColumn,
+  PrimaryGeneratedColumn
+} from 'typeorm'
+import { ObjectType, Field, ID, registerEnumType } from 'type-graphql'
+
+import { Domain, roundTransformer } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { Task } from '../task/task'
+import { BuildingComplex } from '@dssp/building-complex'
+import { Attachment } from '@things-factory/attachment-base'
+
+export enum ProjectStatus {
+  'PROCEEDING' = '10',
+  'COMPLICATED' = '20'
+}
+
+registerEnumType(ProjectStatus, {
+  name: 'ProjectStatus',
+  description: '프로젝트 상태'
+})
+
+@Entity()
+@Index('ix_project_0', (project: Project) => [project.buildingComplex], { unique: true, where: '"deleted_at" IS NULL' })
+@ObjectType({ description: '프로젝트' })
+export class Project {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((project: Project) => project.domain)
+  domainId?: string
+
+  @Column({ nullable: false, comment: '프로젝트 이름' })
+  @Field({ nullable: false })
+  name?: string
+
+  @Column({ nullable: false, default: ProjectStatus.PROCEEDING, comment: '프로젝트 상태 (10: 진행중, 20: 완료)' })
+  @Field({ nullable: false })
+  state?: ProjectStatus
+
+  @Column({ type: 'date', nullable: true, comment: '착공일정' })
+  @Field({ nullable: true })
+  startDate?: string
+
+  @Column({ type: 'date', nullable: true, comment: '준공일정' })
+  @Field({ nullable: true })
+  endDate?: string
+
+  // 대표 사진
+  @Field(type => Attachment, { nullable: true })
+  mainPhoto?: Attachment
+
+  @Column({ type: 'float', nullable: true, default: 0, transformer: roundTransformer, comment: '전체 진행현황' })
+  @Field({ nullable: true })
+  totalProgress?: number
+
+  @Column({ type: 'float', nullable: true, default: 0, transformer: roundTransformer, comment: '주간 진행현황' })
+  @Field({ nullable: true })
+  weeklyProgress?: number
+
+  @Column({ type: 'float', nullable: true, default: 0, transformer: roundTransformer, comment: 'KPI' })
+  @Field({ nullable: true })
+  kpi?: number
+
+  @Column({ type: 'float', nullable: true, default: 0, transformer: roundTransformer, comment: '검측/통과 비율' })
+  @Field({ nullable: true })
+  inspPassRate?: number
+
+  @Column({ type: 'float', nullable: true, default: 0, transformer: roundTransformer, comment: '로봇 작업 진행율' })
+  @Field({ nullable: true })
+  robotProgressRate?: number
+
+  @Column({ type: 'float', nullable: true, default: 0, transformer: roundTransformer, comment: '구조 안전도' })
+  @Field({ nullable: true })
+  structuralSafetyRate?: number
+
+  // 단지 정보 (1:1 테이블 참조)
+  @OneToOne(type => BuildingComplex)
+  @JoinColumn()
+  @Field({ nullable: true })
+  buildingComplex?: BuildingComplex
+
+  @RelationId((project: Project) => project.buildingComplex)
+  buildingComplexId?: string
+
+  // 작업 정보 (하위 테이블 참조)
+  @Field(() => [Task], { nullable: true })
+  @OneToMany(() => Task, task => task.project)
+  tasks?: Task[]
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @DeleteDateColumn()
+  @Field({ nullable: true })
+  deletedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((project: Project) => project.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((project: Project) => project.updater)
+  updaterId?: string
+}

package/server/service/resource/index.ts

@@ -0,0 +1,6 @@
+import { Resource } from './resource'
+import { ResourceQuery } from './resource-query'
+import { ResourceMutation } from './resource-mutation'
+
+export const entities = [Resource]
+export const resolvers = [ResourceQuery, ResourceMutation]

package/server/service/resource/resource-mutation.ts

@@ -0,0 +1,139 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { createAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
+
+import { Resource } from './resource'
+import { NewResource, ResourcePatch } from './resource-type'
+
+@Resolver(Resource)
+export class ResourceMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Resource, { description: 'To create new Resource' })
+  async createResource(@Arg('resource') resource: NewResource, @Ctx() context: ResolverContext): Promise<Resource> {
+    const { domain, user, tx } = context.state
+
+    const result = await tx.getRepository(Resource).save({
+      ...resource,
+      domain,
+      creator: user,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Resource, { description: 'To modify Resource information' })
+  async updateResource(
+    @Arg('id') id: string,
+    @Arg('patch') patch: ResourcePatch,
+    @Ctx() context: ResolverContext
+  ): Promise<Resource> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(Resource)
+    const resource = await repository.findOne({
+      where: { id }
+    })
+
+    const result = await repository.save({
+      ...resource,
+      ...patch,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [Resource], { description: "To modify multiple Resources' information" })
+  async updateMultipleResource(
+    @Arg('patches', type => [ResourcePatch]) patches: ResourcePatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<Resource[]> {
+    const { domain, user, tx } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const resourceRepo = tx.getRepository(Resource)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await resourceRepo.save({
+          ...newRecord,
+          domain,
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const updateRecord = _updateRecords[i]
+        const resource = await resourceRepo.findOneBy({ id: updateRecord.id })
+
+        const result = await resourceRepo.save({
+          ...resource,
+          ...updateRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete Resource' })
+  async deleteResource(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Resource).delete({ id })
+    await deleteAttachmentsByRef(null, { refBys: [id] }, context)
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple Resources' })
+  async deleteResources(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Resource).delete({
+      id: In(ids)
+    })
+
+    await deleteAttachmentsByRef(null, { refBys: ids }, context)
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To import multiple Resources' })
+  async importResources(
+    @Arg('resources', type => [ResourcePatch]) resources: ResourcePatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await Promise.all(
+      resources.map(async (resource: ResourcePatch) => {
+        const createdResource: Resource = await tx.getRepository(Resource).save({ domain, ...resource })
+      })
+    )
+
+    return true
+  }
+}