@things-factory/dataset 8.0.6 → 9.0.0-beta.12

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

@@ -1,193 +0,0 @@
-import { Field, ID, ObjectType } 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, json5Transformer } 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 { DataOoc } from '../data-ooc/data-ooc'
-
-const ORMCONFIG = config.get('ormconfig', {})
-const DATABASE_TYPE = ORMCONFIG.type
-@Entity()
-@Index(
-  'ix_data_sample_0',
-  (dataSample: DataSample) => [
-    dataSample.domain,
-    dataSample.dataSet,
-    dataSample.workDate,
-    dataSample.workShift,
-    dataSample.collectedAt
-  ],
-  {
-    unique: false
-  }
-)
-@Index(
-  'ix_data_sample_1',
-  (dataSample: DataSample) => [dataSample.domain, dataSample.dataSet, dataSample.collectedAt],
-  { unique: false }
-)
-@ObjectType({ description: 'Entity for DataSample' })
-export class DataSample {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain)
-  domain?: Domain
-
-  @RelationId((dataSample: DataSample) => dataSample.domain)
-  domainId?: string
-
-  @Column()
-  @Field({ nullable: true })
-  name: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  type?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  useCase?: string
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => ScalarObject, { nullable: true })
-  partitionKeys?: { [key: string]: any }
-
-  @ManyToOne(type => DataSet)
-  @Field(type => DataSet, { nullable: false })
-  dataSet?: DataSet
-
-  @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?: any
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => ScalarObject, { nullable: true })
-  judgment?: any
-
-  @Field(type => [DataItem], { nullable: true })
-  dataItems?: DataItem[]
-
-  @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,
-    transformer: json5Transformer
-  })
-  @Field({ nullable: true })
-  rawData?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  source?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  ooc?: boolean
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  oos?: boolean
-
-  @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({ nullable: true })
-  @Field({ nullable: true })
-  workDate?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  workShift?: string
-
-  @OneToOne(type => ActivityInstance, { nullable: true })
-  @JoinColumn()
-  @Field({ nullable: true })
-  reviewActivityInstance?: ActivityInstance
-
-  @RelationId((dataSample: DataSample) => dataSample.reviewActivityInstance)
-  reviewActivityInstanceId?: string
-
-  @OneToOne(type => DataOoc, dataOoc => dataOoc.dataSample, { nullable: true })
-  @Field(type => DataOoc, { nullable: true })
-  dataOoc?: DataOoc
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  collectedAt?: Date
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((dataSample: DataSample) => dataSample.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((dataSample: DataSample) => dataSample.updater)
-  updaterId?: string
-}

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

@@ -1,6 +0,0 @@
-import { DataSample } from './data-sample'
-import { DataSampleQuery } from './data-sample-query'
-import { DataSampleMutation } from './data-sample-mutation'
-
-export const entities = [DataSample]
-export const resolvers = [DataSampleQuery, DataSampleMutation]

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

