@dssp/project 0.0.8 → 0.0.10

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

@@ -1,10 +1,12 @@
-import { Resolver, Query, FieldResolver, Root, Arg, Ctx } from 'type-graphql'
-import { Domain, getRepository } from '@things-factory/shell'
+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 { InspectionSummary, ProjectList } from './project-type'
-import { BuildingComplex, InspectionStatus } from '@dssp/building-complex'
+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 {
@@ -18,51 +20,41 @@ export class ProjectQuery {
   }
 
   @Query(returns => ProjectList, { description: '프로젝트 리스트' })
-  async projects(@Arg('projectName') projectName: string, @Ctx() context: ResolverContext): Promise<ProjectList> {
+  async projects(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ProjectList> {
     const { domain } = context.state
-    // const { page = 1, limit = 0 } = params.pagination || {}
 
-    const queryBuilder = await getRepository(Project)
-      .createQueryBuilder('p')
-      .innerJoinAndSelect('p.buildingComplex', 'bc')
-      .where('p.domain = :domain', { domain: domain.id })
-      .orderBy('p.created_at', 'DESC')
-    // .offset((page - 1) * limit)
-    // .limit(limit)
-
-    if (projectName) {
-      projectName = `%${projectName}%`
-      queryBuilder.andWhere('p.name LIKE :projectName', { projectName })
-    }
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(Project),
+      searchables: ['name', 'description']
+    })
 
     const [items, total] = await queryBuilder.getManyAndCount()
 
     return { items, total }
   }
 
-  @Query(returns => InspectionSummary, { description: '프로젝트의 검측상태 별 카운트' })
-  async inspectionSummary(@Arg('projectId') projectId: string, @Ctx() context: ResolverContext): Promise<InspectionSummary> {
+  @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
 
-    const queryBuilder = getRepository(Project)
-      .createQueryBuilder('p')
-      .select(`COUNT(CASE WHEN bi.status='${InspectionStatus.REQUEST}' THEN 1 ELSE NULL END) AS request`)
-      .addSelect(`COUNT(CASE WHEN bi.status='${InspectionStatus.PASS}' THEN 1 ELSE NULL END) AS pass`)
-      .addSelect(`COUNT(CASE WHEN bi.status='${InspectionStatus.FAIL}' THEN 1 ELSE NULL END) AS fail`)
-      .innerJoin('p.buildingComplex', 'bc')
-      .innerJoin('bc.buildings', 'b')
-      .innerJoin('b.buildingLevels', 'bl')
-      .innerJoin('bl.buildingInspections', 'bi')
-      .where('p.domain = :domain', { domain: domain.id })
-      .andWhere('p.id = :projectId', { projectId })
-      .groupBy('p.id')
+    return await getRepository(Project).findOne({
+      where: { domain: { id: domain.id }, buildingComplex: { id: buildingComplexId } }
+    })
+  }
 
-    const result = (await queryBuilder.getRawOne()) || {}
-    return {
-      request: result.request || 0,
-      pass: result.pass || 0,
-      fail: result.fail || 0
-    }
+  @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)

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

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

package/server/service/project/project.ts

@@ -12,7 +12,7 @@ import {
   JoinColumn,
   PrimaryGeneratedColumn
 } from 'typeorm'
-import { ObjectType, Field, ID, registerEnumType } from 'type-graphql'
+import { ObjectType, Field, ID } from 'type-graphql'
 
 import { Domain, roundTransformer } from '@things-factory/shell'
 import { User } from '@things-factory/auth-base'
@@ -21,18 +21,13 @@ import { BuildingComplex } from '@dssp/building-complex'
 import { Attachment } from '@things-factory/attachment-base'
 
 export enum ProjectStatus {
-  'PROCEEDING' = '10',
-  'COMPLICATED' = '20'
+  'ONGOING' = '10',
+  'COMPLETED' = '20'
 }
 
-registerEnumType(ProjectStatus, {
-  name: 'ProjectStatus',
-  description: '프로젝트 상태'
-})
-
-@Entity()
-@Index('ix_project_0', (project: Project) => [project.buildingComplex], { unique: true, where: '"deleted_at" IS NULL' })
 @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)
