@things-factory/dataset 8.0.0-beta.8 → 8.0.0

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

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

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

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

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

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

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

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