@@ -1,116 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { DataSensor } from './data-sensor'
-import { DataSensorPatch, NewDataSensor } from './data-sensor-type'
-
-@Resolver(DataSensor)
-export class DataSensorMutation {
-  @Directive('@transaction')
-  @Mutation(returns => DataSensor, { description: 'To create new DataSensor' })
-  async createDataSensor(
-    @Arg('dataSensor') dataSensor: NewDataSensor,
-    @Ctx() context: ResolverContext
-  ): Promise<DataSensor> {
-    const { domain, user, tx } = context.state
-
-    return await tx.getRepository(DataSensor).save({
-      ...dataSensor,
-      domain,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => DataSensor, { description: 'To modify DataSensor information' })
-  async updateDataSensor(
-    @Arg('id') id: string,
-    @Arg('patch') patch: DataSensorPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<DataSensor> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(DataSensor)
-    const dataSensor = await repository.findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-
-    return await repository.save({
-      ...dataSensor,
-      ...patch,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [DataSensor], { description: "To modify multiple DataSensors' information" })
-  async updateMultipleDataSensor(
-    @Arg('patches', type => [DataSensorPatch]) patches: DataSensorPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<DataSensor[]> {
-    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 dataSensorRepo = tx.getRepository(DataSensor)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await dataSensorRepo.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 dataSensor = await dataSensorRepo.findOneBy({ id: newRecord.id })
-
-        const result = await dataSensorRepo.save({
-          ...dataSensor,
-          ...newRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete DataSensor' })
-  async deleteDataSensor(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(DataSensor).delete({ domain: { id: domain.id }, id })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple dataSensors' })
-  async deleteDataSensors(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(DataSensor).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    return true
-  }
-}

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

@@ -1,76 +0,0 @@
-import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-
-import { Appliance, User } from '@things-factory/auth-base'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-import { Scenario } from '@things-factory/integration-base'
-
-import { DataSet } from '../data-set/data-set'
-import { DataSensor } from './data-sensor'
-import { DataSensorList } from './data-sensor-type'
-
-@Resolver(DataSensor)
-export class DataSensorQuery {
-  @Query(returns => DataSensor, { description: 'To fetch a DataSensor' })
-  async dataSensor(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<DataSensor> {
-    const { domain } = context.state
-
-    return await getRepository(DataSensor).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Query(returns => DataSensorList, { description: 'To fetch multiple DataSensors' })
-  async dataSensors(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<DataSensorList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      repository: getRepository(DataSensor),
-      params,
-      domain,
-      searchables: ['name', 'description', 'deviceId', 'tag']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => Appliance)
-  async appliance(@Root() dataSensor: DataSensor): Promise<Appliance> {
-    return dataSensor.applianceId && (await getRepository(Appliance).findOneBy({ id: dataSensor.applianceId }))
-  }
-
-  @FieldResolver(type => DataSet)
-  async dataSet(@Root() dataSensor: DataSensor): Promise<DataSet> {
-    return dataSensor.dataSetId && (await getRepository(DataSet).findOneBy({ id: dataSensor.dataSetId }))
-  }
-
-  @FieldResolver(type => Scenario)
-  async decoder(@Root() dataSensor: DataSensor): Promise<Scenario> {
-    return (
-      dataSensor.decoder ||
-      (dataSensor.decoderId &&
-        (await getRepository(Scenario).findOneBy({
-          id: dataSensor.decoderId
-        })))
-    )
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() dataSensor: DataSensor): Promise<Domain> {
-    return dataSensor.domainId && (await getRepository(Domain).findOneBy({ id: dataSensor.domainId }))
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() dataSensor: DataSensor): Promise<User> {
-    return dataSensor.updaterId && (await getRepository(User).findOneBy({ id: dataSensor.updaterId }))
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() dataSensor: DataSensor): Promise<User> {
-    return dataSensor.creatorId && (await getRepository(User).findOneBy({ id: dataSensor.creatorId }))
-  }
-}

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

@@ -1,104 +0,0 @@
-import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
-
-import { ObjectRef } from '@things-factory/shell'
-
-import { DataSensor } from './data-sensor'
-
-@InputType()
-export class NewDataSensor {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field({ nullable: true })
-  deviceId?: string
-
-  @Field({ nullable: true })
-  serialNo?: string
-
-  @Field({ nullable: true })
-  brand?: string
-
-  @Field({ nullable: true })
-  model?: string
-
-  @Field({ nullable: true })
-  netmask?: string
-
-  @Field({ nullable: true })
-  tag?: string
-
-  @Field({ nullable: true })
-  refBy?: string
-
-  @Field(type => ObjectRef, { nullable: true })
-  appliance?: ObjectRef
-
-  @Field(type => ObjectRef, { nullable: true })
-  dataSet?: ObjectRef
-
-  @Field(type => ObjectRef, { nullable: true })
-  decoder?: ObjectRef
-}
-
-@InputType()
-export class DataSensorPatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field({ nullable: true })
-  deviceId?: string
-
-  @Field({ nullable: true })
-  serialNo?: string
-
-  @Field({ nullable: true })
-  brand?: string
-
-  @Field({ nullable: true })
-  model?: string
-
-  @Field({ nullable: true })
-  netmask?: string
-
-  @Field({ nullable: true })
-  tag?: string
-
-  @Field({ nullable: true })
-  refBy?: string
-
-  @Field(type => ObjectRef, { nullable: true })
-  appliance?: ObjectRef
-
-  @Field(type => ObjectRef, { nullable: true })
-  dataSet?: ObjectRef
-
-  @Field(type => ObjectRef, { nullable: true })
-  decoder?: ObjectRef
-
-  @Field()
-  cuFlag: string
-}
-
-@ObjectType()
-export class DataSensorList {
-  @Field(type => [DataSensor])
-  items: DataSensor[]
-
-  @Field(type => Int)
-  total: number
-}

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

@@ -1,126 +0,0 @@
-import { Field, ID, ObjectType } from 'type-graphql'
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn
-} from 'typeorm'
-
-import { Domain } from '@things-factory/shell'
-import { Appliance, User } from '@things-factory/auth-base'
-import { Scenario } from '@things-factory/integration-base'
-
-import { DataSet } from '../data-set/data-set'
-
-@Entity()
-@Index('ix_data_sensor_0', (dataSensor: DataSensor) => [dataSensor.domain, dataSensor.name], { unique: true })
-@Index('ix_data_sensor_1', (dataSensor: DataSensor) => [dataSensor.deviceId], { unique: true })
-@Index('ix_data_sensor_2', (dataSensor: DataSensor) => [dataSensor.domain, dataSensor.refBy], {
-  unique: false
-})
-@Index('ix_data_sensor_3', (dataSensor: DataSensor) => [dataSensor.domain, dataSensor.serialNo], {
-  unique: false
-})
-@ObjectType({ description: 'Entity for DataSensor' })
-export class DataSensor {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain)
-  domain?: Domain
-
-  @RelationId((dataSensor: DataSensor) => dataSensor.domain)
-  domainId?: string
-
-  @Column()
-  @Field()
-  name?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  deviceId?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  serialNo?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  brand?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  model?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  netmask?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  tag?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  refBy?: string
-
-  @ManyToOne(type => Appliance, { nullable: true })
-  @Field({ nullable: true })
-  appliance?: Appliance
-
-  @RelationId((dataSensor: DataSensor) => dataSensor.appliance)
-  applianceId?: string
-
-  @ManyToOne(type => DataSet, { nullable: true })
-  @Field({ nullable: true })
-  dataSet?: DataSet
-
-  @RelationId((dataSensor: DataSensor) => dataSensor.dataSet)
-  dataSetId?: string
-
-  @ManyToOne(type => Scenario, { nullable: true })
-  @Field(type => Scenario, {
-    nullable: true,
-    description: 'The decoder scenario that automatically executes based on the trigger of raw data collection'
-  })
-  decoder?: Scenario
-
-  @RelationId((dataSensor: DataSensor) => dataSensor.decoder)
-  decoderId?: string
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((dataSensor: DataSensor) => dataSensor.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((dataSensor: DataSensor) => dataSensor.updater)
-  updaterId?: string
-}

package/server/service/data-sensor/index.ts

@@ -1,6 +0,0 @@
-import { DataSensor } from './data-sensor'
-import { DataSensorQuery } from './data-sensor-query'
-import { DataSensorMutation } from './data-sensor-mutation'
-
-export const entities = [DataSensor]
-export const resolvers = [DataSensorQuery, DataSensorMutation]