@dssp/project 0.0.9 → 0.0.11

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

@@ -1,30 +1,39 @@
-import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
-import { Attachment } from '@things-factory/attachment-base'
+import { Resolver, Query, Field, FieldResolver, ObjectType, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
 import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
 import { User } from '@things-factory/auth-base'
-import { Task } from './task'
+import { Task, TaskType } from './task'
 import { TaskList } from './task-type'
+import { TaskResource } from '../task-resource/task-resource'
+import { ResourceType } from 'service/resource/resource'
+
+@ObjectType()
+export class DigestedResource {
+  @Field({ nullable: true, description: '자원 유형' })
+  type?: string
+
+  @Field({ nullable: true, description: '할당량' })
+  allocated?: number
+}
 
 @Resolver(Task)
 export class TaskQuery {
-  @Query(returns => Task!, { nullable: true, description: 'To fetch a Task' })
+  @Directive('@privilege(category: "project", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => Task!, { nullable: true, description: 'Fetch a single Task by its ID' })
   async task(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Task> {
-    const { domain } = context.state
-
     return await getRepository(Task).findOne({
-      where: { id }
+      where: { id },
+      relations: ['parent', 'taskResources']
     })
   }
 
-  @Query(returns => TaskList, { description: 'To fetch multiple Tasks' })
+  @Directive('@privilege(category: "project", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => TaskList, { description: 'Fetch multiple Tasks based on list parameters' })
   async tasks(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<TaskList> {
-    const { domain } = context.state
-
     const queryBuilder = getQueryBuilderFromListParams({
-      domain,
       params,
       repository: await getRepository(Task),
-      searchables: ['name', 'description']
+      alias: 'tasks',
+      searchables: ['name', 'code']
     })
 
     const [items, total] = await queryBuilder.getManyAndCount()
@@ -32,24 +41,128 @@ export class TaskQuery {
     return { items, total }
   }
 
-  @FieldResolver(type => String)
-  async thumbnail(@Root() task: Task): Promise<string | undefined> {
-    const attachment: Attachment = await getRepository(Attachment).findOne({
-      where: {
-        refType: Task.name,
-        refBy: task.id
+  // @FieldResolver(type => Date, { nullable: true, description: 'Calculate or return the start date of the task' })
+  // async startDate(@Root() task: Task): Promise<Date | undefined> {
+  //   if (task.type === TaskType.TASK) {
+  //     return task.startDate
+  //   } else {
+  //     const children = await getRepository(Task).find({ where: { parent: { id: task.id } } })
+  //     return children.reduce(
+  //       (earliest, child) => {
+  //         if (!earliest || (child.startDate && child.startDate < earliest)) {
+  //           return child.startDate
+  //         }
+  //         return earliest
+  //       },
+  //       undefined as Date | undefined
+  //     )
+  //   }
+  // }
+
+  // @FieldResolver(type => Date, { nullable: true, description: 'Calculate or return the end date of the task' })
+  // async endDate(@Root() task: Task): Promise<Date | undefined> {
+  //   if (task.type === TaskType.TASK) {
+  //     return task.endDate
+  //   } else {
+  //     const children = await getRepository(Task).find({ where: { parent: { id: task.id } } })
+  //     return children.reduce(
+  //       (latest, child) => {
+  //         if (!latest || (child.endDate && child.endDate > latest)) {
+  //           return child.endDate
+  //         }
+  //         return latest
+  //       },
+  //       undefined as Date | undefined
+  //     )
+  //   }
+  // }
+
+  // @FieldResolver(type => Number, { nullable: true, description: 'Calculate the duration of the task in days' })
+  // async duration(@Root() task: Task): Promise<number | undefined> {
+  //   if (task.type === TaskType.TASK) {
+  //     return task.duration
+  //   } else {
+  //     const startDate = await this.startDate(task)
+  //     const endDate = await this.endDate(task)
+
+  //     if (startDate && endDate) {
+  //       const durationInMs = endDate.getTime() - startDate.getTime()
+  //       const durationInDays = Math.ceil(durationInMs / (1000 * 60 * 60 * 24))
+  //       return durationInDays
+  //     }
+
+  //     return
+  //   }
+  // }
+
+  @FieldResolver(type => String, { nullable: true, description: 'Calculate the duration of the task in days' })
+  async length(@Root() task: Task): Promise<string | undefined> {
+    // if (task.type === TaskType.TASK) {
+    return `${task.duration || 1}d`
+    // } else {
+    //   const startDate = await this.startDate(task)
+    //   const endDate = await this.endDate(task)
+
+    //   if (startDate && endDate) {
+    //     const durationInMs = endDate.getTime() - startDate.getTime()
+    //     const durationInDays = Math.ceil(durationInMs / (1000 * 60 * 60 * 24))
+    //     return `${durationInDays || 1}d`
+    //   }
+
+    //   return
+    // }
+  }
+
+  @FieldResolver(type => [Task])
+  async children(
+    @Root() task: Task,
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<Task[]> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      params,
+      alias: 'tasks',
+      repository: await getRepository(Task),
+      searchables: ['name', 'code']
+    }).andWhere({ parent: { id: task.id } })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return items
+  }
+
+  @FieldResolver(type => [TaskResource], { description: 'Return the list of resources allocated to the task' })
+  async taskResources(@Root() task: Task): Promise<TaskResource[]> {
+    return task?.id && (await getRepository(TaskResource).find({ where: { task: { id: task.id } } }))
+  }
+
+  @FieldResolver(type => [DigestedResource], { description: 'Return the simple list of resources allocated to the task' })
+  async resources(@Root() task: Task): Promise<DigestedResource[]> {
+    const taskResources =
+      task?.id &&
+      (await getRepository(TaskResource).find({
+        where: {
+          task: { id: task.id }
+        },
+        relations: ['resource']
+      }))
+
+    return (taskResources || []).map(taskResource => {
+      return {
+        type: taskResource.resource.name,
+        allocated: taskResource.quantity
       }
     })
-
-    return attachment?.fullpath
   }
 
-  @FieldResolver(type => User)
+  @FieldResolver(type => User, { description: 'Fetch the user who last updated the task' })
   async updater(@Root() task: Task): Promise<User> {
     return await getRepository(User).findOneBy({ id: task.updaterId })
   }
 
-  @FieldResolver(type => User)
+  @FieldResolver(type => User, { description: 'Fetch the user who created the task' })
   async creator(@Root() task: Task): Promise<User> {
     return await getRepository(User).findOneBy({ id: task.creatorId })
   }

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

@@ -1,49 +1,75 @@
-import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
-import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
 import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
-
 import { ObjectRef, ScalarObject } from '@things-factory/shell'
-
 import { Task } from './task'
 
+@InputType()
+export class ObjectRefForProject extends ObjectRef {
+  @Field({ nullable: true, description: '프로젝트 이름 (선택 사항)' })
+  name?: string
+}
+
+@InputType()
+export class ObjectRefForTask extends ObjectRef {
+  @Field({ nullable: true, description: '작업 코드 (선택 사항)' })
+  code?: string
+}
+
 @InputType()
 export class NewTask {
-  @Field()
+  @Field({ description: '프로젝트 내에서 유니크한 작업 코드' })
+  code: string
+
+  @Field({ description: '작업의 이름' })
   name: string
 
-  @Field({ nullable: true })
+  @Field(type => ObjectRefForProject, { nullable: true, description: '작업이 속한 프로젝트 (선택 사항)' })
+  project?: ObjectRefForProject
+
+  @Field(type => ObjectRefForTask, { nullable: true, description: '부모 작업, 해당 작업이 하위 작업인 경우 (선택 사항)' })
+  parent?: ObjectRefForTask
+
+  @Field({ nullable: true, description: '작업에 대한 설명 (선택 사항)' })
   description?: string
 
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: '작업이 활성 상태인지 여부 (선택 사항)' })
   active?: boolean
 
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: '작업에 대한 추가 파라미터, JSON 형식으로 저장 (선택 사항)' })
   params?: string
 }
 
 @InputType()
 export class TaskPatch {
-  @Field(type => ID, { nullable: true })
+  @Field(type => ID, { nullable: true, description: '수정할 작업의 ID (선택 사항)' })
   id?: string
 
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: '프로젝트 내에서 유니크한 작업 코드 (선택 사항)' })
+  code?: string
+
+  @Field({ nullable: true, description: '작업의 이름 (선택 사항)' })
   name?: string
 
-  @Field({ nullable: true })
+  @Field(type => ObjectRefForProject, { nullable: true, description: '작업이 속한 프로젝트 (선택 사항)' })
+  project?: ObjectRefForProject
+
+  @Field(type => ObjectRefForTask, { nullable: true, description: '부모 작업, 해당 작업이 하위 작업인 경우 (선택 사항)' })
+  parent?: ObjectRefForTask
+
+  @Field({ nullable: true, description: '작업에 대한 설명 (선택 사항)' })
   description?: string
 
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: '작업이 활성 상태인지 여부 (선택 사항)' })
   active?: boolean
 
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: "생성('+') 또는 수정('M') 플래그 (선택 사항)" })
   cuFlag?: string
 }
 
 @ObjectType()
 export class TaskList {
-  @Field(type => [Task])
+  @Field(type => [Task], { description: '작업 리스트 항목들' })
   items: Task[]
 
-  @Field(type => Int)
+  @Field(type => Int, { description: '전체 작업 수' })
   total: number
 }

