@things-factory/dataset 8.0.0-beta.9 → 8.0.2

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

@@ -0,0 +1,48 @@
+import { filter, pipe } from 'graphql-yoga'
+import { Resolver, Root, Subscription } from 'type-graphql'
+
+import { User } from '@things-factory/auth-base'
+import { getRepository, pubsub } from '@things-factory/shell'
+
+import { DataOoc } from './data-ooc'
+
+@Resolver(DataOoc)
+export class DataOocSubscription {
+  @Subscription({
+    subscribe: ({ args, context, info }) => {
+      const { domain, user } = context.state
+      const subdomain = domain?.subdomain
+
+      if (!domain) {
+        throw new Error('domain required')
+      }
+
+      if (!user.domains?.find(d => d.subdomain === subdomain) && !process.superUserGranted(domain, user)) {
+        throw new Error(`domain(${subdomain}) is not working for user(${user.email}).`)
+      }
+
+      return pipe(
+        pubsub.subscribe('data-ooc'),
+        filter(async (payload: { dataOoc: DataOoc; supervisoryRoleId: string }) => {
+          const { dataOoc, supervisoryRoleId } = payload
+          const { domain } = dataOoc
+
+          if (subdomain !== domain?.subdomain) {
+            return false
+          }
+
+          // check if the user has that role
+          const userWithRoles: User = await getRepository(User).findOne({
+            where: { id: user.id },
+            relations: ['roles']
+          })
+
+          return !!userWithRoles.roles.find(role => role.id === supervisoryRoleId)
+        })
+      )
+    }
+  })
+  dataOoc(@Root() payload: { dataOoc: DataOoc; supervisoryRoleId: string }): DataOoc {
+    return payload.dataOoc
+  }
+}

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

