@things-factory/dataset 5.0.0-alpha.3 → 5.0.0-alpha.32

package/server/service/data-ooc/data-ooc.ts

@@ -0,0 +1,204 @@
+import { Field, ID, ObjectType, registerEnumType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  JoinColumn,
+  ManyToOne,
+  OneToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { config } from '@things-factory/env'
+import { Domain, ScalarObject } from '@things-factory/shell'
+
+import { DataSample } from '../data-sample/data-sample'
+import { DataSet } from '../data-set/data-set'
+
+const ORMCONFIG = config.get('ormconfig', {})
+const DATABASE_TYPE = ORMCONFIG.type
+
+export enum DataOocStatus {
+  CREATED = 'CREATED',
+  REVIEWED = 'REVIEWED',
+  CORRECTED = 'CORRECTED'
+}
+
+registerEnumType(DataOocStatus, {
+  name: 'DataOocStatus',
+  description: 'Out of control data corrective action process progress status'
+})
+
+@Entity()
+@Index('ix_data_ooc_0', (dataOoc: DataOoc) => [dataOoc.domain, dataOoc.dataSet], { unique: false })
+@Index('ix_data_ooc_1', (dataOoc: DataOoc) => [dataOoc.domain, dataOoc.dataSample], { unique: true })
+@Index('ix_data_ooc_2', (dataOoc: DataOoc) => [dataOoc.domain, dataOoc.collectedAt], { unique: false })
+@ObjectType({ description: 'Entity for Out of control data' })
+export class DataOoc {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((dataOoc: DataOoc) => dataOoc.domain)
+  domainId?: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  description?: string
+
+  @ManyToOne(type => DataSet)
+  @Field(type => DataSet, { nullable: true })
+  dataSet?: DataSet
+
+  @RelationId((dataOoc: DataOoc) => dataOoc.dataSet)
+  dataSetId?: string
+
+  @OneToOne(type => DataSample)
+  @JoinColumn()
+  @Field(type => DataSample, { nullable: true })
+  dataSample?: DataSample
+
+  @RelationId((dataOoc: DataOoc) => dataOoc.dataSample)
+  dataSampleId?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  ooc?: boolean
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  oos?: boolean
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  state?: DataOocStatus
+
+  @Column({
+    nullable: true,
+    type:
+      DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
+        ? 'longtext'
+        : DATABASE_TYPE == 'oracle'
+        ? 'clob'
+        : 'varchar'
+  })
+  @Field({ nullable: true })
+  correctiveAction?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  type?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  useCase?: string
+
+  @Column('simple-json', { nullable: true })
+  @Field(type => ScalarObject, { nullable: true })
+  partitionKeys?: ScalarObject
+
+  @Column('simple-json', { nullable: true })
+  @Field(type => ScalarObject, { nullable: true })
+  data?: ScalarObject
+
+  @Column('simple-json', { nullable: true })
+  @Field(type => ScalarObject, { nullable: true })
+  spec?: ScalarObject
+
+  @Column('simple-json', { nullable: true })
+  @Field(type => ScalarObject, { nullable: true })
+  history?: ScalarObject
+
+  @Column({
+    nullable: true,
+    type:
+      DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
+        ? 'longtext'
+        : DATABASE_TYPE == 'oracle'
+        ? 'clob'
+        : 'varchar'
+  })
+  @Field({ nullable: true })
+  rawData?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  source?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  workDate?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  workShift?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  collectedAt?: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  correctedAt?: Date
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  corrector?: User
+
+  @RelationId((dataOoc: DataOoc) => dataOoc.corrector)
+  correctorId?: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((dataOoc: DataOoc) => dataOoc.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((dataOoc: DataOoc) => dataOoc.creator)
+  updaterId?: string
+}

package/server/service/data-ooc/index.ts

@@ -0,0 +1,7 @@
+import { DataOoc } from './data-ooc'
+import { DataOocMutation } from './data-ooc-mutation'
+import { DataOocQuery } from './data-ooc-query'
+import { DataOocSubscription } from './data-ooc-subscription'
+
+export const entities = [DataOoc]
+export const resolvers = [DataOocQuery, DataOocMutation, DataOocSubscription]

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

@@ -1,10 +1,11 @@
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
 
-import { DataItem } from '../data-item/data-item'
-import { DataSet } from '../data-set/data-set'
 import { DataSample } from './data-sample'
-import { DataSamplePatch, NewDataSample } from './data-sample-type'
+import { NewDataSample } from './data-sample-type'
+
+import { createDataSample } from '../../controllers/create-data-sample'
+
+const debug = require('debug')('things-factory:dataset:data-sample:data-sample-mutation')
 
 @Resolver(DataSample)
 export class DataSampleMutation {
@@ -12,129 +13,6 @@ export class DataSampleMutation {
   @Directive('@transaction')
   @Mutation(returns => DataSample, { description: 'To create new data sample' })
   async createDataSample(@Arg('dataSample') dataSample: NewDataSample, @Ctx() context: any): Promise<DataSample> {
-    const { domain, user, tx } = context.state
-
-    const dataSet = await tx.getRepository(DataSet).findOne({ id: dataSample.dataSetId })
-    const dataItems = await tx.getRepository(DataItem).find({
-      where: {
-        domain,
-        dataSet
-      },
-      order: {
-        sequence: 'DESC'
-      }
-    })
-
-    var spec = {} as any
-
-    dataItems.forEach(dataItem => {
-      spec[dataItem.name] = dataItem.spec
-      // TODO 변수형 스펙값은 처리 결과값을 spec의 아이템 value로 반영하여야 한다.
-    })
-
-    return await tx.getRepository(DataSample).save({
-      name: dataSet.name,
-      description: dataSet.description,
-      collectedAt: new Date(),
-      ...dataSample,
-      domain,
-      partitionKeys: dataSet.partitionKeys,
-      spec,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@privilege(category: "data-sample", privilege: "mutation", domainOwnerGranted: true)')
-  @Directive('@transaction')
-  @Mutation(returns => DataSample, { description: 'To modify data sample information' })
-  async updateDataSample(
-    @Arg('id') id: string,
-    @Arg('patch') patch: DataSamplePatch,
-    @Ctx() context: any
-  ): Promise<DataSample> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(DataSample)
-    const dataSample = await repository.findOne({
-      where: { domain, id }
-    })
-
-    return await repository.save({
-      ...dataSample,
-      ...patch,
-      updater: user
-    })
-  }
-
-  @Directive('@privilege(category: "data-sample", privilege: "mutation", domainOwnerGranted: true)')
-  @Directive('@transaction')
-  @Mutation(returns => [DataSample], { description: "To modify multiple data samples' information" })
-  async updateMultipleDataSample(
-    @Arg('patches', type => [DataSamplePatch]) patches: DataSamplePatch[],
-    @Ctx() context: any
-  ): Promise<DataSample[]> {
-    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 dataSampleRepo = tx.getRepository(DataSample)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await dataSampleRepo.save({
-          ...newRecord,
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const newRecord = _updateRecords[i]
-        const dataSample = await dataSampleRepo.findOne(newRecord.id)
-
-        const result = await dataSampleRepo.save({
-          ...dataSample,
-          ...newRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@privilege(category: "data-sample", privilege: "mutation", domainOwnerGranted: true)')
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete a data sample' })
-  async deleteDataSample(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(DataSample).delete({ domain, id })
-    return true
-  }
-
-  @Directive('@privilege(category: "data-sample", privilege: "mutation", domainOwnerGranted: true)')
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple data samples' })
-  async deleteDataSamples(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(DataSample).delete({
-      domain,
-      id: In(ids)
-    })
-
-    return true
+    return await createDataSample(dataSample, context)
   }
 }

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

@@ -1,6 +1,6 @@
-import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
 
-import { ScalarObject } from '@things-factory/shell'
+import { ObjectRef, ScalarObject } from '@things-factory/shell'
 
 import { DataSample } from './data-sample'
 
@@ -12,8 +12,8 @@ export class NewDataSample {
   @Field({ nullable: true })
   description?: string
 
-  @Field({ nullable: true })
-  dataSetId?: string
+  @Field(type => ObjectRef, { nullable: true })
+  dataSet?: ObjectRef
 
   @Field(type => ScalarObject, { nullable: true })
   data?: ScalarObject
@@ -25,34 +25,13 @@ export class NewDataSample {
   source?: string
 
   @Field({ nullable: true })
-  collectedAt?: Date
-}
-
-@InputType()
-export class DataSamplePatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  dataSetId?: string
-
-  @Field(type => ScalarObject, { nullable: true })
-  data?: ScalarObject
+  workDate?: string
 
   @Field({ nullable: true })
-  rawData?: string
+  workShift?: string
 
   @Field({ nullable: true })
-  source?: string
-
-  @Field()
-  cuFlag: string
+  collectedAt?: Date
 }
 
 @ObjectType()

package/server/service/data-sample/data-sample.ts

@@ -20,6 +20,11 @@ const ORMCONFIG = config.get('ormconfig', {})
 const DATABASE_TYPE = ORMCONFIG.type
 @Entity()
 @Index('ix_data_sample_0', (dataSample: DataSample) => [dataSample.domain, dataSample.dataSet], { unique: false })
+@Index(
+  'ix_data_sample_2',
+  (dataSample: DataSample) => [dataSample.domain, dataSample.dataSet, dataSample.collectedAt],
+  { unique: false }
+)
 @ObjectType({ description: 'Entity for DataSample' })
 export class DataSample {
   @PrimaryGeneratedColumn('uuid')
@@ -49,16 +54,21 @@ export class DataSample {
   @Field({ nullable: true })
   type?: string
 
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  useCase?: string
+
   @Column('simple-json', { nullable: true })
   @Field(type => ScalarObject, { nullable: true })
   partitionKeys?: ScalarObject
 
-  @ManyToOne(type => DataSet, dataSet => dataSet.dataSamples)
-  @Field(type => DataSet, { nullable: true })
+  @ManyToOne(type => DataSet)
+  @Field(type => DataSet, { nullable: false })
   dataSet?: DataSet
 
   @RelationId((dataSample: DataSample) => dataSample.dataSet)
-  @Field({ nullable: true })
   dataSetId?: string
 
   @Column('simple-json', { nullable: true })
@@ -87,6 +97,26 @@ export class DataSample {
   @Field({ nullable: true })
   source?: string
 
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  ooc?: boolean
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  oos?: boolean
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  workDate?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  workShift?: string
+
   @Column({ nullable: true })
   @Field({ nullable: true })
   collectedAt?: Date

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

@@ -200,10 +200,7 @@ export class DataSetMutation {
 
     return copiedDataSets.map(dataSet => {
       dataSet.dataItems = copiedDataItems.filter(dataItem => dataItem.dataSet == dataSet.id)
-      return {
-        ...dataSet,
-        state: 'UNLOADED' // DataSetInstanceStatus.UNLOADED
-      }
+      return dataSet
     })
   }
 }

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

@@ -1,13 +1,17 @@
 import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
+import { Equal, getRepository } from 'typeorm'
 
-import { User } from '@things-factory/auth-base'
+import { Role, User } from '@things-factory/auth-base'
+import { Board } from '@things-factory/board-service'
 import { convertListParams, Domain, ListParam } from '@things-factory/shell'
 
 import { DataItem } from '../data-item/data-item'
+import { DataSample } from '../data-sample/data-sample'
 import { DataSet } from './data-set'
 import { DataSetList } from './data-set-type'
 
+var parser = require('cron-parser')
+
 @Resolver(DataSet)
 export class DataSetQuery {
   @Directive('@privilege(category: "data-set", privilege: "query", domainOwnerGranted: true)')
@@ -31,6 +35,25 @@ export class DataSetQuery {
     return { items, total }
   }
 
+  @Query(returns => DataSetList, { description: 'To fetch multiple DataSets for data entry manually' })
+  async dataSetsForEntry(@Args() params: ListParam, @Ctx() context: any): Promise<DataSetList> {
+    const { domain } = context.state
+
+    /* TODO. 조회한 사용자가 supervisory 역할을 가진 data-set 리스트만 반환 */
+
+    const { where = {}, order, skip, take } = convertListParams(params, domain.id)
+    where.active = Equal(true)
+
+    const [items, total] = await getRepository(DataSet).findAndCount({
+      where,
+      order,
+      skip,
+      take
+    })
+
+    return { items, total }
+  }
+
   @FieldResolver(type => [DataItem])
   async dataItems(@Root() dataSet: DataSet): Promise<DataItem[]> {
     return await getRepository(DataItem).find({
@@ -38,6 +61,27 @@ export class DataSetQuery {
     })
   }
 
+  @FieldResolver(type => Role)
+  async supervisoryRole(@Root() dataSet: DataSet): Promise<Role> {
+    return await getRepository(Role).findOne({
+      id: dataSet.supervisoryRoleId
+    })
+  }
+
+  @FieldResolver(type => Board, { nullable: true })
+  async entryBoard(@Root() dataSet: DataSet) {
+    if (dataSet.entryType == 'board' && dataSet.entryView) {
+      return await getRepository(Board).findOne({ id: dataSet.entryView })
+    }
+  }
+
+  @FieldResolver(type => Board, { nullable: true })
+  async monitorBoard(@Root() dataSet: DataSet) {
+    if (dataSet.monitorType == 'board' && dataSet.monitorView) {
+      return await getRepository(Board).findOne({ id: dataSet.monitorView })
+    }
+  }
+
   @FieldResolver(type => Domain)
   async domain(@Root() dataSet: DataSet): Promise<Domain> {
     return await getRepository(Domain).findOne(dataSet.domainId)
@@ -52,4 +96,45 @@ export class DataSetQuery {
   async creator(@Root() dataSet: DataSet): Promise<User> {
     return await getRepository(User).findOne(dataSet.creatorId)
   }
+
+  @FieldResolver(type => Date, { nullable: true })
+  async latestCollectedAt(@Root() dataSet: DataSet): Promise<Date> {
+    const sample = await getRepository(DataSample).findOne({
+      select: ['collectedAt'],
+      where: { dataSet },
+      order: { collectedAt: 'DESC' }
+    })
+
+    return sample?.collectedAt
+  }
+
+  @FieldResolver(type => Date, { nullable: true })
+  async nextSchedule(@Root() dataSet: DataSet): Promise<Date> {
+    const { timezone, schedule } = dataSet
+
+    if (!schedule) {
+      return
+    }
+
+    var interval = parser.parseExpression(schedule, {
+      tz: timezone
+    })
+
+    return interval.next().toDate()
+  }
+
+  @FieldResolver(type => Date, { nullable: true })
+  async prevSchedule(@Root() dataSet: DataSet): Promise<Date> {
+    const { timezone, schedule } = dataSet
+
+    if (!schedule) {
+      return
+    }
+
+    var interval = parser.parseExpression(schedule, {
+      tz: timezone
+    })
+
+    return interval.prev().toDate()
+  }
 }

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

@@ -1,8 +1,8 @@
 import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
 
-import { ScalarObject } from '@things-factory/shell'
+import { ObjectRef, ScalarObject } from '@things-factory/shell'
 
-import { DataSet } from './data-set'
+import { DataSet, DataSetViewType } from './data-set'
 
 @InputType()
 export class NewDataSet {
@@ -12,11 +12,17 @@ export class NewDataSet {
   @Field({ nullable: true })
   description?: string
 
+  @Field(type => ObjectRef, { nullable: true })
+  supervisoryRole?: ObjectRef
+
   @Field({ nullable: true })
   active?: boolean
 
   @Field({ nullable: true })
-  type?: string
+  type?: 'manual' | 'automatic' | string
+
+  @Field({ nullable: true })
+  useCase?: string
 
   @Field(type => ScalarObject, { nullable: true })
   partitionKeys?: ScalarObject
@@ -26,6 +32,18 @@ export class NewDataSet {
 
   @Field({ nullable: true })
   timezone?: string
+
+  @Field({ nullable: true })
+  entryType?: DataSetViewType
+
+  @Field({ nullable: true })
+  entryView?: string
+
+  @Field({ nullable: true })
+  monitorType?: DataSetViewType
+
+  @Field({ nullable: true })
+  monitorView?: string
 }
 
 @InputType()
@@ -39,11 +57,14 @@ export class DataSetPatch {
   @Field({ nullable: true })
   description?: string
 
+  @Field(type => ObjectRef, { nullable: true })
+  supervisoryRole?: ObjectRef
+
   @Field({ nullable: true })
   active?: boolean
 
   @Field({ nullable: true })
-  type?: string
+  useCase?: string
 
   @Field(type => ScalarObject, { nullable: true })
   partitionKeys?: ScalarObject
@@ -54,6 +75,18 @@ export class DataSetPatch {
   @Field({ nullable: true })
   timezone?: string
 
+  @Field({ nullable: true })
+  entryType?: DataSetViewType
+
+  @Field({ nullable: true })
+  entryView?: string
+
+  @Field({ nullable: true })
+  monitorType?: DataSetViewType
+
+  @Field({ nullable: true })
+  monitorView?: string
+
   @Field()
   cuFlag: string
 }