@things-factory/dataset 8.0.40 → 9.0.0-9.0.0-beta.59.0

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

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

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