@dssp/project 1.0.0-alpha.0 → 1.0.0-alpha.1

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

@@ -1,255 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { In } from 'typeorm'
-import { getRepository } from '@things-factory/shell'
-import { Attachment, createAttachment, deleteAttachmentsByRef, ATTACHMENT_PATH } from '@things-factory/attachment-base'
-import { Project, ProjectState } from './project'
-import { NewProject, ProjectPatch, UploadProjectScheduleTable } from './project-type'
-import { BuildingComplex, Building, BuildingLevel } from '@dssp/building-complex'
-import { pdfToImage } from '@things-factory/board-service/dist-server/controllers/headless-pdf-to-image'
-
-import { parseExcelAndImportTasks } from '../../controllers/parse-excel'
-@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 = getRepository(Project, tx)
-    const buildingComplexRepo = getRepository(BuildingComplex, tx)
-
-    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 = getRepository(Project, tx)
-    const buildingComplexRepo = getRepository(BuildingComplex, tx)
-    const buildingRepo = getRepository(Building, tx)
-    const buildingLevelRepo = getRepository(BuildingLevel, tx)
-
-    const buildingComplex = project.buildingComplex
-    const buildings = project.buildingComplex?.buildings || []
-
-    // 1. 프로젝트 수정
-    const projectState = project.totalProgress == 100 ? ProjectState.COMPLETED : ProjectState.ONGOING
-    const projectResult = await projectRepo.save({ ...project, state: projectState, updater: user })
-
-    // 2. 단지 정보 수정
-    await buildingComplexRepo.save({ ...buildingComplex, updater: user })
-
-    // 2-1. 프로젝트 메인 이미지 첨부파일 나머지 삭제 후 저장
-    await createAttachmentAfterDelete(context, project?.mainPhotoUpload, project.id, Project.name)
-
-    // 2-2. 단지 BIM 이미지 첨부파일 나머지 삭제 후 저장
-    await createAttachmentAfterDelete(context, buildingComplex?.drawingUpload, buildingComplex.id, BuildingComplex.name + '_bim')
-
-    // 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)
-
-      // 3-2. 단지 내 동 정보들 생성
-      for (let buildingKey in buildings) {
-        const building = buildings[buildingKey]
-        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, domain } = context.state
-    const projectRepo = getRepository(Project, tx)
-    const buildingComplexRepo = getRepository(BuildingComplex, tx)
-    const buildingRepo = getRepository(Building, tx)
-    const buildingLevelRepo = getRepository(BuildingLevel, tx)
-    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 })
-
-    for (let buildingKey in buildings) {
-      const building = buildings[buildingKey]
-
-      for (let buildingLevelKey in building.buildingLevels) {
-        const buildingLevel = building.buildingLevels[buildingLevelKey]
-
-        // 3. 층별 도면 이미지 저장
-        const mainDrawingAttatchment = await createAttachmentAfterDelete(
-          context,
-          buildingLevel.mainDrawingUpload,
-          buildingLevel.id,
-          BuildingLevel.name + '_mainDrawing'
-        )
-        // 첨부된 PDF가 있으면 PDF 파일대로 썸네일 생성
-        if (mainDrawingAttatchment) {
-          const mainDrawingUpload = await buildingLevel.mainDrawingUpload
-          const pdfPath = `/${ATTACHMENT_PATH}/${mainDrawingAttatchment.path}` // TODO ATTACHMENT_PATH 제거, mainDrawingAttachment.fullpath 로 해도 될 것 같은데...
-          const fileName = mainDrawingUpload.filename.replace('.pdf', '')
-          const pngFile = await pdfToImage({ pdfPath, fileName })
-          await createAttachmentAfterDelete(context, pngFile, buildingLevel.id, BuildingLevel.name + '_mainDrawing_image')
-
-          const pngThumbnailFile = await pdfToImage({ pdfPath, fileName, defaultViewport: { width: 300, height: 200 } })
-          await createAttachmentAfterDelete(
-            context,
-            pngThumbnailFile,
-            buildingLevel.id,
-            BuildingLevel.name + '_mainDrawing_thumbnail'
-          )
-        }
-
-        // 3-1. 입면도 파일 저장
-        const elevationDrawingAttatchment = await createAttachmentAfterDelete(
-          context,
-          buildingLevel.elevationDrawingUpload,
-          buildingLevel.id,
-          BuildingLevel.name + '_elevationDrawing'
-        )
-        if (elevationDrawingAttatchment) {
-          const elevationDrawingUpload = await buildingLevel.elevationDrawingUpload
-          const pdfPath = `/${ATTACHMENT_PATH}/${elevationDrawingAttatchment.path}`
-          const fileName = elevationDrawingUpload.filename.replace('.pdf', '')
-          const pngThumbnailFile = await pdfToImage({ pdfPath, fileName, defaultViewport: { width: 300, height: 200 } })
-          await createAttachmentAfterDelete(
-            context,
-            pngThumbnailFile,
-            buildingLevel.id,
-            BuildingLevel.name + '_elevationDrawing_thumbnail'
-          )
-        }
-
-        // 3-2. 철근배분도 파일 저장
-        const rebarDistributionDrawingAttatchment = await createAttachmentAfterDelete(
-          context,
-          buildingLevel.rebarDistributionDrawingUpload,
-          buildingLevel.id,
-          BuildingLevel.name + '_rebarDistributionDrawing'
-        )
-        if (rebarDistributionDrawingAttatchment) {
-          const rebarDistributionDrawingUpload = await buildingLevel.rebarDistributionDrawingUpload
-          const pdfPath = `/${ATTACHMENT_PATH}/${rebarDistributionDrawingAttatchment.path}`
-          const fileName = rebarDistributionDrawingUpload.filename.replace('.pdf', '')
-          const pngThumbnailFile = await pdfToImage({ pdfPath, fileName, defaultViewport: { width: 300, height: 200 } })
-          await createAttachmentAfterDelete(
-            context,
-            pngThumbnailFile,
-            buildingLevel.id,
-            BuildingLevel.name + '_rebarDistributionDrawing_thumbnail'
-          )
-        }
-
-        // 3-3. 층 업데이트 시간 갱신
-        await buildingLevelRepo.save({ ...buildingLevel, updater: user })
-      }
-
-      // 4. 동별 도면 이미지 저장
-      await createAttachmentAfterDelete(context, building?.drawingUpload, building.id, Building.name)
-
-      // 4-1. 동 업데이트 시간 갱신
-      await buildingRepo.save({ ...building, updater: user })
-    }
-
-    return projectResult
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: '프로젝트 공정표 업로드' })
-  async uploadProjectScheduleTable(
-    @Arg('param') param: UploadProjectScheduleTable,
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, user, tx } = context.state
-    const { projectId, scheduleTable } = param
-
-    const projectRepo = getRepository(Project, tx)
-    const project = await projectRepo.findOne({
-      where: { domain: { id: domain.id }, id: projectId }
-    })
-
-    const { createReadStream, filename, mimetype } = await scheduleTable
-
-    const stream = createReadStream()
-
-    const chunks = []
-    for await (const chunk of stream) {
-      chunks.push(chunk)
-    }
-
-    const buffer = Buffer.concat(chunks)
-
-    await parseExcelAndImportTasks(buffer, project, context)
-    // await parseExcelAndImportTasks(attachment.fullpath, project, context)
-
-    return true
-  }
-
-  @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 getRepository(Project, tx).delete({ domain: { id: domain.id }, id })
-    await deleteAttachmentsByRef(null, { refBys: [id] }, context)
-
-    return true
-  }
-}
-
-export async function createAttachmentAfterDelete(context: ResolverContext, file: any, refBy: any, refType: any) {
-  if (file === undefined) {
-    return null
-  }
-
-  const { tx } = context.state
-
-  // 기존 첨부 파일이 있으면 삭제
-  await deleteAttachmentsByRef(null, { refBys: [refBy], refType }, context)
-
-  let result = await createAttachment(null, { attachment: { file, refType, refBy } }, context)
-
-  return await getRepository(Attachment, tx).findOne({ where: { id: result.id } })
-}

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