package/server/service/task/task.ts

@@ -4,23 +4,23 @@ import {
   DeleteDateColumn,
   Entity,
   Index,
-  JoinTable,
   Column,
   RelationId,
-  ManyToMany,
   ManyToOne,
   OneToMany,
   PrimaryGeneratedColumn
 } from 'typeorm'
 import { ObjectType, Field, ID, registerEnumType } from 'type-graphql'
 
+import { ScalarObject } from '@things-factory/shell'
 import { User } from '@things-factory/auth-base'
 import { Project } from '../project/project'
-import { Checklist } from '../checklist/checklist'
+// import { Checklist } from '@dssp/supervisor'
+import { TaskResource } from '../task-resource/task-resource'
 
 export enum TaskType {
-  GROUP = 'GROUP',
-  TASK = 'TASK'
+  GROUP = 'group',
+  TASK = 'task'
 }
 
 registerEnumType(TaskType, {
@@ -29,13 +29,17 @@ registerEnumType(TaskType, {
 })
 
 @Entity()
-@Index('ix_task_0', (task: Task) => [task.project], { where: '"deleted_at" IS NULL' })
+@Index('ix_task_project_code', (task: Task) => [task.project, task.code], { unique: true, where: '"deleted_at" IS NULL' })
 @ObjectType({ description: '공정표 작업 정보' })
 export class Task {
   @PrimaryGeneratedColumn('uuid')
   @Field(type => ID)
   readonly id: string
 
+  @Column({ nullable: false, comment: '프로젝트 내에서 유니크한 작업 코드' })
+  @Field({ nullable: false })
+  code: string
+
   @Column({ nullable: true, comment: '작업 명' })
   @Field({ nullable: true })
   name?: string
@@ -44,9 +48,16 @@ export class Task {
   @Field({ nullable: true })
   type?: TaskType
 
-  @Column({ nullable: true, comment: '테스크에 그룹(부모)가 있을 시 taskId' })
+  @ManyToOne(type => Task, task => task.children, { nullable: true })
   @Field({ nullable: true })
-  parentTaskId?: string
+  parent: Task
+
+  @RelationId((task: Task) => task.parent)
+  parentId?: string
+
+  @OneToMany(type => Task, task => task.parent, { nullable: true })
+  @Field(type => [Task], { nullable: true })
+  children?: Task[]
 
   @Column({ nullable: true, comment: '시작일' })
   @Field({ nullable: true })
@@ -56,18 +67,36 @@ export class Task {
   @Field({ nullable: true })
   endDate?: Date
 
-  // 프로젝트 정보 (상위 테이블 참조)
-  @Field(() => Project)
-  @ManyToOne(() => Project, project => project.tasks)
+  @Column({ nullable: true, comment: '기간' })
+  @Field({ nullable: true })
+  duration?: number
+
+  @Column({ nullable: true, comment: '선행 태스크 코드' })
+  @Field({ nullable: true })
+  dependsOn?: string
+
+  @ManyToOne(type => Project, project => project.tasks)
+  @Field(type => Project)
   project?: Project
 
   @RelationId((task: Task) => task.project)
   projectId?: string
 
-  // 체크리스트 정보 (하위 테이블 참조)
-  @Field(() => Checklist)
-  @OneToMany(() => Checklist, checklist => checklist.task)
-  checklists?: Checklist[]
+  @Column('simple-json', { nullable: true, default: null })
+  @Field(type => ScalarObject, { nullable: true })
+  tags?: string[]
+
+  @Column({ nullable: true, comment: '진행율' })
+  @Field({ nullable: true })
+  progress?: number
+
+  // @OneToMany(type => Checklist, checklist => checklist.task, { nullable: true })
+  // @Field(type => [Checklist], { nullable: true })
+  // checklists?: Checklist[]
+
+  @OneToMany(type => TaskResource, taskResource => taskResource.task, { cascade: true })
+  @Field(type => [TaskResource], { nullable: true })
+  taskResources?: TaskResource[]
 
   @CreateDateColumn()
   @Field({ nullable: true })

package/server/service/task-resource/index.ts

@@ -0,0 +1,7 @@
+import { TaskResource } from './task-resource'
+import { TaskResourceQuery } from './task-resource-query'
+import { TaskResourceMutation } from './task-resource-mutation'
+
+export const entities = [TaskResource]
+export const resolvers = [TaskResourceQuery, TaskResourceMutation]
+export const subscribers = []

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

@@ -0,0 +1,140 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { TaskResource } from './task-resource'
+import { NewTaskResource, TaskResourcePatch } from './task-resource-type'
+
+@Resolver(TaskResource)
+export class TaskResourceMutation {
+  @Directive('@transaction')
+  @Directive('@privilege(category: "project", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => TaskResource, { description: 'To create new TaskResource' })
+  async createTaskResource(
+    @Arg('taskResource') taskResource: NewTaskResource,
+    @Ctx() context: ResolverContext
+  ): Promise<TaskResource> {
+    const { domain, user, tx } = context.state
+
+    const result = await tx.getRepository(TaskResource).save({
+      ...taskResource,
+      domain,
+      creator: user,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "project", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => TaskResource, { description: 'To modify TaskResource information' })
+  async updateTaskResource(
+    @Arg('id') id: string,
+    @Arg('patch') patch: TaskResourcePatch,
+    @Ctx() context: ResolverContext
+  ): Promise<TaskResource> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(TaskResource)
+    const taskResource = await repository.findOne({
+      where: { id }
+    })
+
+    const result = await repository.save({
+      ...taskResource,
+      ...patch,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "project", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => [TaskResource], { description: "To modify multiple TaskResources' information" })
+  async updateMultipleTaskResource(
+    @Arg('patches', type => [TaskResourcePatch]) patches: TaskResourcePatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<TaskResource[]> {
+    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 taskResourceRepo = tx.getRepository(TaskResource)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await taskResourceRepo.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 taskResource = await taskResourceRepo.findOneBy({ id: updateRecord.id })
+
+        const result = await taskResourceRepo.save({
+          ...taskResource,
+          ...updateRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "project", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => Boolean, { description: 'To delete TaskResource' })
+  async deleteTaskResource(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(TaskResource).delete({ id })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "project", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => Boolean, { description: 'To delete multiple TaskResources' })
+  async deleteTaskResources(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(TaskResource).delete({
+      id: In(ids)
+    })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "project", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => Boolean, { description: 'To import multiple TaskResources' })
+  async importTaskResources(
+    @Arg('taskResources', type => [TaskResourcePatch]) taskResources: TaskResourcePatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await Promise.all(
+      taskResources.map(async (taskResource: TaskResourcePatch) => {
+        const createdTaskResource: TaskResource = await tx.getRepository(TaskResource).save({ domain, ...taskResource })
+      })
+    )
+
+    return true
+  }
+}

package/server/service/task-resource/task-resource-query.ts

@@ -0,0 +1,36 @@
+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 { TaskResource } from './task-resource'
+import { TaskResourceList } from './task-resource-type'
+
+@Resolver(TaskResource)
+export class TaskResourceQuery {
+  @Directive('@privilege(category: "project", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => TaskResource!, { nullable: true, description: 'To fetch a TaskResource' })
+  async taskResource(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<TaskResource> {
+    const { domain } = context.state
+
+    return await getRepository(TaskResource).findOne({
+      where: { id }
+    })
+  }
+
+  @Directive('@privilege(category: "project", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => TaskResourceList, { description: 'To fetch multiple TaskResources' })
+  async taskResources(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<TaskResourceList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(TaskResource),
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+}

package/server/service/task-resource/task-resource-type.ts

@@ -0,0 +1,41 @@
+import { InputType, Field, ID, ObjectType, Int } from 'type-graphql'
+import { TaskResource } from './task-resource'
+
+@InputType()
+export class NewTaskResource {
+  @Field(type => ID)
+  taskId: string
+
+  @Field(type => ID)
+  resourceId: string
+
+  @Field()
+  quantity: number
+}
+
+@InputType()
+export class TaskResourcePatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field(type => ID, { nullable: true })
+  taskId?: string
+
+  @Field(type => ID, { nullable: true })
+  resourceId?: string
+
+  @Field({ nullable: true })
+  quantity?: number
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class TaskResourceList {
+  @Field(type => [TaskResource])
+  items: TaskResource[]
+
+  @Field(type => Int)
+  total: number
+}

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

@@ -0,0 +1,51 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  RelationId,
+  ManyToOne,
+  Column,
+  CreateDateColumn,
+  UpdateDateColumn,
+  DeleteDateColumn
+} from 'typeorm'
+import { ObjectType, Field, ID } from 'type-graphql'
+import { Task } from '../task/task'
+import { Resource } from '../resource/resource'
+
+@Entity()
+@ObjectType({ description: '작업에 소요되는 자원' })
+export class TaskResource {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(() => Task, task => task.taskResources, { nullable: false })
+  @Field(type => Task)
+  task: Task
+
+  @RelationId((taskResource: TaskResource) => taskResource.task)
+  taskId: string
+
+  @ManyToOne(() => Resource, resource => resource.taskResources, { nullable: false })
+  @Field(type => Resource)
+  resource: Resource
+
+  @RelationId((taskResource: TaskResource) => taskResource.resource)
+  resourceId: string
+
+  @Column({ type: 'float', nullable: false, comment: '소요량 (예: 8, 5 등)' })
+  @Field({ nullable: false })
+  quantity: number
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @DeleteDateColumn()
+  @Field({ nullable: true })
+  deletedAt?: Date
+}

package/things-factory.config.js

@@ -14,6 +14,7 @@ export default {
     'manager-management', // 담당자 관리
     'worker-type-management', // 인력 관리
     'construction-type-management', // 공종 관리
+    'inspection-drawing-type-management', // 도면 타입 및 검측 부위 관리
   ].map(page => {
     return {
       page,