@things-factory/dataset 8.0.0 → 9.0.0-beta.3

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

@@ -1,155 +0,0 @@
-import { Field, InputType, Int, ObjectType, registerEnumType } from 'type-graphql'
-
-import { ScalarObject } from '@things-factory/shell'
-
-export enum DataItemType {
-  number = 'number',
-  text = 'text',
-  boolean = 'boolean',
-  select = 'select',
-  radio = 'radio',
-  date = 'date',
-  datetime = 'datetime',
-  file = 'file',
-  signature = 'signature'
-}
-
-registerEnumType(DataItemType, {
-  name: 'DataItemType',
-  description: 'type enumeration of a data-item'
-})
-
-export enum DataItemStatType {
-  sum = 'sum',
-  mean = 'mean',
-  stddev = 'stddev',
-  variance = 'variance',
-  min = 'min',
-  max = 'max',
-  range = 'range',
-  median = 'median',
-  mode = 'mode'
-}
-
-registerEnumType(DataItemStatType, {
-  name: 'DataItemStatType',
-  description: 'stat/agg type enumeration of a data-item'
-})
-
-@ObjectType({ description: 'Entity for DataItem' })
-export class DataItem {
-  @Field({ description: 'The name of the data item' })
-  name: string
-
-  @Field({ nullable: true, description: 'A description of the data item' })
-  description?: string
-
-  @Field({
-    nullable: true,
-    description:
-      'Specifies a key name to be used as a property in a JSON-like object, representing a subfield of a dataset record.'
-  })
-  tag?: string
-
-  @Field({
-    nullable: true,
-    description:
-      'Specifies a grouping identifier for data items with related content, allowing them to be displayed as subgroups within the overall dataset.'
-  })
-  group?: string
-
-  @Field({ nullable: true, description: 'Indicates if the data item is active' })
-  active?: boolean
-
-  @Field({ nullable: true, description: 'Indicates if the data item is hidden' })
-  hidden?: boolean
-
-  @Field({ nullable: true, description: 'The type of the data item' })
-  type?: DataItemType
-
-  @Field(type => ScalarObject, { nullable: true, description: 'Options associated with the data item type' })
-  options?: { [option: string]: any }
-
-  @Field({
-    nullable: true,
-    description: 'The grouping logic for data finalize in the given field during periodic task deadlines.'
-  })
-  stat?: DataItemStatType
-
-  @Field({
-    nullable: true,
-    description: 'Aggregation functions to be used in data summarizing logic for a given period.'
-  })
-  agg?: DataItemStatType
-
-  @Field({ nullable: true, description: 'The unit of measurement for the data item' })
-  unit?: string
-
-  @Field(type => Int, { nullable: true, description: 'The maximum number of data values allowed for this field' })
-  quota?: number
-
-  @Field(type => ScalarObject, {
-    nullable: true,
-    description: 'Specifies the valid ranges and parameters for this data item.'
-  })
-  spec?: { [key: string]: any }
-}
-
-@InputType()
-export class DataItemPatch {
-  @Field({ nullable: true, description: 'The name of the data item' })
-  name?: string
-
-  @Field({ nullable: true, description: 'A description of the data item' })
-  description?: string
-
-  @Field({
-    nullable: true,
-    description:
-      'Specifies a key name to be used as a property in a JSON-like object, representing a subfield of a dataset record.'
-  })
-  tag?: string
-
-  @Field({
-    nullable: true,
-    description:
-      'Specifies a grouping identifier for data items with related content, allowing them to be displayed as subgroups within the overall dataset.'
-  })
-  group?: string
-
-  @Field(type => DataItemType, { nullable: true, description: 'The type of the data item' })
-  type?: DataItemType
-
-  @Field(type => ScalarObject, { nullable: true, description: 'Options associated with the data item type' })
-  options?: { [option: string]: any }
-
-  @Field({
-    nullable: true,
-    description: 'The grouping logic for data summarization in the given field during periodic task deadlines.'
-  })
-  stat?: DataItemStatType
-
-  @Field({
-    nullable: true,
-    description: 'Aggregation functions to be used in data summarizing logic for a given period.'
-  })
-  agg?: DataItemStatType
-
-  @Field({ nullable: true, description: 'The unit of measurement for the data item' })
-  unit?: string
-
-  @Field(type => Int, { nullable: true, description: 'The maximum number of data values allowed for this field' })
-  quota?: number
-
-  @Field({ nullable: true, description: 'Indicates if the data item is active' })
-  active?: boolean
-
-  @Field({ nullable: true, description: 'Indicates if the data item is hidden' })
-  hidden?: boolean
-
-  @Field(type => ScalarObject, {
-    nullable: true,
-    description: 'Specifies the valid ranges and parameters for this data item.'
-  })
-  spec?: { [key: string]: any }
-}

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

