@dssp/project 0.0.2 → 0.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dssp/project",
-  "version": "0.0.2",
+  "version": "0.0.5",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -27,12 +27,12 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create -d ./server/migrations"
   },
   "dependencies": {
-    "@dssp/building-complex": "^0.0.2",
+    "@dssp/building-complex": "^0.0.5",
     "@operato/graphql": "^7.0.0",
     "@operato/shell": "^7.0.0",
     "@things-factory/auth-base": "^7.0.0",
     "@things-factory/shell": "^7.0.0",
     "exceljs": "^4.4.0"
   },
-  "gitHead": "d2d9c69dd4dc2e4098becc405c3641dc440766b7"
+  "gitHead": "5ccd5b966f8b5b5cabf6cb9f65f0d43d6c87c0c7"
 }

package/server/service/construction-type/construction-type-mutation.ts

@@ -0,0 +1,66 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+import { ConstructionType } from './construction-type'
+import { ConstructionTypePatch } from './construction-type-type'
+
+@Resolver(ConstructionType)
+export class ConstructionTypeMutation {
+  @Directive('@transaction')
+  @Mutation(returns => [ConstructionType], { description: "To modify multiple ConstructionTypes' information" })
+  async updateMultipleConstructionType(
+    @Arg('patches', type => [ConstructionTypePatch]) patches: ConstructionTypePatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<ConstructionType[]> {
+    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 constructionTypeRepo = tx.getRepository(ConstructionType)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await constructionTypeRepo.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 constructionType = await constructionTypeRepo.findOneBy({ id: updateRecord.id })
+
+        const result = await constructionTypeRepo.save({
+          ...constructionType,
+          ...updateRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple ConstructionTypes' })
+  async deleteConstructionTypes(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(ConstructionType).softDelete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+
+    return true
+  }
+}

package/server/service/construction-type/construction-type-query.ts

@@ -0,0 +1,47 @@
+import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx } from 'type-graphql'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { ConstructionType } from './construction-type'
+import { ConstructionTypeList } from './construction-type-type'
+
+@Resolver(ConstructionType)
+export class ConstructionTypeQuery {
+  @Query(returns => ConstructionType!, { nullable: true, description: 'To fetch a ConstructionType' })
+  async constructionType(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<ConstructionType> {
+    const { domain } = context.state
+
+    return await getRepository(ConstructionType).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Query(returns => ConstructionTypeList, { description: 'To fetch multiple ConstructionTypes' })
+  async constructionTypes(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ConstructionTypeList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(ConstructionType)
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() constructionType: ConstructionType): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: constructionType.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() constructionType: ConstructionType): Promise<User> {
+    return await getRepository(User).findOneBy({ id: constructionType.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() constructionType: ConstructionType): Promise<User> {
+    return await getRepository(User).findOneBy({ id: constructionType.creatorId })
+  }
+}

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

@@ -0,0 +1,26 @@
+import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
+import { ConstructionType } from './construction-type'
+
+@InputType()
+export class ConstructionTypePatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class ConstructionTypeList {
+  @Field(type => [ConstructionType])
+  items: ConstructionType[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/{resource/resource.ts → construction-type/construction-type.ts}

@@ -11,23 +11,35 @@ import {
 } from 'typeorm'
 import { ObjectType, Field, ID } from 'type-graphql'
 
+import { Domain } from '@things-factory/shell'
 import { User } from '@things-factory/auth-base'
 
 @Entity()
-@Index('ix_resource_0', (resource: Resource) => [resource.name], {
+@Index('ix_construction_type_0', (constructionType: ConstructionType) => [constructionType.domain, constructionType.name], {
   unique: true,
   where: '"deleted_at" IS NULL'
 })
-@ObjectType({ description: '리소스 관리 (작업자)' })
-export class Resource {
+@ObjectType({ description: '공종 타입' })
+export class ConstructionType {
   @PrimaryGeneratedColumn('uuid')
   @Field(type => ID)
   readonly id: string
 
-  @Column({ nullable: true, comment: '직군' })
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((constructionType: ConstructionType) => constructionType.domain)
+  domainId?: string
+
+  @Column()
   @Field({ nullable: true })
   name?: string
 
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description?: string
+
   @CreateDateColumn()
   @Field({ nullable: true })
   createdAt?: Date
@@ -44,13 +56,13 @@ export class Resource {
   @Field(type => User, { nullable: true })
   creator?: User
 
-  @RelationId((resource: Resource) => resource.creator)
+  @RelationId((constructionType: ConstructionType) => constructionType.creator)
   creatorId?: string
 
   @ManyToOne(type => User, { nullable: true })
   @Field(type => User, { nullable: true })
   updater?: User
 
-  @RelationId((resource: Resource) => resource.updater)
+  @RelationId((constructionType: ConstructionType) => constructionType.updater)
   updaterId?: string
 }

package/server/service/construction-type/index.ts

@@ -0,0 +1,6 @@
+import { ConstructionType } from './construction-type'
+import { ConstructionTypeQuery } from './construction-type-query'
+import { ConstructionTypeMutation } from './construction-type-mutation'
+
+export const entities = [ConstructionType]
+export const resolvers = [ConstructionTypeQuery, ConstructionTypeMutation]

package/server/service/index.ts

@@ -1,12 +1,16 @@
 /* EXPORT ENTITY TYPES */
-export * from './resource/resource'
+export * from './construction-type/construction-type'
+export * from './worker-type/worker-type'
+export * from './manager/manager'
 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 ConstructionTypeEntities, resolvers as ConstructionTypeResolvers } from './construction-type'
+import { entities as WorkerTypeEntities, resolvers as WorkerTypeResolvers } from './worker-type'
+import { entities as ManagerEntities, resolvers as ManagerResolvers } from './manager'
 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'
@@ -14,7 +18,9 @@ import { entities as ProjectEntities, resolvers as ProjectResolvers, types as Pr
 
 export const entities = [
   /* ENTITIES */
-  ...ResourceEntities,
+  ...ConstructionTypeEntities,
+  ...WorkerTypeEntities,
+  ...ManagerEntities,
   ...CheckItemEntities,
   ...ChecklistEntities,
   ...TaskEntities,
@@ -24,7 +30,9 @@ export const entities = [
 export const schema = {
   resolverClasses: [
     /* RESOLVER CLASSES */
-    ...ResourceResolvers,
+    ...ConstructionTypeResolvers,
+    ...WorkerTypeResolvers,
+    ...ManagerResolvers,
     ...CheckItemResolvers,
     ...ChecklistResolvers,
     ...TaskResolvers,

package/server/service/manager/index.ts

@@ -0,0 +1,6 @@
+import { Manager } from './manager'
+import { ManagerQuery } from './manager-query'
+import { ManagerMutation } from './manager-mutation'
+
+export const entities = [Manager]
+export const resolvers = [ManagerQuery, ManagerMutation]

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

@@ -0,0 +1,42 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { Manager } from './manager'
+import { ManagerPatch } from './manager-type'
+import { User } from '@things-factory/auth-base'
+
+@Resolver(Manager)
+export class ManagerMutation {
+  @Directive('@transaction')
+  @Mutation(returns => [Manager], { description: "To modify multiple Managers' information" })
+  async updateMultipleManager(
+    @Arg('patches', type => [ManagerPatch]) patches: ManagerPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<Manager[]> {
+    const { tx, user } = context.state
+
+    let results = []
+    const managerRepo = tx.getRepository(Manager)
+    const userRepo = tx.getRepository(User)
+
+    for (let i = 0; i < patches.length; i++) {
+      const updateRecord = patches[i]
+      const manager = updateRecord.id ? await managerRepo.findOneBy({ id: updateRecord.id }) : {}
+      const managerUser = await userRepo.findOneBy({ id: updateRecord.userId })
+
+      await userRepo.save({
+        ...managerUser,
+        name: updateRecord.name,
+        updater: user
+      })
+
+      const result = await managerRepo.save({
+        ...manager,
+        user: managerUser,
+        ...updateRecord
+      })
+
+      results.push({ ...result })
+    }
+
+    return results
+  }
+}

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

@@ -0,0 +1,28 @@
+import { Resolver, Query, Ctx } from 'type-graphql'
+import { getRepository } from '@things-factory/shell'
+import { Manager } from './manager'
+import { ManagerOutput } from './manager-type'
+import { User } from '@things-factory/auth-base'
+
+@Resolver(Manager)
+export class ManagerQuery {
+  @Query(returns => [ManagerOutput], { description: '담당자 리스트' })
+  async managers(@Ctx() context: ResolverContext): Promise<ManagerOutput[]> {
+    const { domain } = context.state
+
+    const queryBuilder = await getRepository(User)
+      .createQueryBuilder('u')
+      .select('m.id', 'id')
+      .addSelect('m.phone', 'phone')
+      .addSelect('m.position', 'position')
+      .addSelect('u.id', 'userId')
+      .addSelect('u.name', 'name')
+      .addSelect('u.updated_at', 'updatedAt')
+      .innerJoin('users_domains', 'ud', 'u.id = ud.users_id')
+      .leftJoin('managers', 'm', 'u.id = m.user_id')
+      .where('ud.domains_id = :domain', { domain: domain.id })
+      .orderBy('u.name', 'DESC')
+
+    return await queryBuilder.getRawMany()
+  }
+}

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

@@ -0,0 +1,40 @@
+import { ObjectType, Field, InputType, ID } from 'type-graphql'
+
+@InputType()
+export class ManagerPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  phone?: string
+
+  @Field({ nullable: true })
+  position?: string
+
+  @Field(type => ID, { nullable: true })
+  userId?: string
+
+  @Field({ nullable: true })
+  name?: string
+}
+
+@ObjectType()
+export class ManagerOutput {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  phone?: string
+
+  @Field({ nullable: true })
+  position?: string
+
+  @Field(type => ID)
+  userId?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  updatedAt?: string
+}

package/server/service/manager/manager.ts

@@ -0,0 +1,29 @@
+import { Entity, Index, Column, RelationId, OneToOne, PrimaryGeneratedColumn, JoinColumn } from 'typeorm'
+import { ObjectType, Field, ID } from 'type-graphql'
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+
+@Entity()
+@Index('ix_manager_0', (manager: Manager) => [manager.user])
+@ObjectType({ description: '담당자 관리' })
+export class Manager {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @Column({ nullable: true, comment: '핸드폰 번호' })
+  @Field({ nullable: true })
+  phone?: string
+
+  @Column({ nullable: true, comment: '직위' })
+  @Field({ nullable: true })
+  position?: string
+
+  @OneToOne(type => User)
+  @JoinColumn()
+  @Field({ nullable: true })
+  user?: User
+
+  @RelationId((manager: Manager) => manager.user)
+  userId?: string
+}

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

@@ -1,11 +1,10 @@
-import { Resolver, Mutation, Arg, Args, Ctx, Directive } from 'type-graphql'
-import { In, Not } from 'typeorm'
-
-import { createAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
-
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+import { createAttachment, deleteAttachmentsByRef, ATTACHMENT_PATH } from '@things-factory/attachment-base'
 import { Project } from './project'
 import { NewProject, ProjectPatch } 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'
 
 @Resolver(Project)
 export class ProjectMutation {
@@ -51,43 +50,11 @@ export class ProjectMutation {
     // 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-1. 프로젝트 메인 이미지 첨부파일 나머지 삭제 후 저장
+    await createAttachmentAfterDelete(context, project?.mainPhotoUpload, project.id, Project.name)
 
-    // 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
-        )
-      }
-    }
+    // 2-2. 단지 BIM 이미지 첨부파일 나머지 삭제 후 저장
+    await createAttachmentAfterDelete(context, buildingComplex?.drawingUpload, buildingComplex.id, BuildingComplex.name)
 
     // 3. 동의 층 정보가 바뀌었으면 층 초기화 후 다시 생성
     const originBuilding = await buildingRepo.findBy({ buildingComplex: { id: buildingComplex.id } }) // 이전 동 정보 가져오기
@@ -105,8 +72,9 @@ export class ProjectMutation {
       await buildingRepo.softDelete({ id: In(buildingIds) })
       await deleteAttachmentsByRef(null, { refBys: [...buildingIds, ...buildingLevelIds] }, context)
 
-      buildings.forEach(async (building: Building) => {
-        // 3-2. 단지 내 동 정보들 생성
+      // 3-2. 단지 내 동 정보들 생성
+      for (let buildingKey in buildings) {
+        const building = buildings[buildingKey]
         const newBuilding = await buildingRepo.save({
           buildingComplex: buildingComplex,
           name: building.name,
@@ -118,7 +86,7 @@ export class ProjectMutation {
         for (let i = 1; i <= building.floorCount; i++) {
           await buildingLevelRepo.save({ building: newBuilding, floor: i, creator: user })
         }
-      })
+      }
     }
 
     return projectResult
@@ -127,11 +95,13 @@ export class ProjectMutation {
   @Directive('@transaction')
   @Mutation(returns => Project, { description: '프로젝트 도면 업데이트' })
   async updateProjectPlan(@Arg('project') project: ProjectPatch, @Ctx() context: ResolverContext): Promise<Project> {
-    const { user, tx } = context.state
+    const { user, tx, domain } = 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: Building[] = project.buildingComplex?.buildings || []
+    const buildings = project.buildingComplex?.buildings || []
 
     // 1. 프로젝트 수정 시간 업데이트
     const projectResult = await projectRepo.save({ ...project, updater: user })
@@ -145,44 +115,79 @@ export class ProjectMutation {
       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
-            )
-          }
+        // 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}`
+          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'
+          )
         }
-      }
 
-      // 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
+        // 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
@@ -199,3 +204,20 @@ export class ProjectMutation {
     return true
   }
 }
+
+export async function createAttachmentAfterDelete(context: ResolverContext, file: any, refBy: any, refType: any) {
+  let result = null
+
+  // undefined = 기존 파일 그대로
+  if (file === undefined) return result
+
+  // 기존 첨부 파일이 있으면 삭제
+  await deleteAttachmentsByRef(null, { refBys: [refBy], refType }, context)
+
+  // 파일이 있으면 생성 (null로 들어올 경우 delete까지만)
+  if (file) {
+    result = await createAttachment(null, { attachment: { file, refType, refBy } }, context)
+  }
+
+  return result
+}