@@ -0,0 +1,71 @@
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef, ScalarObject } from '@things-factory/shell'
+
+import { DataOoc, DataOocStatus } from './data-ooc'
+
+@InputType()
+export class NewDataOoc {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  dataSet?: ObjectRef
+
+  @Field({ nullable: true })
+  dataSetVersion?: number
+
+  @Field(type => ObjectRef, { nullable: true })
+  dataSample?: ObjectRef
+
+  @Field(type => DataOocStatus, { nullable: true })
+  state?: DataOocStatus
+
+  @Field(type => ScalarObject, { nullable: true })
+  data?: any
+
+  @Field({ nullable: true })
+  rawData?: string
+
+  @Field({ nullable: true })
+  source?: string
+
+  @Field({ nullable: true })
+  ooc?: boolean
+
+  @Field({ nullable: true })
+  oos?: boolean
+
+  @Field({ nullable: true })
+  workDate?: string
+
+  @Field({ nullable: true })
+  workShift?: string
+
+  @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,259 @@
+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 { ActivityInstance } from '@things-factory/worklist'
+
+import { DataItem } from '../data-set/data-item-type'
+import { DataSet } from '../data-set/data-set'
+import { DataSample } from '../data-sample/data-sample'
+
+const ORMCONFIG = config.get('ormconfig', {})
+const DATABASE_TYPE = ORMCONFIG.type
+
+export enum DataOocStatus {
+  ISSUED = 'ISSUED',
+  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, 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(type => Domain)
+  domain?: Domain
+
+  @RelationId((dataOoc: DataOoc) => dataOoc.domain)
+  domainId?: string
+
+  @Column()
+  @Field({ nullable: true })
+  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
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  dataSetVersion?: number
+
+  @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'
+          : DATABASE_TYPE == 'mssql'
+            ? 'nvarchar'
+            : 'varchar',
+    length: DATABASE_TYPE == 'mssql' ? 'MAX' : undefined
+  })
+  @Field({ nullable: true })
+  correctiveInstruction?: string
+
+  @Column({
+    nullable: true,
+    type:
+      DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
+        ? 'longtext'
+        : DATABASE_TYPE == 'oracle'
+          ? 'clob'
+          : DATABASE_TYPE == 'mssql'
+            ? 'nvarchar'
+            : 'varchar',
+    length: DATABASE_TYPE == 'mssql' ? 'MAX' : undefined
+  })
+  @Field({ nullable: true })
+  correctiveAction?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  type?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  useCase?: string
+
+  @Column({ nullable: true, default: '' })
+  @Field({ nullable: true })
+  key01?: string = ''
+
+  @Column({ nullable: true, default: '' })
+  @Field({ nullable: true })
+  key02?: string = ''
+
+  @Column({ nullable: true, default: '' })
+  @Field({ nullable: true })
+  key03?: string = ''
+
+  @Column({ nullable: true, default: '' })
+  @Field({ nullable: true })
+  key04?: string = ''
+
+  @Column({ nullable: true, default: '' })
+  @Field({ nullable: true })
+  key05?: string = ''
+
+  @Column('simple-json', { nullable: true })
+  @Field(type => ScalarObject, { nullable: true })
+  partitionKeys?: { [key: string]: any }
+
+  @Column('simple-json', { nullable: true })
+  @Field(type => ScalarObject, { nullable: true })
+  data?: any
+
+  @Column('simple-json', { nullable: true })
+  @Field(type => ScalarObject, { nullable: true })
+  judgment?: any
+
+  @Field(type => [DataItem], { nullable: true })
+  dataItems?: DataItem[]
+
+  @Column('simple-json', { nullable: true })
+  @Field(type => ScalarObject, { nullable: true })
+  history?: any
+
+  @Column({
+    nullable: true,
+    type:
+      DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
+        ? 'longtext'
+        : DATABASE_TYPE == 'oracle'
+          ? 'clob'
+          : DATABASE_TYPE == 'mssql'
+            ? 'nvarchar'
+            : 'varchar',
+    length: DATABASE_TYPE == 'mssql' ? 'MAX' : undefined
+  })
+  @Field({ nullable: true })
+  rawData?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  source?: string
+
+  @OneToOne(type => DataSample, { nullable: true })
+  @JoinColumn()
+  @Field(type => DataSample, { nullable: true })
+  dataSample?: DataSample
+
+  @RelationId((dataOoc: DataOoc) => dataOoc.dataSample)
+  dataSampleId?: string
+
+  @OneToOne(type => ActivityInstance, { nullable: true })
+  @JoinColumn()
+  @Field({ nullable: true })
+  reviewActivityInstance?: ActivityInstance
+
+  @RelationId((dataOoc: DataOoc) => dataOoc.reviewActivityInstance)
+  reviewActivityInstanceId?: string
+
+  @OneToOne(type => ActivityInstance, { nullable: true })
+  @JoinColumn()
+  @Field({ nullable: true })
+  resolveActivityInstance?: ActivityInstance
+
+  @RelationId((dataOoc: DataOoc) => dataOoc.resolveActivityInstance)
+  resolveActivityInstanceId?: 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 })
+  reviewedAt?: 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 })
+  reviewer?: User
+
+  @RelationId((dataOoc: DataOoc) => dataOoc.reviewer)
+  reviewerId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  corrector?: User
+
+  @RelationId((dataOoc: DataOoc) => dataOoc.corrector)
+  correctorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((dataOoc: DataOoc) => dataOoc.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((dataOoc: DataOoc) => dataOoc.updater)
+  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

@@ -0,0 +1,18 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+
+import { createDataSample } from '../../controllers/create-data-sample'
+import { DataSample } from './data-sample'
+import { NewDataSample } from './data-sample-type'
+
+@Resolver(DataSample)
+export class DataSampleMutation {
+  @Directive('@privilege(category: "data-sample", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => DataSample, { description: 'To create new data sample' })
+  async createDataSample(
+    @Arg('dataSample') dataSample: NewDataSample,
+    @Ctx() context: ResolverContext
+  ): Promise<DataSample> {
+    return await createDataSample(dataSample, context)
+  }
+}

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

@@ -0,0 +1,215 @@
+import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import {
+  Domain,
+  getISOStringsForPeriod,
+  getQueryBuilderFromListParams,
+  getRepository,
+  ListParam
+} from '@things-factory/shell'
+import { ActivityInstance } from '@things-factory/worklist'
+
+import { DataKeySet } from '../data-key-set/data-key-set'
+import { DataOoc } from '../data-ooc/data-ooc'
+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'
+
+@Resolver(DataSample)
+export class DataSampleQuery {
+  @Directive('@privilege(category: "data-sample", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => DataSample, { description: 'To fetch a data sample' })
+  async dataSample(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<DataSample> {
+    const { domain } = context.state
+
+    return await getRepository(DataSample).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Directive('@privilege(category: "data-sample", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => DataSampleList, { description: 'To fetch multiple data samples' })
+  async dataSamples(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<DataSampleList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      repository: getRepository(DataSample),
+      params,
+      domain,
+      searchables: ['name', 'description', 'key01', 'key02', 'key03', 'key04', 'key05']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @Directive('@privilege(category: "data-sample", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => DataSampleList, { description: 'To fetch multiple data samples by data set' })
+  async dataSamplesByDataSet(
+    @Arg('dataSetId') dataSetId: string,
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<DataSampleList> {
+    const { domain } = context.state
+
+    const dataSet = await getRepository(DataSet).findOne({
+      where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, id: dataSetId },
+      relations: ['dataKeySet']
+    })
+
+    if (!dataSet) {
+      throw new Error(`dataSet not found by the given dataSetId(${dataSetId})`)
+    }
+
+    const dataKeyItems = dataSet.dataKeySet?.dataKeyItems || []
+    const searchables = dataKeyItems.map((item, index) => `key0${index + 1}`)
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      repository: getRepository(DataSample),
+      params,
+      domain,
+      alias: 'sample',
+      searchables: ['name', 'description'].concat(searchables)
+    }).innerJoin('sample.dataSet', 'ds', 'ds.id = :dataSetId', {
+      dataSetId
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @Directive('@privilege(category: "data-sample", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => DataSampleList, { description: 'To fetch multiple data samples by data key set' })
+  async dataSamplesByDataKeySet(
+    @Arg('dataKeySetId') dataKeySetId: string,
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<DataSampleList> {
+    const { domain } = context.state
+
+    const dataKeySet = await getRepository(DataKeySet).findOneBy({ id: dataKeySetId })
+    const dataKeyItems = dataKeySet?.dataKeyItems || []
+    const searchables = dataKeyItems.map((item, index) => `key0${index + 1}`)
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      repository: getRepository(DataSample),
+      params,
+      domain,
+      alias: 'sample',
+      searchables: ['name', 'description'].concat(searchables)
+    }).innerJoin('sample.dataSet', 'ds', 'ds.dataKeySet = :dataKeySetId', {
+      dataKeySetId
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @Query(returns => DataSampleList, { description: 'To fetch multiple DataSamples by period' })
+  async dataSamplesByPeriod(
+    @Arg('period') period: 'today' | 'this month' | '30 days' | 'this year' | '12 months',
+    @Arg('dataSetName') dataSetName: string,
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<DataSampleList> {
+    const { domain } = context.state
+    const { from, to } = await getISOStringsForPeriod(period, context)
+
+    const dataSet = await getRepository(DataSet).findOne({
+      where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, name: dataSetName },
+      relations: ['dataKeySet']
+    })
+
+    if (!dataSet) {
+      throw new Error(`dataSet not found by the given dataSetName(${dataSetName})`)
+    }
+
+    const { filters = [] } = params || {}
+    const alteredFilters = filters.concat([
+      {
+        name: 'collectedAt',
+        operator: 'between',
+        value: [from, to]
+      }
+    ])
+
+    const dataKeyItems = dataSet.dataKeySet?.dataKeyItems || []
+    const searchables = dataKeyItems.map((item, index) => `key0${index + 1}`)
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      repository: getRepository(DataSample),
+      params: {
+        ...params,
+        filters: alteredFilters
+      },
+      domain,
+      alias: 'sample',
+      searchables: ['name', 'description'].concat(searchables)
+    }).innerJoin('sample.dataSet', 'ds', 'ds.id = :dataSetId', {
+      dataSetId: dataSet.id
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => [DataItem])
+  async dataItems(@Root() dataSample: DataSample): Promise<DataItem[]> {
+    const dataSetHistory: DataSetHistory =
+      dataSample.dataSetId &&
+      (await getRepository(DataSetHistory).findOne({
+        where: {
+          originalId: dataSample.dataSetId,
+          version: dataSample.dataSetVersion
+        }
+      }))
+
+    return dataSetHistory?.dataItems.filter(item => item.active) || []
+  }
+
+  @FieldResolver(type => DataSet)
+  async dataSet(@Root() dataSample: DataSample): Promise<DataSet> {
+    return dataSample.dataSetId && (await getRepository(DataSet).findOneBy({ id: dataSample.dataSetId }))
+  }
+
+  @FieldResolver(type => DataOoc)
+  async dataOoc(@Root() dataSample: DataSample): Promise<DataOoc> {
+    if (dataSample.ooc || dataSample.oos) {
+      return await getRepository(DataOoc).findOneBy({ dataSample: { id: dataSample.id } })
+    }
+  }
+
+  @FieldResolver(type => ActivityInstance)
+  async reviewActivityInstance(@Root() dataSample: DataSample): Promise<ActivityInstance> {
+    return (
+      dataSample.reviewActivityInstanceId &&
+      (await getRepository(ActivityInstance).findOneBy({ id: dataSample.reviewActivityInstanceId }))
+    )
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() dataSample: DataSample): Promise<Domain> {
+    return dataSample.domainId && (await getRepository(Domain).findOneBy({ id: dataSample.domainId }))
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() dataSample: DataSample): Promise<User> {
+    return dataSample.updaterId && (await getRepository(User).findOneBy({ id: dataSample.updaterId }))
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() dataSample: DataSample): Promise<User> {
+    return dataSample.creatorId && (await getRepository(User).findOneBy({ id: dataSample.creatorId }))
+  }
+}

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

@@ -0,0 +1,47 @@
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef, ScalarObject } from '@things-factory/shell'
+
+import { DataSample } from './data-sample'
+
+@InputType()
+export class NewDataSample {
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  dataSet?: ObjectRef
+
+  @Field({ nullable: true })
+  dataSetVersion?: number
+
+  @Field(type => ScalarObject, { nullable: true })
+  data?: any
+
+  @Field({ nullable: true })
+  rawData?: string
+
+  @Field({ nullable: true })
+  source?: string
+
+  @Field({ nullable: true })
+  workDate?: string
+
+  @Field({ nullable: true })
+  workShift?: string
+
+  @Field({ nullable: true })
+  collectedAt?: Date
+}
+
+@ObjectType()
+export class DataSampleList {
+  @Field(type => [DataSample])
+  items: DataSample[]
+
+  @Field(type => Int)
+  total: number
+}