@things-factory/dataset 5.0.0-zeta.2 → 5.0.0-zeta.20

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: {
+        originalId: 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,8 @@
 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 { DataSet } from './data-set'
 import { DataSetPatch, NewDataSet } from './data-set-type'
 
@@ -17,9 +15,11 @@ 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 result = await tx.getRepository(DataSet).save({
+    const result = await dataSetRepo.save({
       ...dataSet,
+      version: 1,
       domain,
       creator: user,
       updater: user
@@ -35,13 +35,13 @@ 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 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,
       updater: user
@@ -60,11 +60,11 @@ export class DataSetMutation {
     @Ctx() context: any
   ): Promise<DataSet[]> {
     const { domain, user, tx } = context.state
+    const dataSetRepo = tx.getRepository(DataSet)
 
     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 = '+'
@@ -80,7 +80,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
+        })
       }
     }
 
@@ -98,7 +103,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
+        })
       }
     }
 
@@ -139,20 +149,15 @@ 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)
+
     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,
+          ...dataSet
+        })
       })
     )
 
@@ -164,69 +169,37 @@ 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 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,
-
         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)
 
-    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

@@ -103,6 +103,11 @@ export class DataSetQuery {
 
   @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
     })

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

@@ -1,8 +1,9 @@
-import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
 import { FileUpload, GraphQLUpload } from 'graphql-upload'
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
 
 import { ObjectRef, ScalarObject } from '@things-factory/shell'
 
+import { DataItemPatch } from './data-item-type'
 import { DataSet, DataSetEntryType, DataSetMonitorType, DataSetReportType } from './data-set'
 
 @InputType()
@@ -31,6 +32,9 @@ export class NewDataSet {
   @Field(type => ScalarObject, { nullable: true })
   partitionKeys?: ScalarObject
 
+  @Field(type => [DataItemPatch], { nullable: true })
+  dataItems?: DataItemPatch[]
+
   @Field({ nullable: true })
   schedule?: string
 
@@ -88,6 +92,9 @@ export class DataSetPatch {
   @Field(type => ScalarObject, { nullable: true })
   partitionKeys?: ScalarObject
 
+  @Field(type => [DataItemPatch], { nullable: true })
+  dataItems?: DataItemPatch[]
+
   @Field({ nullable: true })
   schedule?: string
 

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

@@ -5,16 +5,16 @@ import {
   Entity,
   Index,
   ManyToOne,
-  OneToMany,
   PrimaryGeneratedColumn,
   RelationId,
-  UpdateDateColumn
+  UpdateDateColumn,
+  VersionColumn
 } from 'typeorm'
 
 import { Role, User } from '@things-factory/auth-base'
 import { Domain, ScalarObject } from '@things-factory/shell'
 
-import { DataItem } from '../data-item/data-item'
+import { DataItem } from './data-item-type'
 
 export enum DataSetEntryType {
   Generated = 'generated',
@@ -77,6 +77,10 @@ export class DataSet {
   @Field({ nullable: true })
   description?: string
 
+  @VersionColumn({ nullable: true, default: 1 })
+  @Field({ nullable: true })
+  version?: number = 1
+
   @Column({
     nullable: true
   })
@@ -156,7 +160,7 @@ export class DataSet {
   @Field(type => ScalarObject, { nullable: true })
   partitionKeys?: ScalarObject
 
-  @OneToMany(type => DataItem, dataItem => dataItem.dataSet)
+  @Column('simple-json', { nullable: true })
   @Field(type => [DataItem], { nullable: true })
   dataItems: DataItem[]
 

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

@@ -0,0 +1,110 @@
+import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository } 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 { Domain, getQueryBuilderFromListParams, ListParam, ScalarDate } from '@things-factory/shell'
+
+import { DataSetHistory } from './data-set-history'
+import { DataSetHistoryList } from './data-set-history-type'
+
+@Resolver(DataSetHistory)
+export class DataSetHistoryQuery {
+  @Directive('@privilege(category: "data-set-history", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => DataSetHistory, { description: 'To fetch a DataSetHistory' })
+  async dataSetHistory(
+    @Arg('id') id: string,
+    @Arg('timestamp', type => ScalarDate) timestamp: ScalarDate,
+    @Ctx() context: any
+  ): Promise<DataSetHistory> {
+    const { domain } = context.state
+
+    return await getRepository(DataSetHistory).findOne({
+      where: { domain, originalId: id, updatedAt: timestamp }
+    })
+  }
+
+  @Directive('@privilege(category: "data-set-history", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => DataSetHistoryList, { description: 'To fetch multiple DataSetHistories' })
+  async dataSetHistories(@Args() params: ListParam, @Ctx() context: any): Promise<DataSetHistoryList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      repository: getRepository(DataSetHistory),
+      params,
+      domain,
+      searchables: ['name', 'description', 'supervisoryRole']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Role)
+  async entryRole(@Root() dataSetHistory: DataSetHistory): Promise<Role> {
+    return (
+      dataSetHistory.entryRole ||
+      (await getRepository(Role).findOne({
+        id: dataSetHistory.entryRoleId
+      }))
+    )
+  }
+
+  @FieldResolver(type => Role)
+  async supervisoryRole(@Root() dataSetHistory: DataSetHistory): Promise<Role> {
+    return (
+      dataSetHistory.supervisoryRole ||
+      (await getRepository(Role).findOne({
+        id: dataSetHistory.supervisoryRoleId
+      }))
+    )
+  }
+
+  @FieldResolver(type => Board, { nullable: true })
+  async entryBoard(@Root() dataSetHistory: DataSetHistory) {
+    if (dataSetHistory.entryType == 'board' && dataSetHistory.entryView) {
+      return await getRepository(Board).findOne({ id: dataSetHistory.entryView })
+    }
+  }
+
+  @FieldResolver(type => Board, { nullable: true })
+  async monitorBoard(@Root() dataSetHistory: DataSetHistory) {
+    if (dataSetHistory.monitorType == 'board' && dataSetHistory.monitorView) {
+      return await getRepository(Board).findOne({ id: dataSetHistory.monitorView })
+    }
+  }
+
+  @FieldResolver(type => User)
+  async timestamp(@Root() dataSetHistory: DataSetHistory): Promise<User> {
+    return dataSetHistory.updatedAt
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() dataSetHistory: DataSetHistory): Promise<Domain> {
+    return await getRepository(Domain).findOne(dataSetHistory.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() dataSetHistory: DataSetHistory): Promise<User> {
+    return await getRepository(User).findOne(dataSetHistory.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() dataSetHistory: DataSetHistory): Promise<User> {
+    return await getRepository(User).findOne(dataSetHistory.creatorId)
+  }
+
+  @FieldResolver(type => String)
+  async reportTemplate(@Root() dataSetHistory: DataSetHistory): Promise<string | undefined> {
+    const attachment: Attachment = await getRepository(Attachment).findOne({
+      where: {
+        domain: dataSetHistory.domainId,
+        refBy: `report-${dataSetHistory.originalId}`
+      }
+    })
+
+    return attachment?.path
+  }
+}

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

@@ -0,0 +1,12 @@
+import { Field, Int, ObjectType } from 'type-graphql'
+
+import { DataSetHistory } from '../data-set-history/data-set-history'
+
+@ObjectType()
+export class DataSetHistoryList {
+  @Field(type => [DataSetHistory])
+  items: DataSetHistory[]
+
+  @Field(type => Int)
+  total: number
+}