@dssp/project 1.0.0-alpha.0 → 1.0.0-alpha.2

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

@@ -1,137 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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/index.ts

@@ -1,6 +0,0 @@
-import { Task } from './task'
-import { TaskQuery } from './task-query'
-import { TaskMutation } from './task-mutation'
-
-export const entities = [Task]
-export const resolvers = [TaskQuery, TaskMutation]

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

@@ -1,135 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { createAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
-
-import { Task } from './task'
-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
-
-    const result = await tx.getRepository(Task).save({
-      ...task,
-      domain,
-      creator: user,
-      updater: user
-    })
-
-    return result
-  }
-
-  @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> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(Task)
-    const task = await repository.findOne({
-      where: { id }
-    })
-
-    const result = await repository.save({
-      ...task,
-      ...patch,
-      updater: user
-    })
-
-    return result
-  }
-
-  @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[],
-    @Ctx() context: ResolverContext
-  ): Promise<Task[]> {
-    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 taskRepo = tx.getRepository(Task)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await taskRepo.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 task = await taskRepo.findOneBy({ id: updateRecord.id })
-
-        const result = await taskRepo.save({
-          ...task,
-          ...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 Task' })
-  async deleteTask(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Task).delete({ id })
-    await deleteAttachmentsByRef(null, { refBys: [id] }, context)
-
-    return true
-  }
-
-  @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
-
-    await tx.getRepository(Task).delete({
-      id: In(ids)
-    })
-
-    await deleteAttachmentsByRef(null, { refBys: ids }, context)
-
-    return true
-  }
-
-  @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> {
-    const { domain, tx } = context.state
-
-    await Promise.all(
-      tasks.map(async (task: TaskPatch) => {
-        const createdTask: Task = await tx.getRepository(Task).save({ domain, ...task })
-      })
-    )
-
-    return true
-  }
-}

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

@@ -1,169 +0,0 @@
-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, 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 {
-  @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> {
-    return await getRepository(Task).findOne({
-      where: { id },
-      relations: ['parent', 'taskResources']
-    })
-  }
-
-  @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 queryBuilder = getQueryBuilderFromListParams({
-      params,
-      repository: await getRepository(Task),
-      alias: 'tasks',
-      searchables: ['name', 'code']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  // @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
-      }
-    })
-  }
-
-  @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, { 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,75 +0,0 @@
-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({ description: '프로젝트 내에서 유니크한 작업 코드' })
-  code: string
-
-  @Field({ description: '작업의 이름' })
-  name: string
-
-  @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, description: '작업이 활성 상태인지 여부 (선택 사항)' })
-  active?: boolean
-
-  @Field({ nullable: true, description: '작업에 대한 추가 파라미터, JSON 형식으로 저장 (선택 사항)' })
-  params?: string
-}
-
-@InputType()
-export class TaskPatch {
-  @Field(type => ID, { nullable: true, description: '수정할 작업의 ID (선택 사항)' })
-  id?: string
-
-  @Field({ nullable: true, description: '프로젝트 내에서 유니크한 작업 코드 (선택 사항)' })
-  code?: string
-
-  @Field({ nullable: true, description: '작업의 이름 (선택 사항)' })
-  name?: string
-
-  @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, description: '작업이 활성 상태인지 여부 (선택 사항)' })
-  active?: boolean
-
-  @Field({ nullable: true, description: "생성('+') 또는 수정('M') 플래그 (선택 사항)" })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class TaskList {
-  @Field(type => [Task], { description: '작업 리스트 항목들' })
-  items: Task[]
-
-  @Field(type => Int, { description: '전체 작업 수' })
-  total: number
-}