@things-factory/dataset 5.0.0-alpha.11 → 5.0.0-alpha.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/dataset",
-  "version": "5.0.0-alpha.11",
+  "version": "5.0.0-alpha.14",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -24,18 +24,19 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create -d ./server/migrations"
   },
   "dependencies": {
-    "@operato/app": "1.0.0-alpha.29",
-    "@operato/data-grist": "1.0.0-alpha.29",
-    "@operato/dataset": "1.0.0-alpha.29",
-    "@operato/graphql": "1.0.0-alpha.29",
-    "@operato/i18n": "1.0.0-alpha.29",
-    "@operato/layout": "1.0.0-alpha.29",
-    "@operato/shell": "1.0.0-alpha.29",
-    "@operato/styles": "1.0.0-alpha.29",
-    "@operato/utils": "1.0.0-alpha.29",
-    "@things-factory/auth-base": "^5.0.0-alpha.11",
-    "@things-factory/env": "^5.0.0-alpha.11",
-    "@things-factory/shell": "^5.0.0-alpha.11"
+    "@operato/app": "1.0.0-alpha.34",
+    "@operato/data-grist": "1.0.0-alpha.34",
+    "@operato/dataset": "1.0.0-alpha.34",
+    "@operato/graphql": "1.0.0-alpha.34",
+    "@operato/i18n": "1.0.0-alpha.34",
+    "@operato/layout": "1.0.0-alpha.34",
+    "@operato/shell": "1.0.0-alpha.34",
+    "@operato/styles": "1.0.0-alpha.34",
+    "@operato/utils": "1.0.0-alpha.34",
+    "@things-factory/auth-base": "^5.0.0-alpha.14",
+    "@things-factory/env": "^5.0.0-alpha.14",
+    "@things-factory/shell": "^5.0.0-alpha.14",
+    "moment": "^2.29.1"
   },
-  "gitHead": "9f8d36335eabb80642c18ffc4a09fca23636bb00"
+  "gitHead": "e64e66b147eca1d3219fed7d9764fe2a221a5569"
 }

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

@@ -0,0 +1,85 @@
+import { DataItem, DataSet } from 'server/service'
+
+export type DataItemSpec = {
+  type: string
+  label: string
+  name: string
+  property: { [option: string]: any }
+}
+
+export type DataItemSpecSet = {
+  name: string
+  description: string
+  specs: DataItemSpec[]
+}
+
+export type EvaluationResult = { oos: boolean; ooc: boolean }
+
+export abstract class DataUseCase {
+  static registry: { [name: string]: DataUseCase } = {}
+
+  public static registerUseCase(name: string, provider: DataUseCase) {
+    DataUseCase.registry[name] = provider
+  }
+
+  public static getUseCaseNames() {
+    return Object.keys(DataUseCase.registry)
+  }
+
+  public static getUseCase(name: string): DataUseCase | undefined {
+    return DataUseCase.registry[name]
+  }
+
+  public static evaluate(dataSet: DataSet, dataItems: DataItem[], data: any): EvaluationResult {
+    var ooc = false
+    var oos = false
+
+    if (!dataSet.useCase) {
+      return { ooc, oos }
+    }
+
+    const useCaseNames = dataSet.useCase.split(',').map(useCaseName => useCaseName.trim())
+    const useCases = useCaseNames.map(useCaseName => DataUseCase.getUseCase(useCaseName)).filter(useCase => !!useCase)
+
+    for (let i = 0; i < dataItems.length; i++) {
+      const dataItem = dataItems[i]
+      const { name, active } = dataItem
+      if (!active) {
+        continue
+      }
+
+      let values: any | any[] = data[name]
+      if (typeof values === 'undefined') {
+        continue // TODO what if in case no value ?
+      }
+
+      if (!(values instanceof Array)) {
+        values = [values]
+      }
+
+      for (let j = 0; j < useCases.length; j++) {
+        const useCase = useCases[j]
+
+        const specs = dataItem.spec?.[dataSet.useCase]
+        if (!specs) {
+          continue
+        }
+
+        const result = useCase.evaluate(specs, values)
+
+        if (result) {
+          ooc ||= result.ooc
+          oos ||= result.oos
+        }
+
+        // if (ooc && oos) {
+        //   return { ooc, oos }
+        // }
+      }
+    }
+
+    return { ooc, oos }
+  }
+
+  public abstract evaluate(specs: any, values: any[]): EvaluationResult
+}

