@things-factory/dataset 5.0.0-alpha.1 → 5.0.0-alpha.10

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

@@ -0,0 +1,110 @@
+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: any): 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: any
+  ): Promise<DataSensor> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(DataSensor)
+    const dataSensor = await repository.findOne({
+      where: { domain, 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: any
+  ): 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.findOne(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: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(DataSensor).delete({ domain, id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple dataSensors' })
+  async deleteDataSensors(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(DataSensor).delete({
+      domain,
+      id: In(ids)
+    })
+
+    return true
+  }
+}

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

@@ -0,0 +1,56 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository } from 'typeorm'
+
+import { Appliance, User } from '@things-factory/auth-base'
+import { convertListParams, Domain, ListParam } from '@things-factory/shell'
+
+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: any): Promise<DataSensor> {
+    const { domain } = context.state
+
+    return await getRepository(DataSensor).findOne({
+      where: { domain, id }
+    })
+  }
+
+  @Query(returns => DataSensorList, { description: 'To fetch multiple DataSensors' })
+  async dataSensors(@Args() params: ListParam, @Ctx() context: any): Promise<DataSensorList> {
+    const { domain } = context.state
+
+    const convertedParams = convertListParams(params, domain.id)
+    const [items, total] = await getRepository(DataSensor).findAndCount(convertedParams)
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Appliance)
+  async appliance(@Root() dataSensor: DataSensor): Promise<Appliance> {
+    return await getRepository(Appliance).findOne(dataSensor.applianceId || '')
+  }
+
+  @FieldResolver(type => Appliance)
+  async dataSet(@Root() dataSensor: DataSensor): Promise<DataSet> {
+    return await getRepository(DataSet).findOne(dataSensor.dataSetId || '')
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() dataSensor: DataSensor): Promise<Domain> {
+    return await getRepository(Domain).findOne(dataSensor.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() dataSensor: DataSensor): Promise<User> {
+    return await getRepository(User).findOne(dataSensor.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() dataSensor: DataSensor): Promise<User> {
+    return await getRepository(User).findOne(dataSensor.creatorId)
+  }
+}

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

@@ -0,0 +1,98 @@
+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
+}
+
+@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()
+  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,139 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { Appliance, User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+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({ nullable: true })
+  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
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((dataSensor: DataSensor) => dataSensor.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((dataSensor: DataSensor) => dataSensor.creator)
+  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]

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

@@ -1,5 +1,7 @@
 import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
 
+import { ScalarObject } from '@things-factory/shell'
+
 import { DataSet } from './data-set'
 
 @InputType()
@@ -13,6 +15,12 @@ export class NewDataSet {
   @Field({ nullable: true })
   active?: boolean
 
+  @Field({ nullable: true })
+  type?: string
+
+  @Field(type => ScalarObject, { nullable: true })
+  partitionKeys?: ScalarObject
+
   @Field({ nullable: true })
   schedule?: string
 
@@ -34,6 +42,12 @@ export class DataSetPatch {
   @Field({ nullable: true })
   active?: boolean
 
+  @Field({ nullable: true })
+  type?: string
+
+  @Field(type => ScalarObject, { nullable: true })
+  partitionKeys?: ScalarObject
+
   @Field({ nullable: true })
   schedule?: string
 

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

@@ -12,7 +12,7 @@ import {
 } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
+import { Domain, ScalarObject } from '@things-factory/shell'
 
 import { DataItem } from '../data-item/data-item'
 import { DataSample } from '../data-sample/data-sample'
@@ -48,6 +48,22 @@ export class DataSet {
   @Field({ nullable: true })
   active?: boolean
 
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  type?: string
+
+  @Column('simple-json', { nullable: true })
+  @Field(type => ScalarObject, { nullable: true })
+  partitionKeys?: ScalarObject
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  slugger?: string
+
   @OneToMany(type => DataItem, dataItem => dataItem.dataSet)
   @Field(type => [DataItem], { nullable: true })
   dataItems: DataItem[]

package/server/service/data-spec/data-spec-manager.ts

@@ -0,0 +1,21 @@
+import { DataSpec } from './data-spec'
+
+export class DataSpecManager {
+  static specRegistry: { [type: string]: DataSpec } = {}
+
+  static getDataSpec(type: string): DataSpec {
+    return DataSpecManager.specRegistry[type]
+  }
+
+  static registerDataSpec(type: string, dataSpec: DataSpec) {
+    DataSpecManager.specRegistry[type] = dataSpec
+  }
+
+  static unregisterDataSpec(type: string) {
+    delete DataSpecManager.specRegistry[type]
+  }
+
+  static getDataSpecs(): DataSpec[] {
+    return Object.values(DataSpecManager.specRegistry)
+  }
+}

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

@@ -0,0 +1,21 @@
+import { Resolver, Query, Arg } from 'type-graphql'
+import { DataSpec, DataSpecList } from './data-spec'
+import { DataSpecManager } from './data-spec-manager'
+
+@Resolver(DataSpec)
+export class DataSpecQuery {
+  @Query(returns => DataSpec, { description: 'To fetch a data-spec' })
+  dataSpec(@Arg('name') name: string): DataSpec {
+    return DataSpecManager.getDataSpec(name)
+  }
+
+  @Query(returns => DataSpecList, { description: 'To fetch all data-specs' })
+  dataSpecs(): DataSpecList {
+    const items = DataSpecManager.getDataSpecs()
+
+    return {
+      items,
+      total: items.length
+    }
+  }
+}

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

@@ -0,0 +1,44 @@
+import { ObjectType, Field, Int } from 'type-graphql'
+import { ScalarObject } from '@things-factory/shell'
+
+@ObjectType()
+export class DataSpecItem {
+  @Field()
+  type: string
+
+  @Field()
+  label: string
+
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  placeholder?: string
+
+  @Field(type => ScalarObject, { nullable: true })
+  property?: ScalarObject
+}
+
+@ObjectType()
+export class DataSpec {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  help: string
+
+  @Field(type => [DataSpecItem], { nullable: true })
+  specItems: DataSpecItem[]
+}
+
+@ObjectType()
+export class DataSpecList {
+  @Field(type => [DataSpec])
+  items: DataSpec[]
+
+  @Field(type => Int)
+  total: number
+}

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

@@ -0,0 +1,5 @@
+import { DataSpec } from './data-spec'
+import { DataSpecQuery } from './data-spec-query'
+
+export const entities = [DataSpec]
+export const resolvers = [DataSpecQuery]

package/server/service/index.ts

@@ -1,25 +1,33 @@
 /* IMPORT ENTITIES AND RESOLVERS */
+import { entities as DataSensorEntities, resolvers as DataSensorResolvers } from './data-sensor'
 import { entities as DataSampleEntities, resolvers as DataSampleResolvers } from './data-sample'
 import { entities as DataItemEntities, resolvers as DataItemResolvers } from './data-item'
 import { entities as DataSetEntities, resolvers as DataSetResolvers } from './data-set'
+import { entities as DataSpecEntities, resolvers as DataSpecResolvers } from './data-spec'
 
 /* EXPORT ENTITY TYPES */
+export * from './data-sensor/data-sensor'
 export * from './data-sample/data-sample'
 export * from './data-item/data-item'
 export * from './data-set/data-set'
+export * from './data-spec/data-spec'
 
 export const entities = [
   /* ENTITIES */
-	...DataSampleEntities,
+  ...DataSensorEntities,
+  ...DataSampleEntities,
   ...DataItemEntities,
-  ...DataSetEntities
+  ...DataSetEntities,
+  ...DataSpecEntities
 ]
 
 export const schema = {
   resolverClasses: [
     /* RESOLVER CLASSES */
-		...DataSampleResolvers,
+    ...DataSensorResolvers,
+    ...DataSampleResolvers,
     ...DataItemResolvers,
-    ...DataSetResolvers
+    ...DataSetResolvers,
+    ...DataSpecResolvers
   ]
 }

package/things-factory.config.js

@@ -8,6 +8,10 @@ export default {
       tagname: 'data-set-page',
       page: 'data-set'
     },
+    {
+      tagname: 'data-sensor-page',
+      page: 'data-sensor'
+    },
     {
       tagname: 'data-sample-page',
       page: 'data-sample'

package/translations/en.json

@@ -1,8 +1,22 @@
 {
-  "field.quota": "quota",
-  "field.spec": "spec",
+  "field.appliance": "appliance",
+  "field.collected_at": "collected at",
   "field.data": "data",
+  "field.dataSet": "data set",
+  "field.device-id": "device id",
+  "field.netmask": "network mask",
+  "field.options": "options",
+  "field.partitionKeys": "partition keys",
+  "field.quota": "sampling #",
+  "field.raw-data": "raw data",
+  "field.ref-by": "ref. by",
+  "field.serial-no": "serial #",
+  "field.spec": "spec",
+  "field.tag": "tag name",
+  "field.unit": "unit",
+  "title.data-entry-form": "data entry form",
   "title.data-item list": "data item list",
-  "title.data-set list": "data set list",
-  "title.data-sample list": "data sample list"
+  "title.data-sample list": "data sample list",
+  "title.data-sensor list": "data sensor list",
+  "title.data-set list": "data set list"
 }

package/translations/ko.json

@@ -1,8 +1,22 @@
 {
+  "field.appliance": "어플라이언스",
+  "field.collected_at": "수집일시",
+  "field.data": "데이타",
+  "field.dataSet": "데이타셋",
+  "field.device-id": "디바이스 아이디",
+  "field.netmask": "네트워크마스크",
+  "field.options": "선택옵션",
+  "field.partitionKeys": "파티션 키",
   "field.quota": "샘플수",
+  "field.raw-data": "데이타 원본",
+  "field.ref-by": "참조아이템",
+  "field.serial-no": "시리얼번호",
   "field.spec": "명세",
-  "field.data": "데이타",
+  "field.tag": "태그이름",
+  "field.unit": "단위",
+  "title.data-entry-form": "데이타 입력",
   "title.data-item list": "데이타 아이템 조회",
-  "title.data-set list": "데이타 셋 조회",
-  "title.data-sample list": "데이타 샘플 조회"
+  "title.data-sample list": "데이타 샘플 조회",
+  "title.data-sensor list": "데이타 센서 조회",
+  "title.data-set list": "데이타 셋 조회"
 }