@@ -1,105 +0,0 @@
-import { Resolver, Query, FieldResolver, Root, Arg, Args, Ctx } from 'type-graphql'
-import { IsNull } from 'typeorm'
-import { Domain, getRepository, ListParam, getQueryBuilderFromListParams } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { Project } from './project'
-import { Task } from '../task/task'
-import { ProjectList } from './project-type'
-import { Attachment } from '@things-factory/attachment-base'
-import { BuildingComplex } from '@dssp/building-complex'
-
-@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(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ProjectList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: await getRepository(Project),
-      searchables: ['name', 'description', 'state']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @Query(returns => Project!, { nullable: true, description: 'To fetch a Project' })
-  async projectByBuildingComplexId(
-    @Arg('buildingComplexId') buildingComplexId: string,
-    @Ctx() context: ResolverContext
-  ): Promise<Project> {
-    const { domain } = context.state
-
-    return await getRepository(Project).findOne({
-      where: { domain: { id: domain.id }, buildingComplex: { id: buildingComplexId } }
-    })
-  }
-
-  @FieldResolver(type => [Task], { nullable: true })
-  async rootTasks(@Root() project: Project): Promise<Task[]> {
-    return await getRepository(Task).find({
-      where: {
-        project: { id: project.id },
-        parent: IsNull()
-      }
-    })
-  }
-
-  @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 => Attachment)
-  async scheduleTable(@Root() project: Project): Promise<Attachment | undefined> {
-    const attachment: Attachment = await getRepository(Attachment).findOne({
-      where: {
-        domain: { id: project.domainId },
-        refBy: project.id,
-        refType: Project.name + '_schedule_table'
-      }
-    })
-
-    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

@@ -1,72 +0,0 @@
-import { ObjectType, Field, InputType, Int, Float } from 'type-graphql'
-import { Project } from './project'
-import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
-import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
-import { ObjectRef, ScalarObject } from '@things-factory/shell'
-import { BuildingComplexPatch } from '@dssp/building-complex'
-
-@InputType()
-export class NewProject {
-  @Field({ nullable: false, description: '프로젝트 이름' })
-  name: string
-
-  @Field(type => ObjectRef, { nullable: true, description: '연관된 건물 복합체 정보 (선택 사항)' })
-  buildingComplex?: ObjectRef
-}
-
-@InputType()
-export class ProjectPatch {
-  @Field({ nullable: false, description: '수정할 프로젝트의 ID' })
-  id: string
-
-  @Field({ nullable: false, description: '프로젝트 이름' })
-  name: string
-
-  @Field({ nullable: true, description: '프로젝트 착공일정' })
-  startDate?: string
-
-  @Field({ nullable: true, description: '프로젝트 준공일정' })
-  endDate?: string
-
-  @Field(type => GraphQLUpload, { nullable: true, description: '프로젝트 대표 사진 업로드' })
-  mainPhotoUpload?: FileUpload
-
-  @Field(type => Float, { nullable: true, description: '프로젝트 전체 진행현황 (%)' })
-  totalProgress?: number
-
-  @Field(type => Float, { nullable: true, description: '프로젝트 주간 진행현황 (%)' })
-  weeklyProgress?: number
-
-  @Field(type => Float, { nullable: true, description: '프로젝트 KPI' })
-  kpi?: number
-
-  @Field(type => Float, { nullable: true, description: '검측/통과 비율 (%)' })
-  inspPassRate?: number
-
-  @Field(type => Float, { nullable: true, description: '로봇 작업 진행율 (%)' })
-  robotProgressRate?: number
-
-  @Field(type => Float, { nullable: true, description: '구조 안전도 (%)' })
-  structuralSafetyRate?: number
-
-  @Field({ nullable: true })
-  buildingComplex?: BuildingComplexPatch
-}
-
-@InputType()
-export class UploadProjectScheduleTable {
-  @Field({ nullable: false, description: '수정할 프로젝트의 ID' })
-  projectId: string
-
-  @Field(type => GraphQLUpload, { nullable: true, description: '프로젝트 공정표 업로드' })
-  scheduleTable?: FileUpload
-}
-
-@ObjectType()
-export class ProjectList {
-  @Field(type => [Project], { description: '프로젝트 리스트 항목들' })
-  items: Project[]
-
-  @Field(type => Int, { description: '전체 프로젝트 수' })
-  total: number
-}

package/server/service/project/project.ts

@@ -1,134 +0,0 @@
-import {
-  CreateDateColumn,
-  UpdateDateColumn,
-  DeleteDateColumn,
-  Entity,
-  Index,
-  Column,
-  RelationId,
-  ManyToOne,
-  OneToOne,
-  OneToMany,
-  JoinColumn,
-  PrimaryGeneratedColumn
-} from 'typeorm'
-import { ObjectType, Field, ID } 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 ProjectState {
-  'ONGOING' = '10',
-  'COMPLETED' = '20'
-}
-
-@ObjectType({ description: '프로젝트' })
-@Entity()
-@Index('ix_project_building', (project: Project) => [project.buildingComplex], { unique: true, where: '"deleted_at" IS NULL' })
-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: ProjectState.ONGOING, comment: '프로젝트 상태 (10: 진행중, 20: 완료)' })
-  @Field({ nullable: false })
-  state?: ProjectState
-
-  @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
-
-  // 작업 정보 (하위 테이블 참조)
-  @OneToMany(() => Task, task => task.project)
-  @Field(() => [Task], { nullable: true })
-  tasks?: Task[]
-
-  // 루트 작업 정보 (부모가 없는 상위 작업)
-  @Field(() => [Task], { nullable: true })
-  rootTasks?: 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
-
-  // 공정표 파일
-  @Field(type => Attachment, { nullable: true })
-  scheduleTable?: Attachment
-}

package/server/service/resource/index.ts

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