@things-factory/dataset 8.0.0-beta.8 → 8.0.0

package/server/service/data-set/data-set-query.ts

@@ -0,0 +1,461 @@
+import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { Brackets, In } from 'typeorm'
+
+import { Attachment } from '@things-factory/attachment-base'
+import { Role, User } from '@things-factory/auth-base'
+import { Board } from '@things-factory/board-service'
+import { ApprovalLineItem } from '@things-factory/organization'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+import { AssigneeItem } from '@things-factory/worklist'
+import { Scenario } from '@things-factory/integration-base'
+
+import { DataKeySet } from '../data-key-set/data-key-set'
+import { DataSample } from '../data-sample/data-sample'
+import { DataItem } from './data-item-type'
+import { DataSet, DataSetState } from './data-set'
+import { DataSetList } from './data-set-type'
+
+var parser = require('cron-parser')
+
+@Resolver(DataSet)
+export class DataSetQuery {
+  // 데이터셋을 ID로 조회
+  @Directive('@privilege(category: "data-set", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => DataSet, { description: 'To fetch a DataSet' })
+  async dataSet(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<DataSet> {
+    const { domain } = context.state
+
+    return await getRepository(DataSet).findOne({
+      where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, id }
+    })
+  }
+
+  // 데이터셋을 이름으로 조회
+  @Directive('@privilege(category: "data-set", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => DataSet, { description: 'To fetch a DataSet by name' })
+  async dataSetByName(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<DataSet> {
+    const { domain } = context.state
+
+    return await getRepository(DataSet).findOne({
+      where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, name }
+    })
+  }
+
+  // 여러 데이터셋을 조회
+  @Directive('@privilege(category: "data-set", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => DataSetList, { description: 'To fetch multiple DataSets' })
+  async dataSets(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<DataSetList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      repository: getRepository(DataSet),
+      params,
+      domain,
+      alias: 'dataset',
+      searchables: ['name', 'description', 'tag', 'supervisoryRole']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  // 데이터 입력을 위한 데이터셋 조회
+  @Query(returns => DataSetList, { description: 'To fetch multiple DataSets for data entry manually' })
+  async dataSetsForEntry(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<DataSetList> {
+    var { domain, user } = context.state
+
+    // 조회한 사용자가 entry-role을 가진 data-set 리스트만 반환
+    user = await getRepository(User).findOne({
+      where: { id: user.id },
+      relations: ['roles']
+    })
+
+    const roles = user.roles
+      .filter(role => role.domainId === domain.id || (domain.parentId && role.domainId === domain.parentId))
+      .map(role => role.id)
+
+    if (!roles.length) {
+      return { items: [], total: 0 }
+    }
+
+    const [items, total] = await getQueryBuilderFromListParams({
+      repository: getRepository(DataSet),
+      params,
+      domain,
+      alias: 'dataset',
+      searchables: ['name', 'description']
+    })
+      .andWhere('dataset.active = :active', { active: true })
+      .andWhere(
+        new Brackets(qb => {
+          qb.where('dataset.supervisoryRole IN (:...roles)').orWhere('dataset.entryRole IN (:...roles)')
+        })
+      )
+      .setParameter('roles', roles)
+      .getManyAndCount()
+
+    return {
+      items,
+      total
+    }
+  }
+
+  // 데이터 보고를 위한 데이터셋 조회
+  @Query(returns => DataSetList, { description: 'To fetch multiple DataSets to see data report' })
+  async dataSetsForReport(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<DataSetList> {
+    var { domain, user } = context.state
+
+    // 조회한 사용자가 supervisory 역할을 가진 data-set 리스트만 반환
+    user = await getRepository(User).findOne({
+      where: { id: user.id },
+      relations: ['roles']
+    })
+    const roles = user.roles.filter(role => role.domainId === domain.id).map(role => role.id)
+
+    if (!roles.length) {
+      return { items: [], total: 0 }
+    }
+
+    const [items, total] = await getQueryBuilderFromListParams({
+      repository: getRepository(DataSet),
+      params,
+      domain,
+      alias: 'dataset',
+      searchables: ['name', 'description']
+    })
+      .andWhere(`dataset.active = :active`, { active: true })
+      .andWhere('dataset.supervisoryRole IN (:...roles)', { roles })
+      .getManyAndCount()
+
+    return { items, total }
+  }
+
+  // 데이터셋의 상태를 조회
+  @FieldResolver(type => DataSetState)
+  async status(@Root() dataSet: DataSet): Promise<DataSetState> {
+    // 스케줄러 서비스에서 정보 가져오기
+    return {
+      id: '',
+      scheduleId: '',
+      state: '',
+      startedAt: new Date(),
+      nextSchedule: new Date()
+    }
+  }
+
+  // 데이터셋의 데이터 항목을 조회
+  @FieldResolver(type => [DataItem])
+  async dataItems(@Root() dataSet: DataSet): Promise<DataItem[]> {
+    if (dataSet.dataItems instanceof Array) {
+      return dataSet.dataItems.filter(item => item.name)
+    }
+
+    return []
+  }
+
+  // 데이터셋의 entry 역할을 조회
+  @FieldResolver(type => Role)
+  async entryRole(@Root() dataSet: DataSet): Promise<Role> {
+    return (
+      dataSet.entryRole ||
+      (dataSet.entryRoleId &&
+        (await getRepository(Role).findOneBy({
+          id: dataSet.entryRoleId
+        })))
+    )
+  }
+
+  // 데이터셋의 supervisory 역할을 조회
+  @FieldResolver(type => Role, { description: 'Retrieves the supervisory role for the dataset' })
+  async supervisoryRole(@Root() dataSet: DataSet): Promise<Role> {
+    return (
+      dataSet.supervisoryRole ||
+      (dataSet.supervisoryRoleId &&
+        (await getRepository(Role).findOneBy({
+          id: dataSet.supervisoryRoleId
+        })))
+    )
+  }
+
+  // 데이터셋의 resolver 역할을 조회
+  @FieldResolver(type => Role, { description: 'Retrieves the resolver role for the dataset' })
+  async resolverRole(@Root() dataSet: DataSet): Promise<Role> {
+    return (
+      dataSet.resolverRole ||
+      (dataSet.resolverRoleId &&
+        (await getRepository(Role).findOneBy({
+          id: dataSet.resolverRoleId
+        })))
+    )
+  }
+
+  @FieldResolver(type => [AssigneeItem], { description: 'Retrieves the assignee items for the dataset' })
+  async assignees(@Root() dataSet: DataSet, @Ctx() context: ResolverContext): Promise<AssigneeItem[]> {
+    const { domain, user } = context.state
+    const { assignees } = dataSet
+
+    if (!assignees || !(assignees instanceof Array)) {
+      return null
+    }
+
+    var assigneeItemList = []
+
+    for (let item of assignees) {
+      // "value" deprecated. to be removed
+      var { type, assignee, value } = item
+      var id = assignee?.id || id
+
+      switch (type) {
+        case 'Employee':
+          assignee = id && (await getRepository('Employee').findOneBy({ domain: { id: domain.id }, id }))
+          break
+        case 'Department':
+          assignee = id && (await getRepository('Department').findOneBy({ domain: { id: domain.id }, id }))
+          break
+        case 'Role':
+          assignee = id && (await getRepository('Role').findOneBy({ domain: { id: domain.id }, id }))
+          break
+        case 'Myself':
+          assignee = user
+          break
+        case 'MyDepartment':
+        case 'MySupervisor':
+          break
+        default:
+      }
+
+      id ? assigneeItemList.push({ type, assignee }) : assigneeItemList.push({ type })
+    }
+
+    return assigneeItemList
+  }
+
+  @FieldResolver(type => [ApprovalLineItem], { description: 'Retrieves the approval line items for the dataset' })
+  async approvalLine(@Root() dataSet: DataSet, @Ctx() context: ResolverContext): Promise<ApprovalLineItem[]> {
+    const { domain, user } = context.state
+    const { reviewApprovalLine } = dataSet
+
+    if (!reviewApprovalLine || !(reviewApprovalLine instanceof Array)) {
+      return null
+    }
+
+    var approvalLineItems = []
+
+    for (let item of reviewApprovalLine) {
+      // "value" deprecated. to be removed
+      var { type, approver, value } = item
+      var id = approver?.id || value
+      approver = null
+
+      switch (type) {
+        case 'Employee':
+          approver = id && (await getRepository('Employee').findOneBy({ domain: { id: domain.id }, id }))
+          break
+        case 'Department':
+          approver = id && (await getRepository('Department').findOneBy({ domain: { id: domain.id }, id }))
+          break
+        case 'Role':
+          approver = id && (await getRepository('Role').findOneBy({ domain: { id: domain.id }, id }))
+          break
+        case 'Myself':
+          approver = user
+          break
+        case 'MyDepartment':
+        case 'MySupervisor':
+          break
+        default:
+      }
+
+      id ? approvalLineItems.push({ type, approver }) : approvalLineItems.push({ type })
+    }
+
+    return approvalLineItems
+  }
+
+  @FieldResolver(type => Board, { nullable: true, description: 'Retrieves the entry board for the dataset' })
+  async entryBoard(@Root() dataSet: DataSet): Promise<Board> {
+    if (dataSet.entryType == 'board' && dataSet.entryView) {
+      return await getRepository(Board).findOneBy({ id: dataSet.entryView })
+    }
+  }
+
+  @FieldResolver(type => Board, { nullable: true, description: 'Retrieves the monitor board for the dataset' })
+  async monitorBoard(@Root() dataSet: DataSet): Promise<Board> {
+    if (dataSet.monitorType == 'board' && dataSet.monitorView) {
+      return await getRepository(Board).findOneBy({ id: dataSet.monitorView })
+    }
+  }
+
+  @FieldResolver(type => DataKeySet, { nullable: true, description: 'Retrieves the data key set for the dataset' })
+  async dataKeySet(@Root() dataSet: DataSet): Promise<DataKeySet> {
+    return (
+      dataSet.dataKeySet ||
+      (dataSet.dataKeySetId &&
+        (await getRepository(DataKeySet).findOneBy({
+          id: dataSet.dataKeySetId
+        })))
+    )
+  }
+
+  @FieldResolver(type => Scenario, { description: 'Retrieves the normal scenario for the dataset.' })
+  async normalScenario(@Root() dataSet: DataSet): Promise<Scenario> {
+    return (
+      dataSet.normalScenario ||
+      (dataSet.normalScenarioId &&
+        (await getRepository(Scenario).findOneBy({
+          id: dataSet.normalScenarioId
+        })))
+    )
+  }
+
+  @FieldResolver(type => Scenario, { description: 'Retrieves the outlier scenario for the dataset.' })
+  async outlierScenario(@Root() dataSet: DataSet): Promise<Scenario> {
+    return (
+      dataSet.outlierScenario ||
+      (dataSet.outlierScenarioId &&
+        (await getRepository(Scenario).findOneBy({
+          id: dataSet.outlierScenarioId
+        })))
+    )
+  }
+
+  // 데이터셋의 도메인을 조회
+  @FieldResolver(type => Domain)
+  async domain(@Root() dataSet: DataSet): Promise<Domain> {
+    return dataSet.domainId && (await getRepository(Domain).findOneBy({ id: dataSet.domainId }))
+  }
+
+  // 데이터셋의 업데이트한 사용자를 조회
+  @FieldResolver(type => User)
+  async updater(@Root() dataSet: DataSet): Promise<User> {
+    return dataSet.updaterId && (await getRepository(User).findOneBy({ id: dataSet.updaterId }))
+  }
+
+  // 데이터셋의 생성자를 조회
+  @FieldResolver(type => User)
+  async creator(@Root() dataSet: DataSet): Promise<User> {
+    return dataSet.creatorId && (await getRepository(User).findOneBy({ id: dataSet.creatorId }))
+  }
+
+  @FieldResolver(type => Date, { nullable: true, description: 'Retrieves the latest collection time for the dataset.' })
+  async latestCollectedAt(@Root() dataSet: DataSet): Promise<Date> {
+    const sample = await getRepository(DataSample).findOne({
+      select: ['id', 'collectedAt'],
+      where: { dataSet: { id: dataSet.id } },
+      order: { collectedAt: 'DESC' }
+    })
+
+    return sample?.collectedAt
+  }
+
+  @FieldResolver(type => Date, { nullable: true, description: 'Retrieves the next schedule time for the dataset.' })
+  async nextSchedule(@Root() dataSet: DataSet): Promise<Date> {
+    const { domainId, schedule, timezone } = dataSet
+
+    if (!schedule) {
+      return
+    }
+
+    var interval = parser.parseExpression(schedule, {
+      tz: timezone || ((await getRepository(Domain).findOneBy({ id: domainId })) as Domain).timezone || 'UTC'
+    })
+
+    return interval.next().toDate()
+  }
+
+  @FieldResolver(type => Date, { nullable: true, description: 'Retrieves the previous schedule time for the dataset.' })
+  async prevSchedule(@Root() dataSet: DataSet): Promise<Date> {
+    const { domainId, schedule, timezone } = dataSet
+
+    if (!schedule) {
+      return
+    }
+
+    var interval = parser.parseExpression(schedule, {
+      tz: timezone || ((await getRepository(Domain).findOneBy({ id: domainId })) as Domain).timezone || 'UTC'
+    })
+
+    return interval.prev().toDate()
+  }
+
+  @FieldResolver(type => Date, {
+    nullable: true,
+    description: 'Retrieves the next summary schedule time for the dataset.'
+  })
+  async nextSummarySchedule(@Root() dataSet: DataSet): Promise<Date> {
+    const { domainId, summarySchedule, timezone } = dataSet
+
+    if (!summarySchedule) {
+      return
+    }
+
+    var interval = parser.parseExpression(summarySchedule, {
+      tz: timezone || ((await getRepository(Domain).findOneBy({ id: domainId })) as Domain).timezone || 'UTC'
+    })
+
+    return interval.next().toDate()
+
+    // FIXME: getSchedules 의 파라미터를 수정해야한다. scheduler 가 없거나 커넥션이 끊겨있어서 오래걸리는 문제는 어떻게 ?? 비동기로 처리한다. 어떻게???
+    // client: {
+    //   application: Application,
+    //   group: `${domain.id}`,
+    //   type: 'data-set',
+    //   key: dataSet.id,
+    //   operation: 'summary'
+    // }
+    // const schedule = getSchedules('name', 'group', false)
+    // return schedule.nextSchedule
+  }
+
+  @FieldResolver(type => String, { description: 'Retrieves the report template for the dataset.' })
+  async reportTemplate(@Root() dataset: DataSet): Promise<string | undefined> {
+    const attachment: Attachment = await getRepository(Attachment).findOne({
+      where: {
+        domain: { id: dataset.domainId },
+        refType: `${DataSet.name}-report-template`,
+        refBy: dataset.id
+      }
+    })
+
+    return attachment?.path
+  }
+
+  @FieldResolver(returns => Boolean, { description: 'Whether the user is a supervisor for this dataset' })
+  async isSupervisor(@Root() dataset: DataSet, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { user, domain } = context.state
+
+    const foundUser = await getRepository(User).findOne({
+      where: { id: user.id },
+      relations: ['roles']
+    })
+
+    const roles = foundUser.roles
+      .filter(role => role.domainId === domain.id || (domain.parentId && role.domainId === domain.parentId))
+      .map(role => role.id)
+
+    return roles.includes(dataset.supervisoryRoleId)
+  }
+
+  @FieldResolver(returns => Boolean, { description: 'Whether the user is allowed to enter data for this dataset' })
+  async isEntryAllowed(@Root() dataset: DataSet, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { user, domain } = context.state
+
+    const foundUser = await getRepository(User).findOne({
+      where: { id: user.id },
+      relations: ['roles']
+    })
+
+    const roles = foundUser.roles
+      .filter(role => role.domainId === domain.id || (domain.parentId && role.domainId === domain.parentId))
+      .map(role => role.id)
+
+    return roles.includes(dataset.entryRoleId)
+  }
+}

package/server/service/data-set/data-set-type.ts

@@ -0,0 +1,204 @@
+import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
+import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ApprovalLineItem } from '@things-factory/organization'
+import { ObjectRef, ScalarObject } from '@things-factory/shell'
+
+import { DataItemPatch } from './data-item-type'
+import { DataSet, DataSetEntryType, DataSetMonitorType, DataSetReportType, DataSetSummaryPeriodType } from './data-set'
+
+@InputType()
+export class NewDataSet {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true, description: 'A tag name of data to be published when a data sample created' })
+  tag?: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  dataKeySet?: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  entryRole?: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  supervisoryRole?: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  resolverRole?: ObjectRef
+
+  @Field(type => ScalarObject, { nullable: true })
+  reviewApprovalLine?: ApprovalLineItem[]
+
+  @Field(type => ScalarObject, { nullable: true })
+  outlierApprovalLine?: ApprovalLineItem[]
+
+  @Field(type => ObjectRef, { nullable: true })
+  normalScenario?: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  outlierScenario?: ObjectRef
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field({ nullable: true })
+  type?: 'manual' | 'automatic' | string
+
+  @Field({ nullable: true })
+  useCase?: string
+
+  @Field(type => ScalarObject, { nullable: true })
+  partitionKeys?: { [key: string]: any }
+
+  @Field(type => [DataItemPatch], { nullable: true })
+  dataItems?: DataItemPatch[]
+
+  @Field({ nullable: true })
+  schedule?: string
+
+  @Field({ nullable: true })
+  timezone?: string
+
+  @Field({ nullable: true })
+  requiresReview?: boolean
+
+  @Field({ nullable: true })
+  entryType?: DataSetEntryType
+
+  @Field({ nullable: true })
+  entryView?: string
+
+  @Field({ nullable: true })
+  monitorType?: DataSetMonitorType
+
+  @Field({ nullable: true })
+  monitorView?: string
+
+  @Field({ nullable: true })
+  reportType?: DataSetReportType
+
+  @Field({ nullable: true })
+  reportView?: string
+
+  @Field(type => GraphQLUpload, { nullable: true })
+  reportTemplate?: FileUpload
+
+  @Field({ nullable: true })
+  summaryPeriod?: DataSetSummaryPeriodType
+
+  @Field({
+    nullable: true,
+    description: 'The maximum allowed time limit (in seconds) for completing the data entry operation'
+  })
+  timeLimit?: number
+}
+
+@InputType()
+export class DataSetPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true, description: 'A tag name of data to be published when a data sample created' })
+  tag?: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  dataKeySet?: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  supervisoryRole?: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  entryRole?: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  resolverRole?: ObjectRef
+
+  @Field(type => ScalarObject, { nullable: true })
+  reviewApprovalLine?: ApprovalLineItem[]
+
+  @Field(type => ScalarObject, { nullable: true })
+  outlierApprovalLine?: ApprovalLineItem[]
+
+  @Field(type => ObjectRef, { nullable: true })
+  normalScenario?: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  outlierScenario?: ObjectRef
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field({ nullable: true })
+  type?: 'manual' | 'automatic' | string
+
+  @Field({ nullable: true })
+  useCase?: string
+
+  @Field(type => ScalarObject, { nullable: true })
+  partitionKeys?: { [key: string]: any }
+
+  @Field(type => [DataItemPatch], { nullable: true })
+  dataItems?: DataItemPatch[]
+
+  @Field({ nullable: true })
+  schedule?: string
+
+  @Field({ nullable: true })
+  timezone?: string
+
+  @Field({ nullable: true })
+  requiresReview?: boolean
+
+  @Field({ nullable: true })
+  entryType?: DataSetEntryType
+
+  @Field({ nullable: true })
+  entryView?: string
+
+  @Field({ nullable: true })
+  monitorType?: DataSetMonitorType
+
+  @Field({ nullable: true })
+  monitorView?: string
+
+  @Field({ nullable: true })
+  reportType?: DataSetReportType
+
+  @Field({ nullable: true })
+  reportView?: string
+
+  @Field(type => GraphQLUpload, { nullable: true })
+  reportTemplate?: FileUpload
+
+  @Field({ nullable: true })
+  summaryPeriod?: DataSetSummaryPeriodType
+
+  @Field({
+    nullable: true,
+    description: 'The maximum allowed time limit (in seconds) for completing the data entry operation'
+  })
+  timeLimit?: number
+
+  @Field()
+  cuFlag: string
+}
+
+@ObjectType()
+export class DataSetList {
+  @Field(type => [DataSet])
+  items: DataSet[]
+
+  @Field(type => Int)
+  total: number
+}