@things-factory/dataset 5.0.0-zeta.9 → 5.0.2

package/server/controllers/jasper-report.ts

@@ -6,47 +6,53 @@ import { AthenaController } from '@things-factory/aws-base'
 import { config } from '@things-factory/env'
 
 const dataReportConfig = config.get('dataReport')
-const { jasper: { 
-  endpoint: { protocol: PROTOCOL, host:HOST, port:PORT }, 
-  datasource: { database: DATABASE } } 
-} = dataReportConfig
+const {
+  jasper: {
+    endpoint: { protocol: PROTOCOL, host: HOST, port: PORT },
+    datasource: { database: DATABASE }
+  }
+} = dataReportConfig || {
+  jasper: {
+    endpoint: {},
+    datasource: {}
+  }
+}
 
-/** author: ywnam123 */
 function transformValuesToRows(queryResult) {
   var parseData = []
-    let index = 1
-    for (let i = 0; i < queryResult.Items.length; i++) {
-      var j = 0
-      const data = JSON.parse(queryResult.Items[i].data)
-      const spec = JSON.parse(queryResult.Items[i].spec)
-
-      for (let key in data) {
-        if (Array.isArray(data[key])) {
-          for (j = 0; j < data[key].length; j++) {
-            for (let specKey in spec) {
-              if (key === specKey) {
-                parseData.push({
-                  item: spec[specKey].name,
-                  index: index + j,
-                  value: String(data[key][j])
-                })
-              }
+  let index = 1
+  for (let i = 0; i < queryResult.Items.length; i++) {
+    var j = 0
+    const data = JSON.parse(queryResult.Items[i].data)
+    const spec = JSON.parse(queryResult.Items[i].spec)
+
+    for (let key in data) {
+      if (Array.isArray(data[key])) {
+        for (j = 0; j < data[key].length; j++) {
+          for (let specKey in spec) {
+            if (key === specKey) {
+              parseData.push({
+                item: spec[specKey].name,
+                index: index + j,
+                value: String(data[key][j])
+              })
             }
           }
-        } else {
-          parseData.push({
-            item: key,
-            index,
-            value: String(data[key])
-          })
         }
-      }
-      if (j !== 0) {
-        index = index + j
       } else {
-        index = index + 1
+        parseData.push({
+          item: key,
+          index,
+          value: String(data[key])
+        })
       }
     }
+    if (j !== 0) {
+      index = index + j
+    } else {
+      index = index + 1
+    }
+  }
 }
 
 /** @todo considering trasformation in lambda, as massive dataset */
@@ -61,11 +67,12 @@ function pivotData(rows) {
     for (let key in data) {
       /** @todo rule to display or not, about unspecified spec */
       const value = data[key]
-      !(spec[key]?.hidden) && parsedData.push({
-        item: spec[key]?.name || key,
-        index,
-        value: Array.isArray(value) ? value.join(', ') : value
-      })
+      !spec[key]?.hidden &&
+        parsedData.push({
+          item: spec[key]?.name || key,
+          index,
+          value: Array.isArray(value) ? value.join(', ') : value
+        })
     }
     if (j !== 0) {
       index = index + j
@@ -95,6 +102,7 @@ function parseJsonDataField(rows) {
 }
 
 const athenaClient = new AthenaController()
+
 async function queryAthena(params) {
   const { table, domain, dataSetId, fromWorkDate, toWorkDate, workShift, timezone } = params
   const queryData = {
@@ -108,7 +116,7 @@ async function queryAthena(params) {
     AND datasetid = '${dataSetId}'
     AND workdate >= '${fromWorkDate}'
     AND workdate <= '${toWorkDate}'
-    ${workShift ? 'AND workshift = \'' + workShift + '\'' : ''}
+    ${workShift ? "AND workshift = '" + workShift + "'" : ''}
     ORDER BY collected_at`,
     db: DATABASE
   }
@@ -116,19 +124,23 @@ async function queryAthena(params) {
 
   return await athenaClient.query(queryData)
 }
-export async function renderJasperReport(context: any) { 
-  const { state: { domain }, query } = context
+
+export async function renderJasperReport(context: any) {
+  const {
+    state: { domain },
+    query
+  } = context
 
   const template = await STORAGE.readFile(query['template'] || 'dynamic_header_sample.jrxml', 'utf-8')
   let templateType = query['templateType'] || 'crosstab'
   let parsedData = []
 
   // @todo: get dataset timezone
-  /**  
+  /**
    * const variables = await gql(dataSet(id:${dataSetId}) {
    *  name, description, partition_keys, timezone
    * })
-  */
+   */
 
   query['domain'] = domain?.subdomain
   query['timezone'] = domain?.timezone
@@ -137,8 +149,7 @@ export async function renderJasperReport(context: any) {
 
   if (!rows.length) {
     return '<h3>Not found result.</h3>'
-  }
-  else {
+  } else {
     const firstRow = rows[0]
     // uses the first row values as data-set has no history data.
     const parameters = {
@@ -146,18 +157,18 @@ export async function renderJasperReport(context: any) {
       description: firstRow.description,
       ...query
     }
-  
+
     if (templateType === 'crosstab') {
       parsedData = pivotData(rows)
     } else {
       parsedData = parseJsonDataField(rows)
     }
-  
+
     const formData = new FormData()
     formData.append('template', template)
     formData.append('jsonString', JSON.stringify(parsedData))
     formData.append('parameters', JSON.stringify(parameters))
-  
+
     const reportUrl = `${PROTOCOL || 'http'}://${HOST}:${PORT}/rest/report/show_html`
     const response = await fetch(reportUrl, {
       method: 'POST',
@@ -166,5 +177,4 @@ export async function renderJasperReport(context: any) {
 
     return await response.text()
   }
-
 }

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

@@ -4,7 +4,6 @@ import { getRepository } from 'typeorm'
 import { User } from '@things-factory/auth-base'
 import { Domain, getQueryBuilderFromListParams, ListParam } from '@things-factory/shell'
 
-import { DataSample } from '../data-sample/data-sample'
 import { DataSetHistory } from '../data-set-history/data-set-history'
 import { DataItem } from '../data-set/data-item-type'
 import { DataSet } from '../data-set/data-set'
@@ -41,14 +40,14 @@ export class DataOocQuery {
   }
 
   @FieldResolver(type => [DataItem])
-  async spec(@Root() dataOoc: DataOoc): Promise<[DataItem]> {
+  async dataItems(@Root() dataOoc: DataOoc): Promise<DataItem[]> {
     const dataSetHistory: DataSetHistory = await getRepository(DataSetHistory).findOne({
       where: {
-        id: dataOoc.dataSetId,
+        originalId: dataOoc.dataSetId,
         version: dataOoc.dataSetVersion
       }
     })
-    return dataSetHistory?.dataItems || dataOoc.spec || []
+    return dataSetHistory?.dataItems || []
   }
 
   @FieldResolver(type => DataSet)
@@ -58,13 +57,6 @@ export class DataOocQuery {
     })
   }
 
-  @FieldResolver(type => DataSample)
-  async dataSample(@Root() dataOoc: DataOoc): Promise<DataSample> {
-    return await getRepository(DataSample).findOne({
-      id: dataOoc.dataSampleId
-    })
-  }
-
   @FieldResolver(type => Domain)
   async domain(@Root() dataOoc: DataOoc): Promise<Domain> {
     return await getRepository(Domain).findOne(dataOoc.domainId)

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

@@ -4,9 +4,7 @@ import {
   CreateDateColumn,
   Entity,
   Index,
-  JoinColumn,
   ManyToOne,
-  OneToOne,
   PrimaryGeneratedColumn,
   RelationId,
   UpdateDateColumn
@@ -16,7 +14,7 @@ import { User } from '@things-factory/auth-base'
 import { config } from '@things-factory/env'
 import { Domain, ScalarObject } from '@things-factory/shell'
 
-import { DataSample } from '../data-sample/data-sample'
+import { DataItem } from '../data-set/data-item-type'
 import { DataSet } from '../data-set/data-set'
 
 const ORMCONFIG = config.get('ormconfig', {})
@@ -34,9 +32,7 @@ registerEnumType(DataOocStatus, {
 })
 
 @Entity()
-@Index('ix_data_ooc_0', (dataOoc: DataOoc) => [dataOoc.domain, dataOoc.dataSet], { unique: false })
-@Index('ix_data_ooc_1', (dataOoc: DataOoc) => [dataOoc.domain, dataOoc.dataSample], { unique: true })
-@Index('ix_data_ooc_2', (dataOoc: DataOoc) => [dataOoc.domain, dataOoc.collectedAt], { unique: false })
+@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')
@@ -71,14 +67,6 @@ export class DataOoc {
   @Field({ nullable: true })
   dataSetVersion?: number
 
-  @OneToOne(type => DataSample)
-  @JoinColumn()
-  @Field(type => DataSample, { nullable: true })
-  dataSample?: DataSample
-
-  @RelationId((dataOoc: DataOoc) => dataOoc.dataSample)
-  dataSampleId?: string
-
   @Column({
     nullable: true
   })
@@ -129,10 +117,12 @@ export class DataOoc {
   @Field(type => ScalarObject, { nullable: true })
   data?: ScalarObject
 
-  // TODO spec should be removed
   @Column('simple-json', { nullable: true })
   @Field(type => ScalarObject, { nullable: true })
-  spec?: ScalarObject
+  judgment?: ScalarObject
+
+  @Field(type => [DataItem], { nullable: true })
+  dataItems?: DataItem[]
 
   @Column('simple-json', { nullable: true })
   @Field(type => ScalarObject, { nullable: true })

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

@@ -40,14 +40,14 @@ export class DataSampleQuery {
   }
 
   @FieldResolver(type => [DataItem])
-  async spec(@Root() dataSample: DataSample): Promise<[DataItem]> {
+  async dataItems(@Root() dataSample: DataSample): Promise<DataItem[]> {
     const dataSetHistory: DataSetHistory = await getRepository(DataSetHistory).findOne({
       where: {
-        id: dataSample.dataSetId,
+        originalId: dataSample.dataSetId,
         version: dataSample.dataSetVersion
       }
     })
-    return dataSetHistory?.dataItems || dataSample.spec || []
+    return dataSetHistory?.dataItems || []
   }
 
   @FieldResolver(type => DataSet)

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

@@ -14,14 +14,14 @@ import { User } from '@things-factory/auth-base'
 import { config } from '@things-factory/env'
 import { Domain, ScalarObject } from '@things-factory/shell'
 
+import { DataItem } from '../data-set/data-item-type'
 import { DataSet } from '../data-set/data-set'
 
 const ORMCONFIG = config.get('ormconfig', {})
 const DATABASE_TYPE = ORMCONFIG.type
 @Entity()
-@Index('ix_data_sample_0', (dataSample: DataSample) => [dataSample.domain, dataSample.dataSet], { unique: false })
 @Index(
-  'ix_data_sample_2',
+  'ix_data_sample_0',
   (dataSample: DataSample) => [dataSample.domain, dataSample.dataSet, dataSample.collectedAt],
   { unique: false }
 )
@@ -79,10 +79,12 @@ export class DataSample {
   @Field(type => ScalarObject, { nullable: true })
   data?: ScalarObject
 
-  // TODO spec should be removed
   @Column('simple-json', { nullable: true })
   @Field(type => ScalarObject, { nullable: true })
-  spec?: ScalarObject
+  judgment?: ScalarObject
+
+  @Field(type => [DataItem], { nullable: true })
+  dataItems?: DataItem[]
 
   @Column({
     nullable: true,

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

@@ -3,7 +3,6 @@ import { In } from 'typeorm'
 
 import { createAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
 
-import { DataSetHistory } from '../data-set-history/data-set-history'
 import { DataSet } from './data-set'
 import { DataSetPatch, NewDataSet } from './data-set-type'
 
@@ -17,7 +16,6 @@ export class DataSetMutation {
   async createDataSet(@Arg('dataSet') dataSet: NewDataSet, @Ctx() context: any): Promise<DataSet> {
     const { domain, user, tx } = context.state
     const dataSetRepo = tx.getRepository(DataSet)
-    const dataSetHistoryRepo = tx.getRepository(DataSetHistory)
 
     const result = await dataSetRepo.save({
       ...dataSet,
@@ -27,13 +25,7 @@ export class DataSetMutation {
       updater: user
     })
 
-    await this._createAttachment(context, dataSet.reportTemplate, { refId: result.id, cuFlag: '+' })
-
-    await dataSetHistoryRepo.save(
-      await dataSetRepo.findOne(result.id, {
-        relations: ['domain', 'creator', 'updater', 'supervisoryRole', 'entryRole']
-      })
-    )
+    await this._createAttachment(context, dataSet.reportTemplate, { ref: result, cuFlag: '+' })
 
     return result
   }
@@ -44,7 +36,6 @@ export class DataSetMutation {
   async updateDataSet(@Arg('id') id: string, @Arg('patch') patch: DataSetPatch, @Ctx() context: any): Promise<DataSet> {
     const { domain, user, tx } = context.state
     const dataSetRepo = tx.getRepository(DataSet)
-    const dataSetHistoryRepo = tx.getRepository(DataSetHistory)
 
     const dataSet = await dataSetRepo.findOne({
       where: { domain, id }
@@ -53,17 +44,10 @@ export class DataSetMutation {
     const result = await dataSetRepo.save({
       ...dataSet,
       ...patch,
-      version: (dataSet.version || 0) + 1,
       updater: user
     })
 
-    await this._createAttachment(context, dataSet.reportTemplate, { refId: result.id, cuFlag: 'M' })
-
-    await dataSetHistoryRepo.save(
-      await dataSetRepo.findOne(id, {
-        relations: ['domain', 'creator', 'updater', 'supervisoryRole', 'entryRole']
-      })
-    )
+    await this._createAttachment(context, dataSet.reportTemplate, { ref: result, cuFlag: 'M' })
 
     return result
   }
@@ -77,7 +61,6 @@ export class DataSetMutation {
   ): Promise<DataSet[]> {
     const { domain, user, tx } = context.state
     const dataSetRepo = tx.getRepository(DataSet)
-    const dataSetHistoryRepo = tx.getRepository(DataSetHistory)
 
     let results = []
     const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
@@ -90,13 +73,12 @@ export class DataSetMutation {
 
         const result = await dataSetRepo.save({
           ...newRecord,
-          version: 1,
           domain,
           creator: user,
           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, {
@@ -116,11 +98,10 @@ export class DataSetMutation {
         const result = await dataSetRepo.save({
           ...dataSet,
           ...newRecord,
-          version: (dataSet.version || 0) + 1,
           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, {
@@ -131,8 +112,6 @@ export class DataSetMutation {
       }
     }
 
-    results.forEach(result => dataSetHistoryRepo.save({ ...result }))
-
     return results
   }
 
@@ -172,20 +151,13 @@ export class DataSetMutation {
   ): Promise<boolean> {
     const { domain, tx } = context.state
     const dataSetRepo = tx.getRepository(DataSet)
-    const dataSetHistoryRepo = tx.getRepository(DataSetHistory)
 
     await Promise.all(
       dataSets.map(async (dataSet: DataSet) => {
         const createdDataSet: DataSet = await dataSetRepo.save({
           domain,
-          version: 1 /* overridable by dataSet's origin value */,
           ...dataSet
         })
-        await dataSetHistoryRepo.save(
-          ...(await dataSetRepo.findOne(createdDataSet.id, {
-            relations: ['domain', 'creator', 'updater', 'supervisoryRole', 'entryRole']
-          }))
-        )
       })
     )
 
@@ -198,7 +170,6 @@ export class DataSetMutation {
   async copyDataSets(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<DataSet[]> {
     const { domain, user, tx } = context.state
     const dataSetRepo = tx.getRepository(DataSet)
-    const dataSetHistoryRepo = tx.getRepository(DataSetHistory)
 
     const originals = await dataSetRepo.find({
       where: {
@@ -220,7 +191,6 @@ export class DataSetMutation {
         id: dataSetId,
         name: dataSet.name + ' (' + dataSetId + ')',
         active: false,
-        version: 1,
         domain,
         creator: user,
         updater: user
@@ -228,21 +198,20 @@ export class DataSetMutation {
     })
 
     var copiedDataSets = await dataSetRepo.save(newCopys)
-    await dataSetHistoryRepo.save(copiedDataSets)
 
     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

@@ -103,7 +103,7 @@ export class DataSetQuery {
 
   @FieldResolver(type => [DataItem])
   async dataItems(@Root() dataSet: DataSet): Promise<DataItem[]> {
-    /* TODO This fieldResolver should be removed. This is only for migration temporarily */
+    /* TODO this fieldResolver should be removed. This is only for migration temporarily */
     if (dataSet.dataItems) {
       return dataSet.dataItems as DataItem[]
     }
@@ -208,7 +208,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

@@ -1,4 +1,5 @@
-import { FileUpload, GraphQLUpload } from 'graphql-upload'
+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 { ObjectRef, ScalarObject } from '@things-factory/shell'

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

@@ -7,7 +7,8 @@ import {
   ManyToOne,
   PrimaryGeneratedColumn,
   RelationId,
-  UpdateDateColumn
+  UpdateDateColumn,
+  VersionColumn
 } from 'typeorm'
 
 import { Role, User } from '@things-factory/auth-base'
@@ -76,10 +77,7 @@ export class DataSet {
   @Field({ nullable: true })
   description?: string
 
-  @Column({
-    nullable: true,
-    default: 1
-  })
+  @VersionColumn({ nullable: true, default: 1 })
   @Field({ nullable: true })
   version?: number = 1
 

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'
 
@@ -21,7 +22,7 @@ export class DataSetHistoryQuery {
     const { domain } = context.state
 
     return await getRepository(DataSetHistory).findOne({
-      where: { domain, id, updatedAt: timestamp }
+      where: { domain, originalId: id, updatedAt: timestamp }
     })
   }
 
@@ -101,7 +102,8 @@ export class DataSetHistoryQuery {
     const attachment: Attachment = await getRepository(Attachment).findOne({
       where: {
         domain: dataSetHistory.domainId,
-        refBy: `report-${dataSetHistory.id}`
+        refType: `${DataSet.name}-report-template`,
+        refBy: dataSetHistory.originalId
       }
     })