@@ -1,552 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { getRepository } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { createAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
-import { ApprovalLineItem, OrgMemberTargetType } from '@things-factory/organization'
-import { Application, CallbackBase, registerSchedule, unregisterSchedule } from '@things-factory/scheduler-client'
-
-import { getDataFinalizeCrontabSchedule } from '../../controllers/finalize-data-collection'
-import { DataSet } from './data-set'
-import { DataSetPatch, NewDataSet } from './data-set-type'
-import { issueDataCollectionTask } from '../../controllers/issue-data-collection-task'
-
-const crypto = require('crypto')
-
-function getApprovalLineValue(patch: NewDataSet | DataSetPatch): ApprovalLineItem[] {
-  const { reviewApprovalLine } = patch
-
-  if (!('reviewApprovalLine' in patch)) {
-    /* reviewApprovalLine 언급되지 않았다면, 업데이트하지 않는다. */
-    return
-  }
-
-  if (!reviewApprovalLine || !(reviewApprovalLine instanceof Array)) {
-    /* approvalLine의 값이 없거나 배열이 아니라면, 클리어시킨다. */
-    return null
-  }
-
-  return reviewApprovalLine
-    .map(m => {
-      return {
-        type: m.type,
-        approver: m.approver
-      } as ApprovalLineItem
-    })
-    .filter(m => m.type)
-    .filter(m => {
-      switch (m.type) {
-        case OrgMemberTargetType.Employee:
-        case OrgMemberTargetType.Department:
-        case OrgMemberTargetType.Role:
-          return !!m.approver?.id
-        default:
-          return true
-      }
-    })
-}
-
-function getOutlierApprovalLineValue(patch: NewDataSet | DataSetPatch): ApprovalLineItem[] {
-  const { outlierApprovalLine } = patch
-
-  if (!('outlierApprovalLine' in patch)) {
-    /* approvalLine이 언급되지 않았다면, 업데이트하지 않는다. */
-    return
-  }
-
-  if (!outlierApprovalLine || !(outlierApprovalLine instanceof Array)) {
-    /* approvalLine의 값이 없거나 배열이 아니라면, 클리어시킨다. */
-    return null
-  }
-
-  return outlierApprovalLine
-    .map(m => {
-      return {
-        type: m.type,
-        approver: m.approver
-      } as ApprovalLineItem
-    })
-    .filter(m => m.type)
-    .filter(m => {
-      switch (m.type) {
-        case OrgMemberTargetType.Employee:
-        case OrgMemberTargetType.Department:
-        case OrgMemberTargetType.Role:
-          return !!m.approver?.id
-        default:
-          return true
-      }
-    })
-}
-
-@Resolver(DataSet)
-export class DataSetMutation {
-  @Directive('@privilege(category: "data-set", privilege: "mutation", domainOwnerGranted: true)')
-  @Directive('@transaction')
-  @Mutation(returns => DataSet, { description: 'To create new DataSet' })
-  async createDataSet(@Arg('dataSet') dataSet: NewDataSet, @Ctx() context: ResolverContext): Promise<DataSet> {
-    const { domain, user, tx } = context.state
-    const dataSetRepo = getRepository(DataSet, tx)
-
-    const result = await dataSetRepo.save({
-      ...dataSet,
-      approvalLine: getApprovalLineValue(dataSet),
-      outlierApprovalLineValue: getOutlierApprovalLineValue(dataSet),
-      version: 1,
-      domain,
-      creator: user,
-      updater: user
-    })
-
-    await this._createAttachment(context, dataSet.reportTemplate, { ref: result, cuFlag: '+' })
-
-    return result
-  }
-
-  @Directive('@privilege(category: "data-set", privilege: "mutation", domainOwnerGranted: true)')
-  @Directive('@transaction')
-  @Mutation(returns => DataSet, { description: 'To modify DataSet information' })
-  async updateDataSet(
-    @Arg('id') id: string,
-    @Arg('patch') patch: DataSetPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<DataSet> {
-    const { domain, user, tx } = context.state
-    const dataSetRepo = getRepository(DataSet, tx)
-
-    const dataSet = await dataSetRepo.findOne({
-      where: { domain: { id: domain.id }, id },
-      relations: ['domain', 'dataKeySet', 'entryRole', 'supervisoryRole', 'creator', 'updater']
-      /* history에 항상 반영될 수 있도록 relations가 있어야 함. */
-    })
-
-    const result = await dataSetRepo.save({
-      ...dataSet,
-      ...patch,
-      approvalLine: getApprovalLineValue(patch),
-      outlierApprovalLineValue: getOutlierApprovalLineValue(patch),
-      updater: user
-    })
-
-    await this._createAttachment(context, dataSet.reportTemplate, { ref: result, cuFlag: 'M' })
-
-    return result
-  }
-
-  @Directive('@privilege(category: "data-set", privilege: "mutation", domainOwnerGranted: true)')
-  @Directive('@transaction')
-  @Mutation(returns => [DataSet], { description: "To modify multiple DataSets' information" })
-  async updateMultipleDataSet(
-    @Arg('patches', type => [DataSetPatch]) patches: DataSetPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<DataSet[]> {
-    const { domain, user, tx } = context.state
-    const dataSetRepo = getRepository(DataSet, tx)
-
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-
-    if (_createRecords.length > 0) {
-      const cuFlag = '+'
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await dataSetRepo.save({
-          ...newRecord,
-          approvalLine: getApprovalLineValue(newRecord),
-          outlierApprovalLineValue: getOutlierApprovalLineValue(newRecord),
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        await this._createAttachment(context, newRecord.reportTemplate, { ref: result, cuFlag })
-
-        results.push({
-          ...result,
-          cuFlag
-        })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      const cuFlag = 'M'
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const updateRecord = _updateRecords[i]
-        const dataSet = await dataSetRepo.findOne({
-          where: { id: updateRecord.id },
-          /* history에 항상 반영될 수 있도록 relations가 있어야 함. */
-          relations: ['domain', 'dataKeySet', 'entryRole', 'supervisoryRole', 'creator', 'updater']
-        })
-
-        const result = await dataSetRepo.save({
-          ...dataSet,
-          ...updateRecord,
-          approvalLine: getApprovalLineValue(updateRecord),
-          outlierApprovalLineValue: getOutlierApprovalLineValue(updateRecord),
-          updater: user
-        })
-
-        await this._createAttachment(context, updateRecord.reportTemplate, { ref: result, cuFlag })
-
-        results.push({
-          ...result,
-          cuFlag
-        })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@privilege(category: "data-set", privilege: "mutation", domainOwnerGranted: true)')
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete DataSet' })
-  async deleteDataSet(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await getRepository(DataSet, tx).delete({ domain: { id: domain.id }, id })
-    await deleteAttachmentsByRef(null, { refBys: [`report-${id}`] }, context)
-
-    return true
-  }
-
-  @Directive('@privilege(category: "data-set", privilege: "mutation", domainOwnerGranted: true)')
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple dataSets' })
-  async deleteDataSets(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await getRepository(DataSet, tx).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    await deleteAttachmentsByRef(null, { refBys: ids.map(id => `report-${id}`) }, context)
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To issue data-collection task for the given dataset' })
-  async issueDataCollection(@Arg('dataSetId') dataSetId: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx, user } = context.state
-
-    const dataSet = await getRepository(DataSet, tx).findOne({
-      where: {
-        domain: {
-          id: In([domain.id, domain.parentId].filter(Boolean))
-        },
-        id: dataSetId
-      }
-    })
-
-    const { supervisoryRoleId, entryRoleId } = dataSet
-    const allowedRoles = [supervisoryRoleId, entryRoleId].filter(Boolean)
-
-    const me = await getRepository(User, tx).findOne({
-      where: { id: user.id },
-      relations: ['roles']
-    })
-
-    if (!me.roles.find(role => allowedRoles.includes(role.id))) {
-      throw new Error(`You don't have permission to issue data collection task for this dataset.`)
-    }
-
-    const activityInstance = await issueDataCollectionTask(domain.id, dataSet.id, context)
-
-    return !!activityInstance
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => DataSet, { description: 'To start data collection schedule for the given dataset' })
-  async startDataCollectionSchedule(
-    @Arg('dataSetId') dataSetId: string,
-    @Ctx() context: ResolverContext
-  ): Promise<DataSet> {
-    const { domain, tx } = context.state
-
-    var repository = getRepository(DataSet, tx)
-    var dataSet = await repository.findOne({
-      where: { domain: { id: domain.id }, id: dataSetId }
-    })
-
-    if (!dataSet) {
-      throw new Error(
-        context.t('error.data-set not found', {
-          dataSet: dataSetId
-        })
-      )
-    }
-
-    try {
-      var handle = await registerSchedule({
-        name: dataSet.name,
-        client: {
-          application: Application,
-          group: `${domain.id}`,
-          type: 'data-set',
-          key: dataSet.id,
-          operation: 'schedule'
-        },
-        type: 'cron',
-        schedule: dataSet.schedule,
-        timezone: dataSet.timezone,
-        task: {
-          type: 'rest',
-          connection: {
-            host: `${CallbackBase}/callback-schedule-for-dataset`,
-            headers: {
-              'Content-Type': 'application/json',
-              accept: '*/*'
-            }
-          },
-          data: {
-            domainId: domain.id,
-            dataSetId
-          },
-          history_check: true,
-          failed_policy: 'retry_dlq',
-          max_retry_count: 3,
-          retry_period: 60
-        }
-      })
-
-      return await repository.save({
-        ...dataSet,
-        scheduleId: handle
-      })
-    } catch (err) {
-      console.error('startDataCollectionSchedule', err)
-    }
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => DataSet, {
-    nullable: true,
-    description: 'To stop data collection schedule for the given dataset'
-  })
-  async stopDataCollectionSchedule(
-    @Arg('dataSetId') dataSetId: string,
-    @Ctx() context: ResolverContext
-  ): Promise<DataSet | undefined> {
-    const { domain, tx } = context.state
-
-    var repository = getRepository(DataSet, tx)
-    var dataSet = await repository.findOne({
-      where: { domain: { id: domain.id }, id: dataSetId }
-    })
-
-    if (!dataSet) {
-      throw new Error(
-        context.t('error.data-set not found', {
-          dataSet: dataSetId
-        })
-      )
-    }
-
-    try {
-      await unregisterSchedule(dataSet.scheduleId)
-
-      return await repository.save({
-        ...dataSet,
-        scheduleId: null
-      })
-    } catch (err) {
-      console.error('stopDataCollectionSchedule', err)
-    }
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => DataSet, { description: 'To start data summary schedule for the given dataset' })
-  async startDataSummarySchedule(
-    @Arg('dataSetId') dataSetId: string,
-    @Ctx() context: ResolverContext
-  ): Promise<DataSet> {
-    const { domain, tx } = context.state
-
-    var repository = getRepository(DataSet, tx)
-    var dataSet = await repository.findOne({
-      where: { domain: { id: domain.id }, id: dataSetId }
-    })
-
-    if (!dataSet) {
-      throw new Error(
-        context.t('error.data-set not found', {
-          dataSet: dataSetId
-        })
-      )
-    }
-
-    if (!dataSet.summaryPeriod) {
-      throw new Error(
-        context.t('error.data-set summary-period not set', {
-          dataSet: dataSetId
-        })
-      )
-    }
-
-    const schedule = await getDataFinalizeCrontabSchedule(dataSet, context)
-
-    try {
-      var handle = await registerSchedule({
-        name: dataSet.name,
-        client: {
-          application: Application,
-          group: `${domain.id}`,
-          type: 'data-set',
-          key: dataSet.id,
-          operation: 'summary'
-        },
-        type: 'cron',
-        schedule,
-        timezone: dataSet.timezone,
-        task: {
-          type: 'rest',
-          connection: {
-            host: `${CallbackBase}/callback-schedule-for-dataset-summary`,
-            headers: {
-              'Content-Type': 'application/json',
-              accept: '*/*'
-            }
-          },
-          data: {
-            domainId: domain.id,
-            dataSetId
-          },
-          history_check: true,
-          failed_policy: 'retry_dlq',
-          max_retry_count: 3,
-          retry_period: 60
-        }
-      })
-
-      return await repository.save({
-        ...dataSet,
-        summarySchedule: schedule,
-        summaryScheduleId: handle
-      })
-    } catch (err) {
-      console.error('startDataSummarySchedule', err)
-    }
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => DataSet, {
-    nullable: true,
-    description: 'To stop data summary schedule for the given dataset'
-  })
-  async stopDataSummarySchedule(
-    @Arg('dataSetId') dataSetId: string,
-    @Ctx() context: ResolverContext
-  ): Promise<DataSet | undefined> {
-    const { domain, tx } = context.state
-
-    var repository = getRepository(DataSet, tx)
-    var dataSet = await repository.findOne({
-      where: { domain: { id: domain.id }, id: dataSetId }
-    })
-
-    if (!dataSet) {
-      throw new Error(
-        context.t('error.data-set not found', {
-          dataSet: dataSetId
-        })
-      )
-    }
-
-    try {
-      await unregisterSchedule(dataSet.summaryScheduleId)
-
-      return await repository.save({
-        ...dataSet,
-        summarySchedule: null,
-        summaryScheduleId: null
-      })
-    } catch (err) {
-      console.error('stopDataSummarySchedule', err)
-    }
-  }
-
-  @Directive('@privilege(category: "data-set", privilege: "mutation", domainOwnerGranted: true)')
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To import multiple data-sets' })
-  async importDataSets(
-    @Arg('dataSets', type => [DataSetPatch]) dataSets: DataSet[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-    const dataSetRepo = getRepository(DataSet, tx)
-
-    await Promise.all(
-      dataSets.map(async (dataSet: DataSet) => {
-        const createdDataSet: DataSet = await dataSetRepo.save({
-          domain,
-          ...dataSet
-        })
-      })
-    )
-
-    return true
-  }
-
-  @Directive('@privilege(category: "data-set", privilege: "mutation", domainOwnerGranted: true)')
-  @Directive('@transaction')
-  @Mutation(returns => [DataSet], { description: 'To copy multiple data-sets' })
-  async copyDataSets(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<DataSet[]> {
-    const { domain, user, tx } = context.state
-    const dataSetRepo = getRepository(DataSet, tx)
-
-    const originals = await dataSetRepo.find({
-      where: {
-        id: In(ids),
-        domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }
-      },
-      relations: ['domain', 'supervisoryRole', 'entryRole', 'dataKeySet']
-    })
-
-    if (originals.length == 0) {
-      return []
-    }
-
-    var newCopys = originals.map(dataSet => {
-      let dataSetId = crypto.randomUUID()
-
-      return {
-        ...dataSet,
-        id: dataSetId,
-        name: dataSet.name + ' (' + dataSetId + ')',
-        active: false,
-        version: 1,
-        domain,
-        creator: user,
-        updater: user,
-        updatedAt: undefined,
-        createdAt: undefined
-      }
-    })
-
-    var copiedDataSets = await dataSetRepo.save(newCopys)
-
-    return copiedDataSets
-  }
-
-  async _createAttachment(context, attachment, { ref, cuFlag }) {
-    if (attachment) {
-      cuFlag == 'M' && (await deleteAttachmentsByRef(null, { refBys: [ref.id] }, context))
-      await createAttachment(
-        null,
-        {
-          attachment: {
-            file: attachment,
-            refType: `${DataSet.name}-report-template`,
-            refBy: ref.id
-          }
-        },
-        context
-      )
-    }
-  }
-}