@things-factory/dataset 5.0.0-zeta.1 → 5.0.0-zeta.12

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

@@ -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,7 +5,6 @@ import {
   Entity,
   Index,
   ManyToOne,
-  OneToMany,
   PrimaryGeneratedColumn,
   RelationId,
   UpdateDateColumn
@@ -14,7 +13,7 @@ import {
 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 +76,13 @@ export class DataSet {
   @Field({ nullable: true })
   description?: string
 
+  @Column({
+    nullable: true,
+    default: 1
+  })
+  @Field({ nullable: true })
+  version?: number = 1
+
   @Column({
     nullable: true
   })
@@ -156,7 +162,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, 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.id}`
+      }
+    })
+
+    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
+}