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

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

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

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