@things-factory/dataset 5.0.0-y.0 → 5.0.0-zeta.10

package/server/controllers/data-use-case.ts

@@ -1,4 +1,5 @@
-import { DataItem, DataSet } from 'server/service'
+import { DataItem } from '../service/data-set/data-item-type'
+import { DataSet } from '../service/data-set/data-set'
 
 export type DataItemSpec = {
   type: string
@@ -13,7 +14,11 @@ export type DataItemSpecSet = {
   specs: DataItemSpec[]
 }
 
-export type EvaluationResult = { oos: boolean; ooc: boolean }
+export type EvaluationResult = {
+  oos: boolean
+  ooc: boolean
+  judgment?: { [tag: string]: { ooc: boolean; oos: boolean } }
+}
 
 export abstract class DataUseCase {
   static registry: { [name: string]: DataUseCase } = {}
@@ -33,6 +38,7 @@ export abstract class DataUseCase {
   public static evaluate(dataSet: DataSet, dataItems: DataItem[], data: any): EvaluationResult {
     var ooc = false
     var oos = false
+    var judgment: { [tag: string]: { ooc: boolean; oos: boolean } } = {}
 
     if (!dataSet.useCase) {
       return { ooc, oos }
@@ -49,7 +55,7 @@ export abstract class DataUseCase {
       }
 
       let values: any | any[] = data[tag]
-      if (typeof values === 'undefined') {
+      if (values == null) {
         continue // TODO what if in case no value ?
       }
 
@@ -57,6 +63,9 @@ export abstract class DataUseCase {
         values = [values]
       }
 
+      let oocForTag = false
+      let oosForTag = false
+
       for (let j = 0; j < useCases.length; j++) {
         const useCase = useCases[j]
 
@@ -68,17 +77,20 @@ export abstract class DataUseCase {
         const result = useCase.evaluate(specs, values)
 
         if (result) {
+          oocForTag ||= result.ooc
+          oosForTag ||= result.oos
           ooc ||= result.ooc
           oos ||= result.oos
         }
+      }
 
-        // if (ooc && oos) {
-        //   return { ooc, oos }
-        // }
+      judgment[tag] = {
+        ooc: oocForTag,
+        oos: oosForTag
       }
     }
 
-    return { ooc, oos }
+    return { ooc, oos, judgment }
   }
 
   public abstract evaluate(specs: any, values: any[]): EvaluationResult

package/server/controllers/index.ts

@@ -1,2 +1,2 @@
-export * from './data-use-case'
 export * from './create-data-sample'
+export * from './data-use-case'

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

@@ -1,6 +1,3 @@
 import { DataItem } from './data-item'
-import { DataItemQuery } from './data-item-query'
-import { DataItemMutation } from './data-item-mutation'
 
 export const entities = [DataItem]
-export const resolvers = [DataItemQuery, DataItemMutation]

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

@@ -4,7 +4,8 @@ import { getRepository } from 'typeorm'
 import { User } from '@things-factory/auth-base'
 import { Domain, getQueryBuilderFromListParams, ListParam } from '@things-factory/shell'
 
-import { DataSample } from '../data-sample/data-sample'
+import { DataSetHistory } from '../data-set-history/data-set-history'
+import { DataItem } from '../data-set/data-item-type'
 import { DataSet } from '../data-set/data-set'
 import { DataOoc } from './data-ooc'
 import { DataOocList } from './data-ooc-type'
@@ -38,6 +39,17 @@ export class DataOocQuery {
     return { items, total }
   }
 
+  @FieldResolver(type => [DataItem])
+  async dataItems(@Root() dataOoc: DataOoc): Promise<DataItem[]> {
+    const dataSetHistory: DataSetHistory = await getRepository(DataSetHistory).findOne({
+      where: {
+        id: dataOoc.dataSetId,
+        version: dataOoc.dataSetVersion
+      }
+    })
+    return dataSetHistory?.dataItems || []
+  }
+
   @FieldResolver(type => DataSet)
   async dataSet(@Root() dataOoc: DataOoc): Promise<DataSet> {
     return await getRepository(DataSet).findOne({
@@ -45,13 +57,6 @@ export class DataOocQuery {
     })
   }
 
-  @FieldResolver(type => DataSample)
-  async dataSample(@Root() dataOoc: DataOoc): Promise<DataSample> {
-    return await getRepository(DataSample).findOne({
-      id: dataOoc.dataSampleId
-    })
-  }
-
   @FieldResolver(type => Domain)
   async domain(@Root() dataOoc: DataOoc): Promise<Domain> {
     return await getRepository(Domain).findOne(dataOoc.domainId)

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

@@ -15,6 +15,9 @@ export class NewDataOoc {
   @Field(type => ObjectRef, { nullable: true })
   dataSet?: ObjectRef
 
+  @Field({ nullable: true })
+  dataSetVersion?: number
+
   @Field(type => ObjectRef, { nullable: true })
   dataSample?: ObjectRef
 

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

@@ -4,9 +4,7 @@ import {
   CreateDateColumn,
   Entity,
   Index,
-  JoinColumn,
   ManyToOne,
-  OneToOne,
   PrimaryGeneratedColumn,
   RelationId,
   UpdateDateColumn
@@ -16,7 +14,7 @@ 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 { DataItem } from '../data-set/data-item-type'
 import { DataSet } from '../data-set/data-set'
 
 const ORMCONFIG = config.get('ormconfig', {})
@@ -34,9 +32,7 @@ registerEnumType(DataOocStatus, {
 })
 
 @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 })
+@Index('ix_data_ooc_0', (dataOoc: DataOoc) => [dataOoc.domain, dataOoc.dataSet, dataOoc.collectedAt], { unique: false })
 @ObjectType({ description: 'Entity for Out of control data' })
 export class DataOoc {
   @PrimaryGeneratedColumn('uuid')
@@ -67,13 +63,9 @@ export class DataOoc {
   @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 })
+  dataSetVersion?: number
 
   @Column({
     nullable: true
@@ -127,7 +119,10 @@ export class DataOoc {
 
   @Column('simple-json', { nullable: true })
   @Field(type => ScalarObject, { nullable: true })
-  spec?: ScalarObject
+  judgment?: ScalarObject
+
+  @Field(type => [DataItem], { nullable: true })
+  dataItems?: DataItem[]
 
   @Column('simple-json', { nullable: true })
   @Field(type => ScalarObject, { nullable: true })

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

@@ -4,6 +4,8 @@ import { getRepository } from 'typeorm'
 import { User } from '@things-factory/auth-base'
 import { Domain, getQueryBuilderFromListParams, ListParam } from '@things-factory/shell'
 
+import { DataSetHistory } from '../data-set-history/data-set-history'
+import { DataItem } from '../data-set/data-item-type'
 import { DataSet } from '../data-set/data-set'
 import { DataSample } from './data-sample'
 import { DataSampleList } from './data-sample-type'
@@ -37,8 +39,19 @@ export class DataSampleQuery {
     return { items, total }
   }
 
+  @FieldResolver(type => [DataItem])
+  async dataItems(@Root() dataSample: DataSample): Promise<DataItem[]> {
+    const dataSetHistory: DataSetHistory = await getRepository(DataSetHistory).findOne({
+      where: {
+        id: dataSample.dataSetId,
+        version: dataSample.dataSetVersion
+      }
+    })
+    return dataSetHistory?.dataItems || []
+  }
+
   @FieldResolver(type => DataSet)
-  async dataSet(@Root() dataSample: DataSample): Promise<Domain> {
+  async dataSet(@Root() dataSample: DataSample): Promise<DataSet> {
     return await getRepository(DataSet).findOne(dataSample.dataSetId)
   }
 

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

@@ -15,6 +15,9 @@ export class NewDataSample {
   @Field(type => ObjectRef, { nullable: true })
   dataSet?: ObjectRef
 
+  @Field({ nullable: true })
+  dataSetVersion?: number
+
   @Field(type => ScalarObject, { nullable: true })
   data?: ScalarObject
 

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

@@ -14,14 +14,14 @@ import { User } from '@things-factory/auth-base'
 import { config } from '@things-factory/env'
 import { Domain, ScalarObject } from '@things-factory/shell'
 
+import { DataItem } from '../data-set/data-item-type'
 import { DataSet } from '../data-set/data-set'
 
 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',
+  'ix_data_sample_0',
   (dataSample: DataSample) => [dataSample.domain, dataSample.dataSet, dataSample.collectedAt],
   { unique: false }
 )
@@ -71,13 +71,20 @@ export class DataSample {
   @RelationId((dataSample: DataSample) => dataSample.dataSet)
   dataSetId?: string
 
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  dataSetVersion?: number
+
   @Column('simple-json', { nullable: true })
   @Field(type => ScalarObject, { nullable: true })
   data?: ScalarObject
 
   @Column('simple-json', { nullable: true })
   @Field(type => ScalarObject, { nullable: true })
-  spec?: ScalarObject
+  judgment?: ScalarObject
+
+  @Field(type => [DataItem], { nullable: true })
+  dataItems?: DataItem[]
 
   @Column({
     nullable: true,

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

@@ -0,0 +1,82 @@
+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',
+  file = 'file'
+}
+
+registerEnumType(DataItemType, {
+  name: 'DataItemType',
+  description: 'state enumeration of a data-item'
+})
+
+@ObjectType({ description: 'Entity for DataItem' })
+export class DataItem {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  tag?: string
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field({ nullable: true })
+  hidden?: boolean
+
+  @Field({ nullable: true })
+  type?: DataItemType
+
+  @Field(type => ScalarObject, { nullable: true })
+  options?: ScalarObject
+
+  @Field({ nullable: true })
+  unit?: string
+
+  @Field(type => Int, { nullable: true })
+  quota: number
+
+  @Field(type => ScalarObject, { nullable: true })
+  spec?: ScalarObject
+}
+
+@InputType()
+export class DataItemPatch {
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  tag?: string
+
+  @Field(type => DataItemType, { nullable: true })
+  type?: DataItemType
+
+  @Field(type => ScalarObject, { nullable: true })
+  options?: ScalarObject
+
+  @Field({ nullable: true })
+  unit?: string
+
+  @Field(type => Int, { nullable: true })
+  quota?: number
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field({ nullable: true })
+  hidden?: boolean
+
+  @Field(type => ScalarObject, { nullable: true })
+  spec?: ScalarObject
+}

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

@@ -1,10 +1,9 @@
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, In } from 'typeorm'
+import { In } from 'typeorm'
 
 import { createAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
-import { Domain } from '@things-factory/shell'
 
-import { DataItem } from '../data-item/data-item'
+import { DataSetHistory } from '../data-set-history/data-set-history'
 import { DataSet } from './data-set'
 import { DataSetPatch, NewDataSet } from './data-set-type'
 
@@ -17,9 +16,12 @@ export class DataSetMutation {
   @Mutation(returns => DataSet, { description: 'To create new DataSet' })
   async createDataSet(@Arg('dataSet') dataSet: NewDataSet, @Ctx() context: any): Promise<DataSet> {
     const { domain, user, tx } = context.state
+    const dataSetRepo = tx.getRepository(DataSet)
+    const dataSetHistoryRepo = tx.getRepository(DataSetHistory)
 
-    const result = await tx.getRepository(DataSet).save({
+    const result = await dataSetRepo.save({
       ...dataSet,
+      version: 1,
       domain,
       creator: user,
       updater: user
@@ -27,6 +29,12 @@ export class DataSetMutation {
 
     await this._createAttachment(context, dataSet.reportTemplate, { refId: result.id, cuFlag: '+' })
 
+    await dataSetHistoryRepo.save(
+      await dataSetRepo.findOne(result.id, {
+        relations: ['domain', 'creator', 'updater', 'supervisoryRole', 'entryRole']
+      })
+    )
+
     return result
   }
 
@@ -35,20 +43,28 @@ export class DataSetMutation {
   @Mutation(returns => DataSet, { description: 'To modify DataSet information' })
   async updateDataSet(@Arg('id') id: string, @Arg('patch') patch: DataSetPatch, @Ctx() context: any): Promise<DataSet> {
     const { domain, user, tx } = context.state
+    const dataSetRepo = tx.getRepository(DataSet)
+    const dataSetHistoryRepo = tx.getRepository(DataSetHistory)
 
-    const repository = tx.getRepository(DataSet)
-    const dataSet = await repository.findOne({
+    const dataSet = await dataSetRepo.findOne({
       where: { domain, id }
     })
 
-    const result = await repository.save({
+    const result = await dataSetRepo.save({
       ...dataSet,
       ...patch,
+      version: (dataSet.version || 0) + 1,
       updater: user
     })
 
     await this._createAttachment(context, dataSet.reportTemplate, { refId: result.id, cuFlag: 'M' })
 
+    await dataSetHistoryRepo.save(
+      await dataSetRepo.findOne(id, {
+        relations: ['domain', 'creator', 'updater', 'supervisoryRole', 'entryRole']
+      })
+    )
+
     return result
   }
 
@@ -60,11 +76,12 @@ export class DataSetMutation {
     @Ctx() context: any
   ): Promise<DataSet[]> {
     const { domain, user, tx } = context.state
+    const dataSetRepo = tx.getRepository(DataSet)
+    const dataSetHistoryRepo = tx.getRepository(DataSetHistory)
 
     let results = []
     const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
     const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const dataSetRepo = tx.getRepository(DataSet)
 
     if (_createRecords.length > 0) {
       const cuFlag = '+'
@@ -73,6 +90,7 @@ export class DataSetMutation {
 
         const result = await dataSetRepo.save({
           ...newRecord,
+          version: 1,
           domain,
           creator: user,
           updater: user
@@ -80,7 +98,12 @@ export class DataSetMutation {
 
         await this._createAttachment(context, newRecord.reportTemplate, { refId: result.id, cuFlag })
 
-        results.push({ ...result, cuFlag })
+        results.push({
+          ...(await dataSetRepo.findOne(result.id, {
+            relations: ['domain', 'creator', 'updater', 'supervisoryRole', 'entryRole']
+          })),
+          cuFlag
+        })
       }
     }
 
@@ -93,15 +116,23 @@ export class DataSetMutation {
         const result = await dataSetRepo.save({
           ...dataSet,
           ...newRecord,
+          version: (dataSet.version || 0) + 1,
           updater: user
         })
 
         await this._createAttachment(context, newRecord.reportTemplate, { refId: result.id, cuFlag })
 
-        results.push({ ...result, cuFlag })
+        results.push({
+          ...(await dataSetRepo.findOne(result.id, {
+            relations: ['domain', 'creator', 'updater', 'supervisoryRole', 'entryRole']
+          })),
+          cuFlag
+        })
       }
     }
 
+    results.forEach(result => dataSetHistoryRepo.save({ ...result }))
+
     return results
   }
 
@@ -139,20 +170,22 @@ export class DataSetMutation {
     @Arg('dataSets', type => [DataSetPatch]) dataSets: DataSet[],
     @Ctx() context: any
   ): Promise<boolean> {
-    const tx: EntityManager = context.state.tx
-    const domain: Domain = context.state.domain
+    const { domain, tx } = context.state
+    const dataSetRepo = tx.getRepository(DataSet)
+    const dataSetHistoryRepo = tx.getRepository(DataSetHistory)
+
     await Promise.all(
       dataSets.map(async (dataSet: DataSet) => {
-        const createdDataSet: DataSet = await tx.getRepository(DataSet).save({ domain, ...dataSet })
-        if (dataSet.dataItems?.length) {
-          await tx.getRepository(DataItem).save(
-            dataSet.dataItems.map((dataItem: DataItem) => {
-              dataItem.domain = domain
-              dataItem.dataSet = createdDataSet
-              return dataItem
-            })
-          )
-        }
+        const createdDataSet: DataSet = await dataSetRepo.save({
+          domain,
+          version: 1 /* overridable by dataSet's origin value */,
+          ...dataSet
+        })
+        await dataSetHistoryRepo.save(
+          ...(await dataSetRepo.findOne(createdDataSet.id, {
+            relations: ['domain', 'creator', 'updater', 'supervisoryRole', 'entryRole']
+          }))
+        )
       })
     )
 
@@ -164,69 +197,40 @@ export class DataSetMutation {
   @Mutation(returns => [DataSet], { description: 'To copy multiple data-sets' })
   async copyDataSets(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<DataSet[]> {
     const { domain, user, tx } = context.state
+    const dataSetRepo = tx.getRepository(DataSet)
+    const dataSetHistoryRepo = tx.getRepository(DataSetHistory)
 
-    const originals = await tx.getRepository(DataSet).find({
+    const originals = await dataSetRepo.find({
       where: {
         id: In(ids),
         domain
       },
-      relations: ['domain', 'dataItems']
+      relations: ['domain', 'supervisoryRole', 'entryRole']
     })
 
     if (originals.length == 0) {
       return []
     }
 
-    var newDataItems = []
-
     var newCopys = originals.map(dataSet => {
       let dataSetId = crypto.randomUUID()
-      newDataItems.push(
-        ...dataSet.dataItems.map(dataItem => {
-          return {
-            dataSet: dataSetId,
-            name: dataItem.name,
-            description: dataItem.description,
-            sequence: dataItem.sequence,
-            tag: dataItem.tag,
-            active: dataItem.active,
-            type: dataItem.type,
-            quota: dataItem.quota,
-            spec: dataItem.spec,
-            unit: dataItem.unit,
-            options: dataItem.options,
-            hidden: dataItem.hidden,
-            // connection: dataItem.connection,
-            // params: dataItem.params,
-            domain,
-            creator: user,
-            updater: user
-          }
-        })
-      )
 
       return {
+        ...dataSet,
         id: dataSetId,
         name: dataSet.name + ' (' + dataSetId + ')',
-        type: dataSet.type,
-        description: dataSet.description,
         active: false,
-        schedule: dataSet.schedule,
-        timezone: dataSet.timezone,
-
+        version: 1,
         domain,
         creator: user,
         updater: user
       }
     })
 
-    var copiedDataSets = await tx.getRepository(DataSet).save(newCopys)
-    var copiedDataItems = await tx.getRepository(DataItem).save(newDataItems)
+    var copiedDataSets = await dataSetRepo.save(newCopys)
+    await dataSetHistoryRepo.save(copiedDataSets)
 
-    return copiedDataSets.map(dataSet => {
-      dataSet.dataItems = copiedDataItems.filter(dataItem => dataItem.dataSet == dataSet.id)
-      return dataSet
-    })
+    return copiedDataSets
   }
 
   async _createAttachment(context, attachment, { refId, cuFlag }) {

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

@@ -34,6 +34,7 @@ export class DataSetQuery {
       repository: getRepository(DataSet),
       params,
       domain,
+      alias: 'dataset',
       searchables: ['name', 'description', 'supervisoryRole']
     })
 
@@ -57,18 +58,16 @@ export class DataSetQuery {
       return { items: [], total: 0 }
     }
 
-    const queryBuilder = getQueryBuilderFromListParams({
+    const [items, total] = await getQueryBuilderFromListParams({
       repository: getRepository(DataSet),
       params,
       domain,
       alias: 'dataset',
       searchables: ['name', 'description']
     })
-
-    queryBuilder.andWhere(`dataset.active = :active`, { active: true })
-    queryBuilder.andWhere(`dataset.entry_role_id IN (:...roles)`, { roles })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
+      .andWhere(`dataset.active = :active`, { active: true })
+      .andWhere('dataset.entryRole IN (:...roles)', { roles })
+      .getManyAndCount()
 
     return { items, total }
   }
@@ -88,24 +87,27 @@ export class DataSetQuery {
       return { items: [], total: 0 }
     }
 
-    const queryBuilder = getQueryBuilderFromListParams({
+    const [items, total] = await getQueryBuilderFromListParams({
       repository: getRepository(DataSet),
       params,
       domain,
       alias: 'dataset',
       searchables: ['name', 'description']
     })
-
-    queryBuilder.andWhere(`dataset.active = :active`, { active: true })
-    queryBuilder.andWhere(`dataset.supervisory_role_id IN (:...roles)`, { roles })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
+      .andWhere(`dataset.active = :active`, { active: true })
+      .andWhere('dataset.supervisoryRole IN (:...roles)', { roles })
+      .getManyAndCount()
 
     return { items, total }
   }
 
   @FieldResolver(type => [DataItem])
   async dataItems(@Root() dataSet: DataSet): Promise<DataItem[]> {
+    /* TODO this fieldResolver should be removed. This is only for migration temporarily */
+    if (dataSet.dataItems) {
+      return dataSet.dataItems as DataItem[]
+    }
+
     return await getRepository(DataItem).find({
       dataSet
     })