package/server/controllers/index.ts

@@ -0,0 +1 @@
+export * from './data-use-case'

package/server/index.ts

@@ -1,5 +1,6 @@
 import './routes'
 
+export * from './controllers'
 export * from './migrations'
 export * from './middlewares'
 export * from './service'

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

@@ -1,15 +1,14 @@
 import { DataItem, DataItemType } from './data-item'
 import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
-
-import { ScalarObject } from '@things-factory/shell'
+import { ObjectRef, ScalarObject } from '@things-factory/shell'
 
 @InputType()
 export class DataItemPatch {
   @Field(type => ID, { nullable: true })
   id?: string
 
-  @Field({ nullable: true })
-  dataSetId?: string
+  @Field(type => ObjectRef, { nullable: true })
+  dataSet?: ObjectRef
 
   @Field({ nullable: true })
   name?: string

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

@@ -53,7 +53,7 @@ export class DataItem {
   description?: string
 
   @ManyToOne(type => DataSet, dataSet => dataSet.dataItems, { onDelete: 'CASCADE' })
-  @Field(type => DataSet, { nullable: true })
+  @Field(type => DataSet, { nullable: false })
   dataSet?: DataSet
 
   @RelationId((dataItem: DataItem) => dataItem.dataSet)

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

@@ -0,0 +1,117 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { getRepository, In } from 'typeorm'
+import { DataOoc, DataOocStatus } from './data-ooc'
+import { NewDataOoc, DataOocPatch } from './data-ooc-type'
+
+@Resolver(DataOoc)
+export class DataOocMutation {
+  @Directive('@privilege(category: "data-ooc", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => DataOoc, { description: 'To create new DataOoc' })
+  async createDataOoc(@Arg('dataOoc') dataOoc: NewDataOoc, @Ctx() context: any): Promise<DataOoc> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(DataOoc).save({
+      ...dataOoc,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@privilege(category: "data-ooc", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => DataOoc, { description: 'To modify DataOoc information' })
+  async updateDataOoc(@Arg('id') id: string, @Arg('patch') patch: DataOocPatch, @Ctx() context: any): Promise<DataOoc> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(DataOoc)
+    const dataOoc = await repository.findOne({
+      where: { domain, id }
+    })
+
+    const more = {} as any
+    if (patch.correctiveAction) {
+      more.corrector = user
+      more.state = DataOocStatus.CORRECTED
+    }
+
+    return await repository.save({
+      ...dataOoc,
+      ...patch,
+      ...more,
+      updater: user
+    })
+  }
+
+  @Directive('@privilege(category: "data-ooc", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => [DataOoc], { description: "To modify multiple DataOoc' information" })
+  async updateMultipleDataOoc(
+    @Arg('patches', type => [DataOocPatch]) patches: DataOocPatch[],
+    @Ctx() context: any
+  ): Promise<DataOoc[]> {
+    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 dataOocRepo = tx.getRepository(DataOoc)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await dataOocRepo.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 dataOoc = await dataOocRepo.findOne(newRecord.id)
+
+        const result = await dataOocRepo.save({
+          ...dataOoc,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@privilege(category: "data-ooc", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete DataOoc' })
+  async deleteDataOoc(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(DataOoc).delete({ domain, id })
+    return true
+  }
+
+  @Directive('@privilege(category: "data-ooc", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple dataOocs' })
+  async deleteDataOocs(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(DataOoc).delete({
+      domain,
+      id: In(ids)
+    })
+
+    return true
+  }
+}

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

@@ -0,0 +1,45 @@
+import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
+import { getRepository } from 'typeorm'
+import { Domain, ListParam, convertListParams } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { DataOoc } from './data-ooc'
+import { DataOocList } from './data-ooc-type'
+
+@Resolver(DataOoc)
+export class DataOocQuery {
+  @Directive('@privilege(category: "data-ooc", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => DataOoc, { description: 'To fetch a DataOoc' })
+  async dataOoc(@Arg('id') id: string, @Ctx() context: any): Promise<DataOoc> {
+    const { domain } = context.state
+
+    return await getRepository(DataOoc).findOne({
+      where: { domain, id }
+    })
+  }
+
+  @Directive('@privilege(category: "data-ooc", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => DataOocList, { description: 'To fetch multiple DataOoc' })
+  async dataOocs(@Args() params: ListParam, @Ctx() context: any): Promise<DataOocList> {
+    const { domain } = context.state
+
+    const convertedParams = convertListParams(params, domain.id)
+    const [items, total] = await getRepository(DataOoc).findAndCount(convertedParams)
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() dataOoc: DataOoc): Promise<Domain> {
+    return await getRepository(Domain).findOne(dataOoc.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() dataOoc: DataOoc): Promise<User> {
+    return await getRepository(User).findOne(dataOoc.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() dataOoc: DataOoc): Promise<User> {
+    return await getRepository(User).findOne(dataOoc.creatorId)
+  }
+}

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

@@ -0,0 +1,62 @@
+import { DataOoc, DataOocStatus } from './data-ooc'
+import { Field, ID, InputType, Int, ObjectType, registerEnumType } from 'type-graphql'
+import { ObjectRef, ScalarObject } from '@things-factory/shell'
+
+import { User } from '@things-factory/auth-base'
+
+@InputType()
+export class NewDataOoc {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  dataSet?: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  dataSample?: ObjectRef
+
+  @Field(type => DataOocStatus, { nullable: true })
+  state?: DataOocStatus
+
+  @Field(type => ScalarObject, { nullable: true })
+  data?: ScalarObject
+
+  @Field({ nullable: true })
+  rawData?: string
+
+  @Field({ nullable: true })
+  source?: string
+
+  @Field({ nullable: true })
+  ooc?: boolean
+
+  @Field({ nullable: true })
+  oos?: boolean
+
+  @Field({ nullable: true })
+  collectedAt?: Date
+}
+
+@InputType()
+export class DataOocPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field(type => DataOocStatus, { nullable: true })
+  state?: DataOocStatus
+
+  @Field({ nullable: true })
+  correctiveAction?: string
+}
+
+@ObjectType()
+export class DataOocList {
+  @Field(type => [DataOoc])
+  items: DataOoc[]
+
+  @Field(type => Int)
+  total: number
+}

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

@@ -0,0 +1,188 @@
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  JoinColumn,
+  ManyToOne,
+  OneToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+import { Domain, ScalarObject } from '@things-factory/shell'
+import { Field, ID, Int, ObjectType, registerEnumType } from 'type-graphql'
+
+import { DataSample } from '../data-sample/data-sample'
+import { DataSet } from '../data-set/data-set'
+import { User } from '@things-factory/auth-base'
+import { config } from '@things-factory/env'
+
+const ORMCONFIG = config.get('ormconfig', {})
+const DATABASE_TYPE = ORMCONFIG.type
+
+export enum DataOocStatus {
+  CREATED = 'CREATED',
+  REVIEWED = 'REVIEWED',
+  CORRECTED = 'CORRECTED',
+  SUBMITTED = 'SUBMITTED',
+  APPROVED = 'APPROVED',
+  REJECTED = 'REJECTED'
+}
+
+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('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({
+    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 })
+  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,6 @@
+import { DataOoc } from './data-ooc'
+import { DataOocMutation } from './data-ooc-mutation'
+import { DataOocQuery } from './data-ooc-query'
+
+export const entities = [DataOoc]
+export const resolvers = [DataOocQuery, DataOocMutation]