@things-factory/dataset 5.0.0 → 5.0.3

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

@@ -0,0 +1,65 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository } from 'typeorm'
+
+import { Attachment } from '@things-factory/attachment-base'
+import { User } from '@things-factory/auth-base'
+import { Domain, getQueryBuilderFromListParams, ListParam } from '@things-factory/shell'
+
+import { DataKeySet } from './data-key-set'
+import { DataKeySetList } from './data-key-set-type'
+
+@Resolver(DataKeySet)
+export class DataKeySetQuery {
+  @Query(returns => DataKeySet!, { nullable: true, description: 'To fetch a DataKeySet' })
+  async dataKeySet(@Arg('id') id: string, @Ctx() context: any): Promise<DataKeySet> {
+    const { domain } = context.state
+
+    return await getRepository(DataKeySet).findOne({
+      where: { domain, id }
+    })
+  }
+
+  @Query(returns => DataKeySetList, { description: 'To fetch multiple DataKeySets' })
+  async dataKeySets(@Args() params: ListParam, @Ctx() context: any): Promise<DataKeySetList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(DataKeySet),
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => String)
+  async thumbnail(@Root() dataKeySet: DataKeySet): Promise<string | undefined> {
+    const attachment: Attachment = await getRepository(Attachment).findOne({
+      where: {
+        domain: dataKeySet.domainId,
+        refType: DataKeySet.name,
+        refBy: dataKeySet.id
+      }
+    })
+
+    return attachment?.fullpath
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() dataKeySet: DataKeySet): Promise<Domain> {
+    return await getRepository(Domain).findOne(dataKeySet.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() dataKeySet: DataKeySet): Promise<User> {
+    return await getRepository(User).findOne(dataKeySet.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() dataKeySet: DataKeySet): Promise<User> {
+    return await getRepository(User).findOne(dataKeySet.creatorId)
+  }
+}

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

@@ -0,0 +1,57 @@
+import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
+import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+
+import { DataKeyItemPatch } from './data-key-item-type'
+import { DataKeySet } from './data-key-set'
+
+@InputType()
+export class NewDataKeySet {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field(type => [DataKeyItemPatch], { nullable: true })
+  dataKeyItems?: DataKeyItemPatch[]
+
+  @Field(type => GraphQLUpload, { nullable: true })
+  thumbnail?: FileUpload
+}
+
+@InputType()
+export class DataKeySetPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field(type => [DataKeyItemPatch], { nullable: true })
+  dataKeyItems?: DataKeyItemPatch[]
+
+  @Field(type => GraphQLUpload, { nullable: true })
+  thumbnail?: FileUpload
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class DataKeySetList {
+  @Field(type => [DataKeySet])
+  items: DataKeySet[]
+
+  @Field(type => Int)
+  total: number
+}

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

@@ -0,0 +1,81 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { DataKeyItem } from './data-key-item-type'
+
+@Entity()
+@Index('ix_data_key_set_0', (dataKeySet: DataKeySet) => [dataKeySet.domain, dataKeySet.name], { unique: true })
+@ObjectType({ description: 'Entity for DataKeySet' })
+export class DataKeySet {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((dataKeySet: DataKeySet) => dataKeySet.domain)
+  domainId?: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  description?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Column('simple-json', { nullable: true })
+  @Field(type => [DataKeyItem], { nullable: true })
+  dataKeyItems: DataKeyItem[]
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((dataKeySet: DataKeySet) => dataKeySet.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((dataKeySet: DataKeySet) => dataKeySet.creator)
+  updaterId?: string
+
+  @Field(type => String, { nullable: true })
+  thumbnail?: string
+}

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

@@ -0,0 +1,6 @@
+import { DataKeySet } from './data-key-set'
+import { DataKeySetQuery } from './data-key-set-query'
+import { DataKeySetMutation } from './data-key-set-mutation'
+
+export const entities = [DataKeySet]
+export const resolvers = [DataKeySetQuery, DataKeySetMutation]

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

@@ -109,6 +109,26 @@ export class DataOoc {
   @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?: ScalarObject

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

@@ -4,6 +4,7 @@ import { getRepository } from 'typeorm'
 import { User } from '@things-factory/auth-base'
 import { Domain, getQueryBuilderFromListParams, ListParam } from '@things-factory/shell'
 
+import { DataKeySet } from '../data-key-set/data-key-set'
 import { DataSetHistory } from '../data-set-history/data-set-history'
 import { DataItem } from '../data-set/data-item-type'
 import { DataSet } from '../data-set/data-set'
@@ -39,6 +40,32 @@ export class DataSampleQuery {
     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() params: ListParam,
+    @Ctx() context: any
+  ): Promise<DataSampleList> {
+    const { domain } = context.state
+
+    const dataKeySet = await getRepository(DataKeySet).findOne(dataKeySetId)
+    const dataKeyItems = dataKeySet?.dataKeyItems || []
+    const searchables = dataKeyItems.map((item, index) => `key0${index + 1}`)
+
+    /* TODO DataKeySet 과 관련된 DataSample만 조회되도록 할 것. */
+    const queryBuilder = getQueryBuilderFromListParams({
+      repository: getRepository(DataSample),
+      params,
+      domain,
+      searchables: ['name', 'description'].concat(searchables)
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
   @FieldResolver(type => [DataItem])
   async dataItems(@Root() dataSample: DataSample): Promise<DataItem[]> {
     const dataSetHistory: DataSetHistory = await getRepository(DataSetHistory).findOne({

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

@@ -25,6 +25,19 @@ const DATABASE_TYPE = ORMCONFIG.type
   (dataSample: DataSample) => [dataSample.domain, dataSample.dataSet, dataSample.collectedAt],
   { unique: false }
 )
+@Index(
+  'ix_data_sample_1',
+  (dataSample: DataSample) => [
+    dataSample.domain,
+    dataSample.key01,
+    dataSample.key02,
+    dataSample.key03,
+    dataSample.key04,
+    dataSample.key05,
+    dataSample.collectedAt
+  ],
+  { unique: false }
+)
 @ObjectType({ description: 'Entity for DataSample' })
 export class DataSample {
   @PrimaryGeneratedColumn('uuid')
@@ -116,6 +129,26 @@ export class DataSample {
   @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

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

@@ -12,7 +12,7 @@ export enum DataItemType {
 
 registerEnumType(DataItemType, {
   name: 'DataItemType',
-  description: 'state enumeration of a data-item'
+  description: 'type enumeration of a data-item'
 })
 
 @ObjectType({ description: 'Entity for DataItem' })

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

@@ -25,7 +25,7 @@ export class DataSetMutation {
       updater: user
     })
 
-    await this._createAttachment(context, dataSet.reportTemplate, { refId: result.id, cuFlag: '+' })
+    await this._createAttachment(context, dataSet.reportTemplate, { ref: result, cuFlag: '+' })
 
     return result
   }
@@ -47,7 +47,7 @@ export class DataSetMutation {
       updater: user
     })
 
-    await this._createAttachment(context, dataSet.reportTemplate, { refId: result.id, cuFlag: 'M' })
+    await this._createAttachment(context, dataSet.reportTemplate, { ref: result, cuFlag: 'M' })
 
     return result
   }
@@ -78,7 +78,7 @@ export class DataSetMutation {
           updater: user
         })
 
-        await this._createAttachment(context, newRecord.reportTemplate, { refId: result.id, cuFlag })
+        await this._createAttachment(context, newRecord.reportTemplate, { ref: result, cuFlag })
 
         results.push({
           ...(await dataSetRepo.findOne(result.id, {
@@ -101,7 +101,7 @@ export class DataSetMutation {
           updater: user
         })
 
-        await this._createAttachment(context, newRecord.reportTemplate, { refId: result.id, cuFlag })
+        await this._createAttachment(context, newRecord.reportTemplate, { ref: result, cuFlag })
 
         results.push({
           ...(await dataSetRepo.findOne(result.id, {
@@ -202,16 +202,16 @@ export class DataSetMutation {
     return copiedDataSets
   }
 
-  async _createAttachment(context, attachment, { refId, cuFlag }) {
+  async _createAttachment(context, attachment, { ref, cuFlag }) {
     if (attachment) {
-      const attachmentRef = 'report-' + refId
-      cuFlag == 'M' && (await deleteAttachmentsByRef(null, { refBys: [attachmentRef] }, context))
+      cuFlag == 'M' && (await deleteAttachmentsByRef(null, { refBys: [ref.id] }, context))
       await createAttachment(
         null,
         {
           attachment: {
             file: attachment,
-            refBy: attachmentRef
+            refType: `${DataSet.name}-report-template`,
+            refBy: ref.id
           }
         },
         context

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

@@ -7,6 +7,7 @@ import { Board } from '@things-factory/board-service'
 import { Domain, getQueryBuilderFromListParams, ListParam } from '@things-factory/shell'
 
 import { DataItem } from '../data-item/data-item'
+import { DataKeySet } from '../data-key-set/data-key-set'
 import { DataSample } from '../data-sample/data-sample'
 import { DataSet } from './data-set'
 import { DataSetList } from './data-set-type'
@@ -147,6 +148,16 @@ export class DataSetQuery {
     }
   }
 
+  @FieldResolver(type => DataKeySet, { nullable: true })
+  async dataKeySet(@Root() dataSet: DataSet) {
+    return (
+      dataSet.dataKeySet ||
+      (await getRepository(DataKeySet).findOne({
+        id: dataSet.dataKeySetId
+      }))
+    )
+  }
+
   @FieldResolver(type => Domain)
   async domain(@Root() dataSet: DataSet): Promise<Domain> {
     return await getRepository(Domain).findOne(dataSet.domainId)
@@ -208,7 +219,8 @@ export class DataSetQuery {
     const attachment: Attachment = await getRepository(Attachment).findOne({
       where: {
         domain: dataset.domainId,
-        refBy: `report-${dataset.id}`
+        refType: `${DataSet.name}-report-template`,
+        refBy: dataset.id
       }
     })
 

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

@@ -15,6 +15,9 @@ export class NewDataSet {
   @Field({ nullable: true })
   description?: string
 
+  @Field(type => ObjectRef, { nullable: true })
+  dataKeySet?: ObjectRef
+
   @Field(type => ObjectRef, { nullable: true })
   entryRole?: ObjectRef
 
@@ -75,6 +78,9 @@ export class DataSetPatch {
   @Field({ nullable: true })
   description?: string
 
+  @Field(type => ObjectRef, { nullable: true })
+  dataKeySet?: ObjectRef
+
   @Field(type => ObjectRef, { nullable: true })
   supervisoryRole?: ObjectRef
 

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

@@ -14,6 +14,7 @@ import {
 import { Role, User } from '@things-factory/auth-base'
 import { Domain, ScalarObject } from '@things-factory/shell'
 
+import { DataKeySet } from '../data-key-set/data-key-set'
 import { DataItem } from './data-item-type'
 
 export enum DataSetEntryType {
@@ -71,9 +72,7 @@ export class DataSet {
   @Field()
   name: string
 
-  @Column({
-    nullable: true
-  })
+  @Column({ nullable: true })
   @Field({ nullable: true })
   description?: string
 
@@ -81,78 +80,63 @@ export class DataSet {
   @Field({ nullable: true })
   version?: number = 1
 
-  @Column({
-    nullable: true
-  })
+  @Column({ nullable: true })
   @Field({ nullable: true })
   active?: boolean
 
-  @ManyToOne(type => Role, {
-    nullable: true
-  })
+  @ManyToOne(type => DataKeySet, { nullable: true })
+  @Field(type => DataKeySet, { nullable: true })
+  dataKeySet?: Role
+
+  @RelationId((dataSet: DataSet) => dataSet.dataKeySet)
+  dataKeySetId?: string
+
+  @ManyToOne(type => Role, { nullable: true })
   @Field(type => Role, { nullable: true })
   entryRole?: Role
 
   @RelationId((dataSet: DataSet) => dataSet.entryRole)
   entryRoleId?: string
 
-  @ManyToOne(type => Role, {
-    nullable: true
-  })
+  @ManyToOne(type => Role, { nullable: true })
   @Field(type => Role, { nullable: true })
   supervisoryRole?: Role
 
   @RelationId((dataSet: DataSet) => dataSet.supervisoryRole)
   supervisoryRoleId?: string
 
-  @Column({
-    nullable: true
-  })
+  @Column({ nullable: true })
   @Field({ nullable: true })
   type?: 'manual' | 'automatic' | string
 
-  @Column({
-    nullable: true
-  })
+  @Column({ nullable: true })
   @Field({ nullable: true })
   entryType?: DataSetEntryType
 
-  @Column({
-    nullable: true
-  })
+  @Column({ nullable: true })
   @Field({ nullable: true })
   entryView?: string
 
-  @Column({
-    nullable: true
-  })
+  @Column({ nullable: true })
   @Field({ nullable: true })
   monitorType?: DataSetMonitorType
 
-  @Column({
-    nullable: true
-  })
+  @Column({ nullable: true })
   @Field({ nullable: true })
   monitorView?: string
 
-  @Column({
-    nullable: true
-  })
+  @Column({ nullable: true })
   @Field({ nullable: true })
   reportType?: DataSetReportType
 
-  @Column({
-    nullable: true
-  })
+  @Column({ nullable: true })
   @Field({ nullable: true })
   reportView?: string
 
   @Field({ nullable: true })
   reportTemplate?: string
 
-  @Column({
-    nullable: true
-  })
+  @Column({ nullable: true })
   @Field({ nullable: true })
   useCase?: string
 
@@ -164,15 +148,11 @@ export class DataSet {
   @Field(type => [DataItem], { nullable: true })
   dataItems: DataItem[]
 
-  @Column({
-    nullable: true
-  })
+  @Column({ nullable: true })
   @Field({ nullable: true })
   schedule?: string
 
-  @Column({
-    nullable: true
-  })
+  @Column({ nullable: true })
   @Field({ nullable: true })
   timezone?: string
 
@@ -184,18 +164,14 @@ export class DataSet {
   @Field({ nullable: true })
   updatedAt?: Date
 
-  @ManyToOne(type => User, {
-    nullable: true
-  })
+  @ManyToOne(type => User, { nullable: true })
   @Field({ nullable: true })
   creator?: User
 
   @RelationId((dataSet: DataSet) => dataSet.creator)
   creatorId?: string
 
-  @ManyToOne(type => User, {
-    nullable: true
-  })
+  @ManyToOne(type => User, { nullable: true })
   @Field({ nullable: true })
   updater?: User
 

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

@@ -6,6 +6,7 @@ import { Role, User } from '@things-factory/auth-base'
 import { Board } from '@things-factory/board-service'
 import { Domain, getQueryBuilderFromListParams, ListParam, ScalarDate } from '@things-factory/shell'
 
+import { DataSet } from '../data-set/data-set'
 import { DataSetHistory } from './data-set-history'
 import { DataSetHistoryList } from './data-set-history-type'
 
@@ -101,7 +102,8 @@ export class DataSetHistoryQuery {
     const attachment: Attachment = await getRepository(Attachment).findOne({
       where: {
         domain: dataSetHistory.domainId,
-        refBy: `report-${dataSetHistory.originalId}`
+        refType: `${DataSet.name}-report-template`,
+        refBy: dataSetHistory.originalId
       }
     })
 

package/server/service/index.ts

@@ -1,5 +1,5 @@
 import { entities as DataItemEntities } from './data-item'
-/* IMPORT ENTITIES AND RESOLVERS */
+import { entities as DataKeySetEntities, resolvers as DataKeySetResolvers } from './data-key-set'
 import { entities as DataOocEntities, resolvers as DataOocResolvers } from './data-ooc'
 import { entities as DataSampleEntities, resolvers as DataSampleResolvers } from './data-sample'
 import { entities as DataSensorEntities, resolvers as DataSensorResolvers } from './data-sensor'
@@ -12,6 +12,7 @@ import {
 import { entities as DataSpecEntities, resolvers as DataSpecResolvers } from './data-spec'
 
 /* EXPORT ENTITY TYPES */
+export * from './data-key-set/data-key-set'
 export * from './data-ooc/data-ooc'
 export * from './data-sensor/data-sensor'
 export * from './data-sample/data-sample'
@@ -22,6 +23,7 @@ export * from './data-spec/data-spec'
 
 export const entities = [
   /* ENTITIES */
+  ...DataKeySetEntities,
   ...DataItemEntities,
   ...DataOocEntities,
   ...DataSensorEntities,
@@ -39,6 +41,7 @@ export const subscribers = [
 export const schema = {
   resolverClasses: [
     /* RESOLVER CLASSES */
+    ...DataKeySetResolvers,
     ...DataOocResolvers,
     ...DataSensorResolvers,
     ...DataSampleResolvers,

package/things-factory.config.js

@@ -16,6 +16,10 @@ export default {
       tagname: 'data-sample-list-page',
       page: 'data-sample-list'
     },
+    {
+      tagname: 'data-sample-search-page',
+      page: 'data-sample-search'
+    },
     {
       tagname: 'data-ooc-list-page',
       page: 'data-ooc-list'
@@ -44,6 +48,10 @@ export default {
       tagname: 'data-report-embed-page',
       page: 'data-report-embed'
     },
+    {
+      tagname: 'data-key-set-list-page',
+      page: 'data-key-set-list'
+    }
   ],
   bootstrap
 }