@dssp/supervision 0.0.9 → 0.0.11

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
+  }
+}

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

@@ -0,0 +1,39 @@
+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 { ChecklistTemplateItem } from './checklist-template-item'
+import { ChecklistTemplateItemList } from './checklist-template-item-type'
+
+@Resolver(ChecklistTemplateItem)
+export class ChecklistTemplateItemQuery {
+  @Query(returns => ChecklistTemplateItem!, { nullable: true, description: 'To fetch a ChecklistTemplateItem' })
+  async checklistTemplateItem(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<ChecklistTemplateItem> {
+    return await getRepository(ChecklistTemplateItem).findOne({
+      where: { id }
+    })
+  }
+
+  @Query(returns => ChecklistTemplateItemList, { description: 'To fetch multiple ChecklistTemplateItems' })
+  async checklistTemplateItems(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ChecklistTemplateItemList> {
+    const queryBuilder = getQueryBuilderFromListParams({
+      params,
+      repository: await getRepository(ChecklistTemplateItem),
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() checklistTemplateItem: ChecklistTemplateItem): Promise<User> {
+    return await getRepository(User).findOneBy({ id: checklistTemplateItem.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() checklistTemplateItem: ChecklistTemplateItem): Promise<User> {
+    return await getRepository(User).findOneBy({ id: checklistTemplateItem.creatorId })
+  }
+}

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

@@ -0,0 +1,39 @@
+import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
+import { ChecklistTemplateItem } from './checklist-template-item'
+import { ChecklistTypeMainType } from '../checklist-type/checklist-type'
+
+@InputType()
+export class ChecklistTemplateItemPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  inspctionCriteria?: string
+
+  @Field(type => Int, { nullable: true })
+  sequence?: number
+
+  @Field({ nullable: true })
+  mainType?: ChecklistTypeMainType
+
+  @Field({ nullable: true })
+  detailType?: string
+
+  @Field({ nullable: true })
+  checklistTemplateId?: string
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class ChecklistTemplateItemList {
+  @Field(type => [ChecklistTemplateItem])
+  items: ChecklistTemplateItem[]
+
+  @Field(type => Int)
+  total: number
+}

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

@@ -0,0 +1,67 @@
+import { CreateDateColumn, UpdateDateColumn, Entity, Index, Column, RelationId, ManyToOne, PrimaryGeneratedColumn } from 'typeorm'
+import { ObjectType, Field, ID, Int } from 'type-graphql'
+
+import { User } from '@things-factory/auth-base'
+import { ChecklistTemplate } from '../checklist-template/checklist-template'
+import { ChecklistTypeMainType } from '../checklist-type/checklist-type'
+
+@Entity({ comment: '체크리스트 템플릿 아이템' })
+@Index('ix_checklist_template_item_0', (checklistTemplateItem: ChecklistTemplateItem) => [checklistTemplateItem.name], {
+  unique: true
+})
+@ObjectType()
+export class ChecklistTemplateItem {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @Column({ nullable: false, comment: '검사 항목' })
+  @Field({ nullable: false })
+  name: string
+
+  @Column({ nullable: true, comment: '검사 기준' })
+  @Field({ nullable: true })
+  inspctionCriteria?: string
+
+  @Column({ nullable: true, comment: '시퀀스' })
+  @Field(type => Int, { nullable: true })
+  sequence?: number
+
+  @Column({ nullable: false, comment: '메인 구분 (10: 기본 업무, 20: 기본 외 업무)' })
+  @Field({ nullable: false })
+  mainType: ChecklistTypeMainType
+
+  @Column({ nullable: false, comment: '상세 구분' })
+  @Field({ nullable: false })
+  detailType: string
+
+  // 체크리스트 템플릿 정보 (상위 테이블 참조)
+  @ManyToOne(type => ChecklistTemplate)
+  @Field(type => ChecklistTemplate, { nullable: true })
+  checklistTemplate?: ChecklistTemplate
+
+  @RelationId((checklistTemplateItem: ChecklistTemplateItem) => checklistTemplateItem.checklistTemplate)
+  checklistTemplateId?: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((checklistTemplateItem: ChecklistTemplateItem) => checklistTemplateItem.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((checklistTemplateItem: ChecklistTemplateItem) => checklistTemplateItem.updater)
+  updaterId?: string
+}

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

@@ -0,0 +1,6 @@
+import { ChecklistTemplateItem } from './checklist-template-item'
+import { ChecklistTemplateItemQuery } from './checklist-template-item-query'
+import { ChecklistTemplateItemMutation } from './checklist-template-item-mutation'
+
+export const entities = [ChecklistTemplateItem]
+export const resolvers = [ChecklistTemplateItemQuery, ChecklistTemplateItemMutation]

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

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

package/server/service/checklist-type/checklist-type-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 { ChecklistType } from './checklist-type'
+import { ChecklistTypeList } from './checklist-type-type'
+
+@Resolver(ChecklistType)
+export class ChecklistTypeQuery {
+  @Query(returns => ChecklistTypeList, { description: 'To fetch multiple ChecklistTypes' })
+  async checklistTypes(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ChecklistTypeList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(ChecklistType),
+      searchables: ['name']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() checklistType: ChecklistType): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: checklistType.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() checklistType: ChecklistType): Promise<User> {
+    return await getRepository(User).findOneBy({ id: checklistType.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() checklistType: ChecklistType): Promise<User> {
+    return await getRepository(User).findOneBy({ id: checklistType.creatorId })
+  }
+}

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

@@ -0,0 +1,26 @@
+import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
+import { ChecklistType, ChecklistTypeMainType } from './checklist-type'
+
+@InputType()
+export class ChecklistTypePatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  mainType: ChecklistTypeMainType
+
+  @Field({ nullable: true })
+  detailType: string
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class ChecklistTypeList {
+  @Field(type => [ChecklistType])
+  items: ChecklistType[]
+
+  @Field(type => Int)
+  total: number
+}

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

@@ -0,0 +1,64 @@
+import { CreateDateColumn, UpdateDateColumn, Entity, Index, Column, RelationId, ManyToOne, PrimaryGeneratedColumn } from 'typeorm'
+import { ObjectType, Field, ID, registerEnumType } from 'type-graphql'
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+
+export enum ChecklistTypeMainType {
+  BASIC = '10',
+  NON_BASIC = '20'
+}
+
+registerEnumType(ChecklistTypeMainType, {
+  name: 'ChecklistTypeMainType',
+  description: '체크리스트 구분 메인 구분'
+})
+
+@Entity({ comment: '체크리스트 구분' })
+@Index(
+  'ix_checklist_type_0',
+  (checklistType: ChecklistType) => [checklistType.domain, checklistType.mainType, checklistType.detailType],
+  { unique: true }
+)
+@ObjectType()
+export class ChecklistType {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((checklistType: ChecklistType) => checklistType.domain)
+  domainId?: string
+
+  @Column({ nullable: false, comment: '메인 구분 (10: 기본 업무, 20: 기본 외 업무)' })
+  @Field({ nullable: false })
+  mainType: ChecklistTypeMainType
+
+  @Column({ nullable: false, comment: '상세 구분' })
+  @Field({ nullable: false })
+  detailType: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((checklistType: ChecklistType) => checklistType.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((checklistType: ChecklistType) => checklistType.updater)
+  updaterId?: string
+}

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

@@ -0,0 +1,6 @@
+import { ChecklistType } from './checklist-type'
+import { ChecklistTypeQuery } from './checklist-type-query'
+import { ChecklistTypeMutation } from './checklist-type-mutation'
+
+export const entities = [ChecklistType]
+export const resolvers = [ChecklistTypeQuery, ChecklistTypeMutation]

package/server/service/index.ts

@@ -1,42 +1,79 @@
 /* EXPORT ENTITY TYPES */
 export * from './action-plan/action-plan'
 export * from './issue/issue'
-export * from './check-item/check-item'
 export * from './project-report/project-report'
 export * from './supervisor/supervisor'
+export * from './checklist-type/checklist-type'
+export * from './checklist/checklist'
+export * from './checklist-item/checklist-item'
+export * from './checklist-template/checklist-template'
+export * from './checklist-template-item/checklist-template-item'
+export * from './building-inspection/building-inspection'
 
 /* IMPORT ENTITIES AND RESOLVERS */
-import { entities as ActionPlanEntities, resolvers as ActionPlanResolvers, subscribers as ActionPlanSubscribers } from './action-plan'
+import {
+  entities as ActionPlanEntities,
+  resolvers as ActionPlanResolvers,
+  subscribers as ActionPlanSubscribers
+} from './action-plan'
 import { entities as IssueEntities, resolvers as IssueResolvers, subscribers as IssueSubscribers } from './issue'
-import { entities as CheckItemEntities, resolvers as CheckItemResolvers, subscribers as CheckItemSubscribers } from './check-item'
-import { entities as ProjectReportEntities, resolvers as ProjectReportResolvers, subscribers as ProjectReportSubscribers } from './project-report'
-import { entities as SupervisorEntities, resolvers as SupervisorResolvers, subscribers as SupervisorSubscribers } from './supervisor'
+import {
+  entities as ProjectReportEntities,
+  resolvers as ProjectReportResolvers,
+  subscribers as ProjectReportSubscribers
+} from './project-report'
+import {
+  entities as SupervisorEntities,
+  resolvers as SupervisorResolvers,
+  subscribers as SupervisorSubscribers
+} from './supervisor'
+import { entities as ChecklistEntities, resolvers as ChecklistResolvers, subscribers as ChecklistSubscribers } from './checklist'
+import { entities as ChecklistItemEntities, resolvers as ChecklistItemResolvers } from './checklist-item'
+import { entities as ChecklistTypeEntities, resolvers as ChecklistTypeResolvers } from './checklist-type'
+import { entities as ChecklistTemplateEntities, resolvers as ChecklistTemplateResolvers } from './checklist-template'
+import { entities as ChecklistTemplateItemEntities, resolvers as ChecklistTemplateItemResolvers } from './checklist-template-item'
+import {
+  entities as BuildingInspectionEntities,
+  resolvers as BuildingInspectionResolvers,
+  subscribers as BuildingInspectionSubscribers
+} from './building-inspection'
 
-export const entities = [  
+export const entities = [
   /* ENTITIES */
-	...ActionPlanEntities,
-	...IssueEntities,
-	...CheckItemEntities,
-	...ProjectReportEntities,
-	...SupervisorEntities,
-] 
+  ...ActionPlanEntities,
+  ...IssueEntities,
+  ...ProjectReportEntities,
+  ...SupervisorEntities,
+  ...ChecklistEntities,
+  ...ChecklistItemEntities,
+  ...ChecklistTypeEntities,
+  ...ChecklistTemplateItemEntities,
+  ...ChecklistTemplateEntities,
+  ...BuildingInspectionEntities
+]
 
 export const subscribers = [
   /* SUBSCRIBERS */
-	...ActionPlanSubscribers,
-	...IssueSubscribers,
-	...CheckItemSubscribers,
-	...ProjectReportSubscribers,
-	...SupervisorSubscribers,
+  ...ActionPlanSubscribers,
+  ...IssueSubscribers,
+  ...ProjectReportSubscribers,
+  ...SupervisorSubscribers,
+  ...BuildingInspectionSubscribers,
+  ...ChecklistSubscribers
 ]
 
 export const schema = {
   resolverClasses: [
     /* RESOLVER CLASSES */
-		...ActionPlanResolvers,
-		...IssueResolvers,
-		...CheckItemResolvers,
-		...ProjectReportResolvers,
-		...SupervisorResolvers,
-  ] 
+    ...ActionPlanResolvers,
+    ...IssueResolvers,
+    ...ProjectReportResolvers,
+    ...SupervisorResolvers,
+    ...ChecklistResolvers,
+    ...ChecklistItemResolvers,
+    ...ChecklistTypeResolvers,
+    ...ChecklistTemplateItemResolvers,
+    ...ChecklistTemplateResolvers,
+    ...BuildingInspectionResolvers
+  ]
 }

package/server/service/issue/issue.ts

@@ -15,8 +15,7 @@ import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
 
 import { Domain } from '@things-factory/shell'
 import { User } from '@things-factory/auth-base'
-import { CheckItem } from 'service/check-item/check-item'
-import { ActionPlan } from 'service/action-plan/action-plan'
+import { ActionPlan } from '../action-plan/action-plan'
 
 export enum IssueStatus {
   STATUS_A = 'STATUS_A',
@@ -66,10 +65,6 @@ export class Issue {
   @Field({ nullable: true })
   params?: string
 
-  @Field(() => CheckItem)
-  @ManyToOne(() => CheckItem, checkItem => checkItem.issues)
-  checkItem: CheckItem
-
   @Field(() => [ActionPlan])
   @OneToMany(() => ActionPlan, actionPlan => actionPlan.issue)
   actionPlans: ActionPlan[]

package/server/service/supervisor/supervisor.ts

@@ -15,8 +15,7 @@ import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
 
 import { Domain } from '@things-factory/shell'
 import { User } from '@things-factory/auth-base'
-import { ProjectReport } from 'service/project-report/project-report'
-import { CheckItem } from 'service/check-item/check-item'
+import { ProjectReport } from '../project-report/project-report'
 
 export enum SupervisorStatus {
   STATUS_A = 'STATUS_A',
@@ -78,10 +77,6 @@ export class Supervisor {
   @OneToMany(() => ProjectReport, report => report.supervisor)
   reports: ProjectReport[]
 
-  @Field(() => [CheckItem])
-  @OneToMany(() => CheckItem, checkItem => checkItem.supervisor)
-  checkItems: CheckItem[]
-
   @CreateDateColumn()
   @Field({ nullable: true })
   createdAt?: Date

package/things-factory.config.js

@@ -4,12 +4,16 @@ import bootstrap from './dist-client/bootstrap'
 export default {
   route,
   routes: [
-    { tagname: 'supervision-main', page: 'supervision-main' },
-    { tagname: 'supervisor-list-page', page: 'supervisor-list' },
-    { tagname: 'project-report-list-page', page: 'project-report-list' },
-    { tagname: 'check-item-list-page', page: 'check-item-list' },
-    { tagname: 'issue-list-page', page: 'issue-list' },
-    { tagname: 'action-plan-list-page', page: 'action-plan-list' }
-  ],
+    'checklist-template-list', // 체크리스트 템플릿
+    'checklist-type-management', // 체크리스트 구분 관리
+    'building-inspection-list', // 층 검측 현황
+    'building-inspection-detail-drawing', // 층 검측 상세 - 검측 도면
+    'building-inspection-detail-checklist', // 층 검측 상세 - 검측 체크리스트
+  ].map(page => {
+    return {
+      page,
+      tagname: page
+    }
+  }),
   bootstrap
 }