@@ -49,7 +44,7 @@ export class Project {
   @Field({ nullable: false })
   name?: string
 
-  @Column({ nullable: false, default: ProjectStatus.PROCEEDING, comment: '프로젝트 상태 (10: 진행중, 20: 완료)' })
+  @Column({ nullable: false, default: ProjectStatus.ONGOING, comment: '프로젝트 상태 (10: 진행중, 20: 완료)' })
   @Field({ nullable: false })
   state?: ProjectStatus
 
@@ -99,10 +94,14 @@ export class Project {
   buildingComplexId?: string
 
   // 작업 정보 (하위 테이블 참조)
-  @Field(() => [Task], { nullable: true })
   @OneToMany(() => Task, task => task.project)
+  @Field(() => [Task], { nullable: true })
   tasks?: Task[]
 
+  // 루트 작업 정보 (부모가 없는 상위 작업)
+  @Field(() => [Task], { nullable: true })
+  rootTasks?: Task[]
+
   @CreateDateColumn()
   @Field({ nullable: true })
   createdAt?: Date

package/server/service/resource/index.ts

@@ -0,0 +1,7 @@
+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 = []

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

@@ -0,0 +1,137 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { Resource } from './resource'
+import { NewResource, ResourcePatch } from './resource-type'
+
+@Resolver(Resource)
+export class ResourceMutation {
+  @Directive('@transaction')
+  @Directive('@privilege(category: "project", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => Resource, { description: 'To create new Resource' })
+  async createResource(@Arg('resource') resource: NewResource, @Ctx() context: ResolverContext): Promise<Resource> {
+    const { domain, user, tx } = context.state
+
+    const result = await tx.getRepository(Resource).save({
+      ...resource,
+      domain,
+      creator: user,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "project", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => Resource, { description: 'To modify Resource information' })
+  async updateResource(
+    @Arg('id') id: string,
+    @Arg('patch') patch: ResourcePatch,
+    @Ctx() context: ResolverContext
+  ): Promise<Resource> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(Resource)
+    const resource = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    const result = await repository.save({
+      ...resource,
+      ...patch,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "project", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => [Resource], { description: "To modify multiple Resources' information" })
+  async updateMultipleResource(
+    @Arg('patches', type => [ResourcePatch]) patches: ResourcePatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<Resource[]> {
+    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 resourceRepo = tx.getRepository(Resource)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await resourceRepo.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 resource = await resourceRepo.findOneBy({ id: updateRecord.id })
+
+        const result = await resourceRepo.save({
+          ...resource,
+          ...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 Resource' })
+  async deleteResource(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Resource).delete({ domain: { id: domain.id }, id })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple Resources' })
+  async deleteResources(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Resource).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "project", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => Boolean, { description: 'To import multiple Resources' })
+  async importResources(
+    @Arg('resources', type => [ResourcePatch]) resources: ResourcePatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await Promise.all(
+      resources.map(async (resource: ResourcePatch) => {
+        const createdResource: Resource = await tx.getRepository(Resource).save({ domain, ...resource })
+      })
+    )
+
+    return true
+  }
+}

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

@@ -0,0 +1,50 @@
+import { Resolver, Query, FieldResolver, 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 { Resource } from './resource'
+import { ResourceList } from './resource-type'
+
+@Resolver(Resource)
+export class ResourceQuery {
+  @Directive('@privilege(category: "project", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => Resource!, { nullable: true, description: 'To fetch a Resource' })
+  async resource(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Resource> {
+    const { domain } = context.state
+
+    return await getRepository(Resource).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Directive('@privilege(category: "project", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => ResourceList, { description: 'To fetch multiple Resources' })
+  async resources(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ResourceList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(Resource),
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() resource: Resource): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: resource.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() resource: Resource): Promise<User> {
+    return await getRepository(User).findOneBy({ id: resource.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() resource: Resource): Promise<User> {
+    return await getRepository(User).findOneBy({ id: resource.creatorId })
+  }
+}

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

@@ -0,0 +1,41 @@
+import { InputType, Field, ID, ObjectType, Int } from 'type-graphql'
+import { Resource, ResourceType } from './resource'
+
+@InputType()
+export class NewResource {
+  @Field()
+  name: string
+
+  @Field(type => ResourceType)
+  type: ResourceType
+
+  @Field()
+  unit: string
+}
+
+@InputType()
+export class ResourcePatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field(type => ResourceType, { nullable: true })
+  type?: ResourceType
+
+  @Field({ nullable: true })
+  unit?: string
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class ResourceList {
+  @Field(type => [Resource])
+  items: Resource[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/resource/resource.ts

@@ -0,0 +1,82 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  DeleteDateColumn,
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  ManyToOne,
+  RelationId,
+  OneToMany
+} from 'typeorm'
+import { ObjectType, Field, ID, registerEnumType } from 'type-graphql'
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { TaskResource } from '../task-resource/task-resource'
+
+export enum ResourceType {
+  HUMAN = 'HUMAN',
+  MATERIAL = 'MATERIAL',
+  EQUIPMENT = 'EQUIPMENT'
+}
+
+registerEnumType(ResourceType, {
+  name: 'ResourceType',
+  description: '자원 유형'
+})
+
+@Entity()
+@ObjectType({ description: '자원' })
+export class Resource {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((resource: Resource) => resource.domain)
+  domainId?: string
+
+  @Column({ nullable: false, comment: '자원 이름' })
+  @Field({ nullable: false })
+  name?: string
+
+  @Column({ nullable: false, default: ResourceType.HUMAN, comment: '자원 유형' })
+  @Field({ nullable: false })
+  type: ResourceType
+
+  @Column({ nullable: false, comment: '단위 (예: man/day, kg, hour 등)' })
+  @Field({ nullable: false })
+  unit: 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((resource: Resource) => resource.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((resource: Resource) => resource.updater)
+  updaterId?: string
+
+  @OneToMany(() => TaskResource, taskResource => taskResource.resource)
+  taskResources?: TaskResource[]
+}

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

@@ -9,6 +9,7 @@ import { NewTask, TaskPatch } from './task-type'
 @Resolver(Task)
 export class TaskMutation {
   @Directive('@transaction')
+  @Directive('@privilege(category: "project", privilege: "mutation", domainOwnerGranted: true)')
   @Mutation(returns => Task, { description: 'To create new Task' })
   async createTask(@Arg('task') task: NewTask, @Ctx() context: ResolverContext): Promise<Task> {
     const { domain, user, tx } = context.state
@@ -24,12 +25,9 @@ export class TaskMutation {
   }
 
   @Directive('@transaction')
+  @Directive('@privilege(category: "project", privilege: "mutation", domainOwnerGranted: true)')
   @Mutation(returns => Task, { description: 'To modify Task information' })
-  async updateTask(
-    @Arg('id') id: string,
-    @Arg('patch') patch: TaskPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<Task> {
+  async updateTask(@Arg('id') id: string, @Arg('patch') patch: TaskPatch, @Ctx() context: ResolverContext): Promise<Task> {
     const { domain, user, tx } = context.state
 
     const repository = tx.getRepository(Task)
@@ -47,6 +45,7 @@ export class TaskMutation {
   }
 
   @Directive('@transaction')
+  @Directive('@privilege(category: "project", privilege: "mutation", domainOwnerGranted: true)')
   @Mutation(returns => [Task], { description: "To modify multiple Tasks' information" })
   async updateMultipleTask(
     @Arg('patches', type => [TaskPatch]) patches: TaskPatch[],
@@ -93,6 +92,7 @@ export class TaskMutation {
   }
 
   @Directive('@transaction')
+  @Directive('@privilege(category: "project", privilege: "mutation", domainOwnerGranted: true)')
   @Mutation(returns => Boolean, { description: 'To delete Task' })
   async deleteTask(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
@@ -104,6 +104,7 @@ export class TaskMutation {
   }
 
   @Directive('@transaction')
+  @Directive('@privilege(category: "project", privilege: "mutation", domainOwnerGranted: true)')
   @Mutation(returns => Boolean, { description: 'To delete multiple Tasks' })
   async deleteTasks(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
@@ -118,11 +119,9 @@ export class TaskMutation {
   }
 
   @Directive('@transaction')
+  @Directive('@privilege(category: "project", privilege: "mutation", domainOwnerGranted: true)')
   @Mutation(returns => Boolean, { description: 'To import multiple Tasks' })
-  async importTasks(
-    @Arg('tasks', type => [TaskPatch]) tasks: TaskPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
+  async importTasks(@Arg('tasks', type => [TaskPatch]) tasks: TaskPatch[], @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
     await Promise.all(