@things-factory/dataset 8.0.39 → 9.0.0-9.0.0-beta.59.0

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

@@ -1,48 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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

@@ -1,259 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,215 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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
-}