@dssp/supervision 0.0.8 → 0.0.10

package/server/service/{check-item/check-item-type.ts → checklist/checklist-type.ts}

@@ -4,31 +4,25 @@ import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-gr
 
 import { ObjectRef, ScalarObject } from '@things-factory/shell'
 
-import { CheckItem, CheckItemStatus } from './check-item'
+import { Checklist } from './checklist'
 
 @InputType()
-export class NewCheckItem {
+export class NewChecklist {
   @Field()
   name: string
 
   @Field({ nullable: true })
   description?: string
 
-  @Field(type => CheckItemStatus, { nullable: true })
-  state?: CheckItemStatus
-
   @Field({ nullable: true })
   active?: boolean
 
   @Field({ nullable: true })
   params?: string
-
-  @Field(type => GraphQLUpload, { nullable: true })
-  thumbnail?: FileUpload
 }
 
 @InputType()
-export class CheckItemPatch {
+export class ChecklistPatch {
   @Field(type => ID, { nullable: true })
   id?: string
 
@@ -38,23 +32,17 @@ export class CheckItemPatch {
   @Field({ nullable: true })
   description?: string
 
-  @Field(type => CheckItemStatus, { nullable: true })
-  state?: CheckItemStatus
-
   @Field({ nullable: true })
   active?: boolean
 
-  @Field(type => GraphQLUpload, { nullable: true })
-  thumbnail?: FileUpload
-
   @Field({ nullable: true })
   cuFlag?: string
 }
 
 @ObjectType()
-export class CheckItemList {
-  @Field(type => [CheckItem])
-  items: CheckItem[]
+export class ChecklistList {
+  @Field(type => [Checklist])
+  items: Checklist[]
 
   @Field(type => Int)
   total: number

package/server/service/checklist/checklist.ts

@@ -0,0 +1,127 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  DeleteDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  OneToMany,
+  OneToOne,
+  JoinColumn,
+  PrimaryGeneratedColumn
+} from 'typeorm'
+import { ObjectType, Field, ID, registerEnumType } from 'type-graphql'
+
+import { User } from '@things-factory/auth-base'
+import { Task } from '@dssp/project'
+import { ChecklistItem } from '../checklist-item/checklist-item'
+import { BuildingInspection } from '../building-inspection/building-inspection'
+
+@Entity({ comment: '체크리스트' })
+@Index('ix_checklist_0', (checklist: Checklist) => [checklist.task], { where: '"deleted_at" IS NULL' })
+@Index('ix_checklist_1', (checklist: Checklist) => [checklist.documentNo, checklist.createdAt], { where: '"deleted_at" IS NULL' })
+@ObjectType()
+export class Checklist {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @Column({ nullable: true, comment: '이름' })
+  @Field({ nullable: true })
+  name?: string
+
+  @Column({ nullable: true, comment: '문서 번호 동(4자리)-층(3자리)-시퀀스(6자리)' })
+  @Field({ nullable: true })
+  documentNo?: string
+
+  @Column({ nullable: false, comment: '공종' })
+  @Field({ nullable: true })
+  constructionType?: string
+
+  @Column({ nullable: false, comment: '세부 공종' })
+  @Field({ nullable: true })
+  constructionDetailType?: string
+
+  @Column({ nullable: false, comment: '위치 (x동 x층)' })
+  @Field({ nullable: true })
+  location?: string
+
+  @Column({ nullable: false, comment: '검측 도면 타입', default: '' })
+  @Field({ nullable: true })
+  inspectionDrawingType?: string
+
+  @Column('simple-array', { nullable: true, comment: '검측 부위' })
+  @Field(() => [String], { nullable: true })
+  inspectionParts?: string[]
+
+  @Column({ nullable: true, comment: '시공자 점검일' })
+  @Field({ nullable: true })
+  constructionInsprctionDate?: Date
+
+  @Column({ nullable: true, comment: '감리자 점검일' })
+  @Field({ nullable: true })
+  supervisorInsprctionDate?: Date
+
+  @Column({ nullable: true, comment: '총괄 시공 책임자 사인' })
+  @Field({ nullable: true })
+  overallConstructorSignature?: string
+
+  @Column({ nullable: true, comment: '공종별 시공 관리자 사인' })
+  @Field({ nullable: true })
+  taskConstructorSignature?: string
+
+  @Column({ nullable: true, comment: '총괄 감리 책임자 사인' })
+  @Field({ nullable: true })
+  overallSupervisorySignature?: string
+
+  @Column({ nullable: true, comment: '건축사보 (공종별 감리 관리자) 사인' })
+  @Field({ nullable: true })
+  taskSupervisorySignature?: string
+
+  // 공정표 작업 정보 (상위 테이블 참조)
+  @ManyToOne(() => Task)
+  @JoinColumn()
+  @Field(() => Task)
+  task?: Task
+
+  @RelationId((checklist: Checklist) => checklist.task)
+  taskId?: string
+
+  // 체크리스트 아이템 정보 (하위 테이블 참조)
+  @OneToMany(() => ChecklistItem, checklistItem => checklistItem.checklist)
+  @Field(() => [ChecklistItem])
+  checklistItems?: ChecklistItem[]
+
+  // 검측 정보 (1:1 하위 테이블 참조)
+  @OneToOne(() => BuildingInspection, buildingInspection => buildingInspection.checklist)
+  @Field(() => BuildingInspection)
+  buildingInspection?: BuildingInspection
+
+  @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((checklist: Checklist) => checklist.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((checklist: Checklist) => checklist.updater)
+  updaterId?: string
+}

package/server/service/checklist/event-subscriber.ts

@@ -0,0 +1,17 @@
+import { EventSubscriber } from 'typeorm'
+
+import { HistoryEntitySubscriber } from '@operato/typeorm-history'
+
+import { Checklist } from './checklist'
+import { ChecklistHistory } from './checklist-history'
+
+@EventSubscriber()
+export class ChecklistHistoryEntitySubscriber extends HistoryEntitySubscriber<Checklist, ChecklistHistory> {
+  public get entity() {
+    return Checklist
+  }
+
+  public get historyEntity() {
+    return ChecklistHistory
+  }
+}

package/server/service/checklist/index.ts

@@ -0,0 +1,9 @@
+import { Checklist } from './checklist'
+import { ChecklistQuery } from './checklist-query'
+import { ChecklistHistory } from './checklist-history'
+import { ChecklistMutation } from './checklist-mutation'
+import { ChecklistHistoryEntitySubscriber } from './event-subscriber'
+
+export const entities = [Checklist, ChecklistHistory]
+export const resolvers = [ChecklistQuery, ChecklistMutation]
+export const subscribers = [ChecklistHistoryEntitySubscriber]

package/server/service/checklist-item/checklist-item-mutation.ts

@@ -0,0 +1,5 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { ChecklistItem } from './checklist-item'
+
+@Resolver(ChecklistItem)
+export class ChecklistItemMutation {}

package/server/service/checklist-item/checklist-item-query.ts

@@ -0,0 +1,43 @@
+import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
+import { Attachment } from '@things-factory/attachment-base'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { ChecklistItem } from './checklist-item'
+import { ChecklistItemList } from './checklist-item-type'
+
+@Resolver(ChecklistItem)
+export class ChecklistItemQuery {
+  @Query(returns => ChecklistItem!, { nullable: true, description: 'To fetch a ChecklistItem' })
+  async checklistItem(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<ChecklistItem> {
+    const { domain } = context.state
+
+    return await getRepository(ChecklistItem).findOne({
+      where: { id }
+    })
+  }
+
+  @Query(returns => ChecklistItemList, { description: 'To fetch multiple ChecklistItems' })
+  async checklistItems(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ChecklistItemList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      params,
+      repository: await getRepository(ChecklistItem),
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() checklistItem: ChecklistItem): Promise<User> {
+    return await getRepository(User).findOneBy({ id: checklistItem.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() checklistItem: ChecklistItem): Promise<User> {
+    return await getRepository(User).findOneBy({ id: checklistItem.creatorId })
+  }
+}

package/server/service/checklist-item/checklist-item-type.ts

@@ -0,0 +1,12 @@
+import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
+
+import { ChecklistItem } from './checklist-item'
+
+@ObjectType()
+export class ChecklistItemList {
+  @Field(type => [ChecklistItem])
+  items: ChecklistItem[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/checklist-item/checklist-item.ts

@@ -0,0 +1,100 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  DeleteDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  PrimaryGeneratedColumn
+} from 'typeorm'
+import { ObjectType, Field, ID, Int, registerEnumType } from 'type-graphql'
+
+import { User } from '@things-factory/auth-base'
+import { Checklist } from '../checklist/checklist'
+
+export enum ChecklistItemConfirmStatus {
+  T = '적합',
+  F = '부적합'
+}
+
+registerEnumType(ChecklistItemConfirmStatus, {
+  name: 'ChecklistItemConfirmStatus',
+  description: '적합 상태'
+})
+
+@Entity({ comment: '체크 리스트 항목' })
+@Index('ix_checklist_item_0', (checklistItem: ChecklistItem) => [checklistItem.checklist], { where: '"deleted_at" IS NULL' })
+@ObjectType()
+export class ChecklistItem {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @Column({ nullable: true, comment: '시퀀스' })
+  @Field(type => Int, { nullable: true })
+  sequence?: number
+
+  @Column({ nullable: false, comment: '구분 (텍스트)' })
+  @Field({ nullable: false })
+  mainType?: string
+
+  @Column({ nullable: false, comment: '상세 구분 (텍스트)' })
+  @Field({ nullable: false })
+  detailType?: string
+
+  @Column({ nullable: true, comment: '검사 항목' })
+  @Field({ nullable: true })
+  name?: string
+
+  @Column({ nullable: true, comment: '검사 기준' })
+  @Field({ nullable: true })
+  inspctionCriteria?: string
+
+  @Column({ nullable: true, comment: '시공 관리자 적합 여부 (T: 적합, F: 부적합)' })
+  @Field({ nullable: true })
+  constructionConfirmStatus?: ChecklistItemConfirmStatus
+
+  @Column({ nullable: true, comment: '감리 관리자 적합 여부 (T: 적합, F: 부적합)' })
+  @Field({ nullable: true })
+  supervisoryConfirmStatus?: ChecklistItemConfirmStatus
+
+  @Column({ nullable: true, comment: '참고 사항' })
+  @Field({ nullable: true })
+  comment?: string
+
+  // 체크리스트 정보 (상위 테이블 참조)
+  @ManyToOne(type => Checklist)
+  @Field(type => Checklist, { nullable: true })
+  checklist?: Checklist
+
+  @RelationId((checklistItem: ChecklistItem) => checklistItem.checklist)
+  checklistId?: string
+
+  @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((checklistItem: ChecklistItem) => checklistItem.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((checklistItem: ChecklistItem) => checklistItem.updater)
+  updaterId?: string
+}

package/server/service/checklist-item/index.ts

@@ -0,0 +1,7 @@
+import { ChecklistItem } from './checklist-item'
+import { ChecklistItemQuery } from './checklist-item-query'
+import { ChecklistItemMutation } from './checklist-item-mutation'
+
+export const entities = [ChecklistItem]
+export const resolvers = [ChecklistItemQuery, ChecklistItemMutation]
+export const subscribers = []

package/server/service/checklist-template/checklist-template-mutation.ts

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

package/server/service/checklist-template/checklist-template-query.ts

@@ -0,0 +1,39 @@
+import { Resolver, Query, FieldResolver, Root, Args, Ctx } from 'type-graphql'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { ChecklistTemplate } from './checklist-template'
+import { ChecklistTemplateList } from './checklist-template-type'
+
+@Resolver(ChecklistTemplate)
+export class ChecklistTemplateQuery {
+  @Query(returns => ChecklistTemplateList, { description: 'To fetch multiple ChecklistTemplates' })
+  async checklistTemplates(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ChecklistTemplateList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(ChecklistTemplate),
+      searchables: ['name']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() checklistTemplate: ChecklistTemplate): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: checklistTemplate.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() checklistTemplate: ChecklistTemplate): Promise<User> {
+    return await getRepository(User).findOneBy({ id: checklistTemplate.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() checklistTemplate: ChecklistTemplate): Promise<User> {
+    return await getRepository(User).findOneBy({ id: checklistTemplate.creatorId })
+  }
+}

package/server/service/checklist-template/checklist-template-type.ts

@@ -0,0 +1,23 @@
+import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
+import { ChecklistTemplate } from './checklist-template'
+
+@InputType()
+export class ChecklistTemplatePatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class ChecklistTemplateList {
+  @Field(type => [ChecklistTemplate])
+  items: ChecklistTemplate[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/checklist-template/checklist-template.ts

@@ -0,0 +1,71 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  DeleteDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn
+} from 'typeorm'
+import { ObjectType, Field, ID } from 'type-graphql'
+
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { ChecklistTemplateItem } from '../checklist-template-item/checklist-template-item'
+
+@Entity({ comment: '체크리스트 템플릿' })
+@Index('ix_checklist_template_0', (checklistTemplate: ChecklistTemplate) => [checklistTemplate.domain, checklistTemplate.name], {
+  unique: true,
+  where: '"deleted_at" IS NULL'
+})
+@ObjectType()
+export class ChecklistTemplate {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((checklistTemplate: ChecklistTemplate) => checklistTemplate.domain)
+  domainId?: string
+
+  @Column({ nullable: true, comment: '이름' })
+  @Field({ nullable: true })
+  name?: string
+
+  // 체크리스트 템플릿 아이템 정보 (하위 테이블 참조)
+  @Field(() => [ChecklistTemplateItem])
+  @OneToMany(() => ChecklistTemplateItem, checklistTemplateItem => checklistTemplateItem.checklistTemplate)
+  checklistTemplateItems?: ChecklistTemplateItem[]
+
+  @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((checklistTemplate: ChecklistTemplate) => checklistTemplate.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((checklistTemplate: ChecklistTemplate) => checklistTemplate.updater)
+  updaterId?: string
+}

package/server/service/checklist-template/index.ts

@@ -0,0 +1,6 @@
+import { ChecklistTemplate } from './checklist-template'
+import { ChecklistTemplateQuery } from './checklist-template-query'
+import { ChecklistTemplateMutation } from './checklist-template-mutation'
+
+export const entities = [ChecklistTemplate]
+export const resolvers = [ChecklistTemplateQuery, ChecklistTemplateMutation]

package/server/service/checklist-template-item/checklist-template-item-mutation.ts

@@ -0,0 +1,64 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+import { ChecklistTemplateItem } from './checklist-template-item'
+import { ChecklistTemplateItemPatch } from './checklist-template-item-type'
+import { ChecklistTemplate } from '../checklist-template/checklist-template'
+
+@Resolver(ChecklistTemplateItem)
+export class ChecklistTemplateItemMutation {
+  @Directive('@transaction')
+  @Mutation(returns => [ChecklistTemplateItem], { description: "To modify multiple ChecklistTemplateItems' information" })
+  async updateMultipleChecklistTemplateItems(
+    @Arg('patches', type => [ChecklistTemplateItemPatch]) patches: ChecklistTemplateItemPatch[],
+    @Arg('checklistTemplateId') checklistTemplateId: string,
+    @Ctx() context: ResolverContext
+  ): Promise<ChecklistTemplateItem[]> {
+    const { domain, user, tx } = context.state
+
+    let results = []
+
+    const checklistTemplateItemRepo = tx.getRepository(ChecklistTemplateItem)
+    const checklistTemplate = await tx.getRepository(ChecklistTemplate).findOneBy({ id: checklistTemplateId })
+
+    await checklistTemplateItemRepo.delete({ checklistTemplate: { id: checklistTemplateId } })
+
+    for (let i = 0; i < patches.length; i++) {
+      const result = await checklistTemplateItemRepo.save({
+        ...patches[i],
+        sequence: i,
+        checklistTemplate,
+        creator: user,
+        updater: user
+      })
+
+      results.push({ ...result, cuFlag: '+' })
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete ChecklistTemplateItem' })
+  async deleteChecklistTemplateItem(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(ChecklistTemplateItem).delete({ id })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple ChecklistTemplateItems' })
+  async deleteChecklistTemplateItems(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(ChecklistTemplateItem).delete({
+      id: In(ids)
+    })
+
+    return true
+  }
+}