@things-factory/dataset 6.0.77 → 6.0.79

package/helps/dataset/data-set.md

@@ -1,28 +1,43 @@
-# DataSet
+# 데이터셋 (DataSet)
+
 데이타 셋을 정의합니다.<br>
-- [`데이타 아이템 등록 및 조회`](./ui/data-key-item-list.md): 데이타 아이템 화면을 팝업으로 띄웁니다.
+
+- [`데이타 아이템 등록 및 조회`](./ui/data-item-list.md): 데이타 아이템 화면을 팝업으로 띄웁니다.
 - 데이타 입력: 데이타 입력 화면을 팝업으로 띄웁니다.
 - 이름: 데이터셋 이름을 설정합니다.<br>
 - 설명: 데이터셋에 대한 설명을 설정합니다.<br>
 - 유형: 데이터셋 유형을 설정합니다.<br>
-    - 수동 수집: 사용자가 입력하는 데이터셋인 경우 
-    - 자동 수집: 센서처럼 자동으로 입력되는 데이터셋인 경우
+  - 수동 수집: 사용자가 입력하는 데이터셋인 경우
+  - 자동 수집: 센서처럼 자동으로 입력되는 데이터셋인 경우
 - 데이타 키셋: 데이타 키셋 마스터 페이지에서 등록한 항목을 적용합니다.<br>
 - 파티션 키: (deprecated 예정)<br>
 - 스케줄: 입력 주기를 설정합니다.<br>
-- 타임존: 수집일 타임존을 설정합니다.<br>
+  - 입력 주기가 설정되면, 설정된 주기마다 입력담당 역할자에게 데이타 입력 태스크가 할당됩니다.
+- 타임존: 스케쥴이 반영될 기준 타임존을 설정합니다.<br>
 - 관리자 역할: 데이터셋 관리자 역할을 설정합니다.<br>
 - 입력담당 역할: 입력 권한을 부여할 역할을 설정합니다.<br>
 - 입력용 화면종류: 입력 화면종류를 설정합니다. 주로 Board가 사용됩니다.<br>
-    - Generated: 구현된 화면을 사용합니다.
-    - Board: Board 화면을 사용합니다.
-    - Page: 구현된 페이지로 이동합니다. suburl이 필요합니다.
-    - External URL: 외부 페이지로 이동합니다. 전체 Url이 필요합니다.
+  - Generated: 구현된 화면을 사용합니다.
+  - Board: Board 화면을 사용합니다.
+  - Page: 구현된 페이지로 이동합니다. suburl이 필요합니다.
+  - External URL: 외부 페이지로 이동합니다. 전체 Url이 필요합니다.
 - 입력용 화면: 화면 종류에 따른 값을 설정합니다. Board 화면 종류는 Board를 선택할 수 있습니다.<br>
 - 모니터용 화면종류: 모니터용 화면종류를 설정합니다. 선택 목록은 입력용 화면종류와 동일합니다.<br>
 - 모니터용 화면: 모니터용 화면종류에 해당하는 값을 설정합니다. <br>
 - 리포트용 화면종류: 리포트용 화면종류를 설정합니다. 선택 목록은 입력용 화면종류에 두 종류가 더 있습니다.
-    - Jasper: Jasper 서버 설정에 따른 jasper 페이지를 렌더링합니다.
-    - Shiny: shiny 서버 설정에 따른 shiny 페이지를 렌더링합니다.
+  - Jasper: Jasper 서버 설정에 따른 jasper 페이지를 렌더링합니다.
+  - Shiny: shiny 서버 설정에 따른 shiny 페이지를 렌더링합니다.
 - 리포트용 화면: 리포트용 화면종류에 맞는 값을 설정합니다. Jasper나 Shiny의 경우, 해당 서버에서 유효한 suburl이 필요합니다. <br>
 - 리포트용 템플릿: 리포트용 화면에 필요한 템플릿 파일을 업로드합니다.
+- 서머리 주기
+  - 서머리 주기가 설정되면, 자동으로 스케쥴러에 서머리 작업이 등록됩니다.
+  - 현재는 주별, 월별 주기 서머리는 작업의 부하를 고려해서 제공하지 않습니다.
+  - 데이터 키셋으로 그룹핑되어서 서머리 레코드가 생성됩니다.
+  - 주기
+    - hour : 매시간 서머리 작업 진행
+    - shift : 매 작업조별로 진행
+    - workdate : 매 작업일 기준
+    - daily : 매일
+- 다음 서머리 실행 일시
+  - 설정된 서머리 주기를 기준으로 다음 서머리 실행 일시를 알려줍니다.
+  - 서머리 주기는 설정되었지만, 스케쥴러에 등록되지 않았다면, 등록버튼이 보여지므로 버튼을 눌러서 등록합니다. 등록이 성공되면 다음 스케쥴이 표시됩니다.

package/helps/dataset/ui/data-item-list.md

@@ -1,19 +1,26 @@
-# DataItemList
+# 데이타 아이템 등록 및 조회 (DataItemList)
+
 데이타 셋의 아이템 목록을 등록합니다.
+
 - 이름: 데이타 셋 아이템 이름입니다.
 - 설명: 데이타 셋 아아템 설명입니다.
 - 활성화: 사용 여부를 설정합니다.
 - 숨기기: 레포트 등 2차 가공 데이터로 사용시, 사용자에게 보여줄 지 여부를 설정합니다.
 - 태그이름: 오브젝트 키를 설정합니다.
 - 유형: 데이타 셋 아이템 값의 데이타 타입 입니다.
-    - number
-    - text
-    - select
-    - boolean
-    - file
-- Options: select 유형인 경우, name과 value 쌍을 추가로 설정합니다.
+  - number
+  - text
+  - select
+  - boolean
+  - file
+- 선택옵션: select 유형인 경우, name과 value 쌍을 추가로 설정합니다.
+- 통계함수:
+  - sum, mean, stddev, variance, min, max, range, median, mode
+  - 주기적으로 기간별 데이터를 모아서 서머리 레코드를 생성할 때, 해당 아이템에 대해서 적용될 통계함수를 설정한다.
+  - 통계함수가 설정되면, 통계함수의 결과 값이 데이타 아이템 순서대로 서머리 레코드의 data{index} 컬럼에 최대 5개까지 저장된다.
 - 단위: kg, cm, 등 의 입력 단위를 설정합니다.
 - 샘플수: 해당 아이템 값을 몇 개 입력받을지 설정합니다.
 - 명세: 명세를 정의하면 이탈값이 OOC 데이터로 추가됩니다. 또한 해당 데이터샘플에 이탈여부가 기록됩니다.
-    - CCP: Critical Control Point Data Spec을 정의합니다.
-    - QC: Quality Contol Data Spec을 정의합니다.
+  - CCP: Critical Control Point Data Spec을 정의합니다.
+  - QC: Quality Contol Data Spec을 정의합니다.
+  - SPC: 아직 지원도지 않습니다.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/dataset",
-  "version": "6.0.77",
+  "version": "6.0.79",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -36,19 +36,19 @@
     "@operato/shell": "^1.0.1",
     "@operato/styles": "^1.0.0",
     "@operato/utils": "^1.0.1",
-    "@things-factory/auth-base": "^6.0.76",
-    "@things-factory/aws-base": "^6.0.76",
-    "@things-factory/board-service": "^6.0.76",
-    "@things-factory/env": "^6.0.76",
-    "@things-factory/organization": "^6.0.76",
-    "@things-factory/scheduler-client": "^6.0.76",
-    "@things-factory/shell": "^6.0.76",
-    "@things-factory/work-shift": "^6.0.76",
-    "@things-factory/worklist": "^6.0.76",
+    "@things-factory/auth-base": "^6.0.78",
+    "@things-factory/aws-base": "^6.0.78",
+    "@things-factory/board-service": "^6.0.78",
+    "@things-factory/env": "^6.0.78",
+    "@things-factory/organization": "^6.0.78",
+    "@things-factory/scheduler-client": "^6.0.78",
+    "@things-factory/shell": "^6.0.78",
+    "@things-factory/work-shift": "^6.0.78",
+    "@things-factory/worklist": "^6.0.78",
     "cron-parser": "^4.3.0",
     "moment-timezone": "^0.5.40",
     "simple-statistics": "^7.8.3",
     "statistics": "^3.3.0"
   },
-  "gitHead": "c2e7f3677ecf8392181a46b457854cc6412dbca2"
+  "gitHead": "a7638563e82d7daf5c105caf1ee62fc4ce6f98dc"
 }

package/server/controllers/generate-data-summary.ts

@@ -1,11 +1,19 @@
 const statistics = require('simple-statistics')
 const deepClone = require('lodash/cloneDeep')
 
+import { Between } from 'typeorm'
+import moment from 'moment-timezone'
+
 import { Sorting, getQueryBuilderFromListParams } from '@things-factory/shell'
 import { logger } from '@things-factory/env'
+import {
+  getDateRangeForWorkDate,
+  getDateRangeForWorkShift,
+  getLatestWorkDateAndShift
+} from '@things-factory/work-shift'
 
 import { DataSample } from '../service/data-sample/data-sample'
-import { DataSet } from '../service/data-set/data-set'
+import { DataSet, DataSetSummaryPeriodType } from '../service/data-set/data-set'
 
 import { DataSummary } from '../service/data-summary/data-summary'
 import { DataKeyItem } from '../service/data-key-set/data-key-item-type'
@@ -57,14 +65,23 @@ const calculateSummary = (dataItems: DataItem[], base: { [tag: string]: any[] })
       .map(Number)
       .filter(item => !isNaN(item))
 
-    switch (item.stat) {
-      case 'range':
-        summary[tag] = statistics.max(data) - statistics.min(data)
-        break
+    if (data.length > 0) {
+      try {
+        switch (item.stat) {
+          case 'range':
+            summary[tag] = statistics.max(data) - statistics.min(data)
+            break
 
-      default:
-        const functionName = STAT_FUNCTION_MAP[item.stat]
-        summary[tag] = (functionName && statistics[functionName](data)) || ''
+          default:
+            const functionName = STAT_FUNCTION_MAP[item.stat]
+            summary[tag] = (functionName && statistics[functionName](data)) || ''
+        }
+      } catch (err) {
+        summary[tag] = null
+        console.error(err)
+      }
+    } else {
+      summary[tag] = null
     }
 
     return summary
@@ -80,14 +97,190 @@ const fillSummaryResult = (
 
   dataSummary.summary = summary
   dataItems.slice(0, 4).forEach((dataItem, idx) => {
-    dataSummary[`data0${idx + 1}`] = summary[dataItem.tag]
+    const value = Number(summary[dataItem.tag])
+    dataSummary[`data0${idx + 1}`] = isNaN(value) ? null : value
   })
 }
 
+async function getLatestTimesForPeriod(
+  periodType: DataSetSummaryPeriodType,
+  context: ResolverContext
+): Promise<{ date?: string; period?: string; range: Date[] }> {
+  const { domain } = context.state
+  const now = moment()
+
+  if (periodType == DataSetSummaryPeriodType.Hour) {
+    const begin = now.clone().subtract(1, 'day').startOf('hour').toDate()
+    const end = now.clone().startOf('hour').toDate()
+
+    return {
+      date: moment(begin).tz(domain.timezone).format('YYYY-MM-DD'),
+      period: String(begin.getHours()),
+      range: [begin, end]
+    }
+  } else if (periodType == DataSetSummaryPeriodType.WorkShift) {
+    const { workDate, workShift, shiftRange } = await getLatestWorkDateAndShift(domain, new Date())
+
+    return { date: workDate, period: workShift, range: shiftRange }
+  } else if (periodType == DataSetSummaryPeriodType.WorkDate) {
+    const { workDate, dateRange } = await getLatestWorkDateAndShift(domain, new Date())
+
+    return { date: workDate, range: dateRange }
+  } else if (periodType == DataSetSummaryPeriodType.Day) {
+    const begin = now.clone().subtract(1, 'day').startOf('day').toDate()
+    const end = now.clone().startOf('day').toDate()
+
+    return {
+      date: moment(begin).tz(domain.timezone).format('YYYY-MM-DD'),
+      range: [begin, end]
+    }
+  }
+}
+
+async function getTimesForPeriod(
+  periodType: DataSetSummaryPeriodType,
+  date: string,
+  period: string,
+  context: ResolverContext
+): Promise<{ date?: string; period?: string; range: Date[] }> {
+  const { domain } = context.state
+
+  if (periodType == DataSetSummaryPeriodType.Hour) {
+    const theDate = moment.tz(`${date} ${period}:00:00`, 'YYYY-MM-DD HH:mm:ss', domain.timezone)
+
+    const begin = theDate.clone().startOf('hour').toDate()
+    const end = theDate.clone().add(+1, 'hour').startOf('hour').toDate()
+
+    return {
+      date,
+      period,
+      range: [begin, end]
+    }
+  } else if (periodType == DataSetSummaryPeriodType.WorkShift) {
+    const range = await getDateRangeForWorkShift(domain, date, period)
+
+    return { date, period, range }
+  } else if (periodType == DataSetSummaryPeriodType.WorkDate) {
+    const range = await getDateRangeForWorkDate(domain, date)
+
+    return { date, range }
+  } else if (periodType == DataSetSummaryPeriodType.Day) {
+    const theDate = moment.tz(`${date} 00:00:00`, 'YYYY-MM-DD HH:mm:ss', domain.timezone)
+
+    const begin = theDate.clone().startOf('day').toDate()
+    const end = theDate.clone().add(1, 'day').startOf('day').toDate()
+
+    return {
+      date: moment(begin).tz(domain.timezone).format('YYYY-MM-DD'),
+      range: [begin, end]
+    }
+  }
+}
+
+export async function generateLatestDataSummaries(dataSetId: string, context: ResolverContext): Promise<boolean> {
+  const { domain, user, tx } = context.state
+
+  try {
+    const dataSet = await tx.getRepository(DataSet).findOne({
+      where: { domain: { id: domain.id }, id: dataSetId },
+      relations: ['dataKeySet']
+    })
+
+    const dataKeyItems = dataSet.dataKeySet?.dataKeyItems || []
+    const dataItems = dataSet.dataItems.filter(item => item.stat)
+    const initialSummary = dataItems.reduce((sum, item) => {
+      sum[item.tag] = []
+      return sum
+    }, {})
+
+    const { date, period, range } = await getLatestTimesForPeriod(dataSet.summaryPeriod, context)
+    const limit = 100
+    var page = 1
+
+    var summaries: Partial<DataSummary>[] = []
+    var summary: Partial<DataSummary>
+
+    do {
+      const samples = await getQueryBuilderFromListParams({
+        repository: tx.getRepository(DataSample),
+        params: {
+          filters: [{ name: 'dataSetId', operator: 'eq', value: dataSetId }],
+          pagination: { page, limit },
+          sortings: [...buildKeySortingList(dataKeyItems), { name: 'collectedAt', desc: true }]
+        },
+        domain
+      })
+        .andWhere({ collectedAt: Between.call(range) })
+        .getMany()
+
+      for (const sample of samples) {
+        if (!summary || !compareKeys(dataKeyItems, summary, sample)) {
+          if (summary) {
+            fillSummaryResult(summary, dataItems, summary.summary)
+            summaries.push(summary)
+          }
+
+          summary = {
+            domain,
+            name: dataSet.name,
+            description: dataSet.description,
+            date,
+            period,
+            dataSet,
+            ...buildKeysFromSample(dataKeyItems, sample),
+            count: 0,
+            countOoc: 0,
+            countOos: 0,
+            summary: deepClone(initialSummary),
+            updater: user,
+            creator: user
+          }
+        }
+
+        summary.count++
+        sample.ooc && summary.countOoc++
+        sample.oos && summary.countOos++
+
+        dataItems.forEach(item => {
+          summary.summary[item.tag].push(sample.data[item.tag])
+        })
+      }
+
+      if (samples.length < limit) {
+        if (summary) {
+          fillSummaryResult(summary, dataItems, summary.summary)
+          summaries.push(summary)
+        }
+        break
+      }
+
+      page++
+    } while (true)
+
+    tx.getRepository(DataSummary).upsert(summaries, [
+      'domain',
+      'dataSet',
+      'key01',
+      'key02',
+      'key03',
+      'key04',
+      'key05',
+      'date',
+      'period'
+    ])
+
+    return true
+  } catch (e) {
+    logger.error(e)
+  }
+
+  return false
+}
+
 export async function generateDataSummary(
   dataSetId: string,
-  workDate: string,
-  workShift: string = 'NA',
+  date: string,
+  period: string,
   context: ResolverContext
 ): Promise<boolean> {
   const { domain, user, tx } = context.state
@@ -105,6 +298,10 @@ export async function generateDataSummary(
       return sum
     }, {})
 
+    const times = await getTimesForPeriod(dataSet.summaryPeriod, date, period, context)
+    const range = times.range
+    period = times.period
+
     const limit = 100
     var page = 1
 
@@ -115,16 +312,16 @@ export async function generateDataSummary(
       const samples = await getQueryBuilderFromListParams({
         repository: tx.getRepository(DataSample),
         params: {
-          filters: [
-            { name: 'dataSetId', operator: 'eq', value: dataSetId },
-            { name: 'workDate', operator: 'eq', value: workDate },
-            { name: 'workShift', operator: 'eq', value: workShift }
-          ],
+          filters: [{ name: 'dataSetId', operator: 'eq', value: dataSetId }],
           pagination: { page, limit },
           sortings: [...buildKeySortingList(dataKeyItems), { name: 'collectedAt', desc: true }]
         },
         domain
-      }).getMany()
+      })
+        .andWhere({
+          collectedAt: Between.apply(null, range)
+        })
+        .getMany()
 
       for (const sample of samples) {
         if (!summary || !compareKeys(dataKeyItems, summary, sample)) {
@@ -137,8 +334,8 @@ export async function generateDataSummary(
             domain,
             name: dataSet.name,
             description: dataSet.description,
-            workDate,
-            workShift,
+            date,
+            period,
             dataSet,
             ...buildKeysFromSample(dataKeyItems, sample),
             count: 0,
@@ -178,8 +375,8 @@ export async function generateDataSummary(
       'key03',
       'key04',
       'key05',
-      'workDate',
-      'workShift'
+      'date',
+      'period'
     ])
 
     return true

package/server/routes.ts

@@ -143,6 +143,35 @@ process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRout
 
     context.status = 200
   })
+
+  /* When a callback occurs from the scheduler when a scheduled summary is on schedule, data summary procedure for the dataset should be executed. */
+  globalPublicRouter.post('/callback-schedule-for-data-summary', async (context, next) => {
+    const { client } = context.request.body as ScheduleRegisterRequest
+
+    if (!client || typeof client !== 'object') {
+      throw new Error('client property should be a part of callback body.')
+    }
+
+    const { group: domainId, key: dataSetId } = client
+
+    if (!domainId || !dataSetId) {
+      throw new Error(`group(${domainId}) and key(${dataSetId}) properties should not be empty`)
+    }
+
+    await getDataSource().transaction(async tx => {
+      const domain = await tx.getRepository(Domain).findOneBy({ id: domainId })
+
+      if (!domain) {
+        throw new Error(`domain(${domainId}) not found`)
+      }
+
+      const dataSet = await tx.getRepository(DataSet).findOne({ where: { domain: { id: domainId }, id: dataSetId } })
+
+      // do what you gotta do
+    })
+
+    context.status = 200
+  })
 })
 
 process.on('bootstrap-module-global-private-route' as any, (app, globalPrivateRouter) => {

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

@@ -7,7 +7,7 @@ import { ApprovalLineItem } from '@things-factory/organization'
 import { AssigneeItem } from '@things-factory/worklist'
 
 import { DataItemPatch } from './data-item-type'
-import { DataSet, DataSetEntryType, DataSetMonitorType, DataSetReportType } from './data-set'
+import { DataSet, DataSetEntryType, DataSetMonitorType, DataSetReportType, DataSetSummaryPeriodType } from './data-set'
 
 @InputType()
 export class NewDataSet {
@@ -73,6 +73,9 @@ export class NewDataSet {
 
   @Field(type => GraphQLUpload, { nullable: true })
   reportTemplate?: FileUpload
+
+  @Field({ nullable: true })
+  summaryPeriod?: DataSetSummaryPeriodType
 }
 
 @InputType()
@@ -143,6 +146,9 @@ export class DataSetPatch {
   @Field(type => GraphQLUpload, { nullable: true })
   reportTemplate?: FileUpload
 
+  @Field({ nullable: true })
+  summaryPeriod?: DataSetSummaryPeriodType
+
   @Field()
   cuFlag: string
 }

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

@@ -60,6 +60,18 @@ registerEnumType(DataSetReportType, {
   description: 'report type enumeration for data-set'
 })
 
+export enum DataSetSummaryPeriodType {
+  Hour = 'hour',
+  WorkShift = 'work-shift',
+  WorkDate = 'work-date',
+  Day = 'day'
+}
+
+registerEnumType(DataSetSummaryPeriodType, {
+  name: 'DataSetSummaryPeriodType',
+  description: 'summary period type enumeration for data-set'
+})
+
 @ObjectType()
 export class DataSetState {
   @Field()
@@ -199,6 +211,14 @@ export class DataSet {
   @Field({ nullable: true })
   scheduleId?: string
 
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  summaryPeriod?: DataSetSummaryPeriodType
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  summaryScheduleId?: string
+
   @CreateDateColumn()
   @Field({ nullable: true })
   createdAt?: Date

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

@@ -2,18 +2,27 @@ import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
 
 import { DataSummary } from './data-summary'
 
-import { generateDataSummary } from '../../controllers/generate-data-summary'
+import { generateDataSummary, generateLatestDataSummaries } from '../../controllers/generate-data-summary'
 
 @Resolver(DataSummary)
 export class DataSummaryMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To generate new Data Summaries' })
+  async generateLatestDataSummaries(
+    @Arg('dataSetId') dataSetId: string,
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    return await generateLatestDataSummaries(dataSetId, context)
+  }
+
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To generate new Data Summaries' })
   async generateDataSummaries(
     @Arg('dataSetId') dataSetId: string,
-    @Arg('workDate') workDate: string,
-    @Arg('workShift') workShift: string,
+    @Arg('date') date: string,
+    @Arg('period') period: string,
     @Ctx() context: ResolverContext
   ): Promise<boolean> {
-    return await generateDataSummary(dataSetId, workDate, workShift, context)
+    return await generateDataSummary(dataSetId, date, period, context)
   }
 }

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

@@ -1,10 +1,5 @@
-import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
-import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
-import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
-
-import { ObjectRef, ScalarObject } from '@things-factory/shell'
-
-import { DataSummary, DataSummaryDurationType } from './data-summary'
+import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
+import { DataSummary } from './data-summary'
 
 @InputType()
 export class NewDataSummary {

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

@@ -14,22 +14,7 @@ import { Domain, ScalarObject } from '@things-factory/shell'
 import { User } from '@things-factory/auth-base'
 
 import { DataItem } from '../data-set/data-item-type'
-import { DataSet } from '../data-set/data-set'
-
-export enum DataSummaryDurationType {
-  Shift = 'shift',
-  Daily = 'daily',
-  Weekly = 'weekly',
-  Monthly = 'monthly',
-  Quarterly = 'quarterly',
-  Yearly = 'yearly',
-  Custom = 'custom'
-}
-
-registerEnumType(DataSummaryDurationType, {
-  name: 'DataSummaryDurationType',
-  description: 'entry type enumeration for data-summary'
-})
+import { DataSet, DataSetSummaryPeriodType } from '../data-set/data-set'
 
 @Entity()
 @Index(
@@ -42,14 +27,14 @@ registerEnumType(DataSummaryDurationType, {
     dataSummary.key03,
     dataSummary.key05,
     dataSummary.key04,
-    dataSummary.workDate,
-    dataSummary.workShift
+    dataSummary.date,
+    dataSummary.period
   ],
   { unique: true }
 )
 @Index(
   'ix_data_summary_1',
-  (dataSummary: DataSummary) => [dataSummary.domain, dataSummary.dataSet, dataSummary.workDate, dataSummary.workShift],
+  (dataSummary: DataSummary) => [dataSummary.domain, dataSummary.dataSet, dataSummary.date, dataSummary.period],
   { unique: false }
 )
 @ObjectType({ description: 'Entity for DataSummary' })
@@ -75,15 +60,15 @@ export class DataSummary {
 
   @Column({ nullable: true })
   @Field({ nullable: true })
-  type?: DataSummaryDurationType
+  type?: DataSetSummaryPeriodType
 
-  @Column({ nullable: true })
+  @Column({ nullable: true, default: '' })
   @Field({ nullable: true })
-  workDate?: string
+  date?: string = ''
 
-  @Column({ nullable: true, default: 'NA' })
+  @Column({ nullable: true, default: '' })
   @Field({ nullable: true })
-  workShift?: string = 'NA'
+  period?: string = ''
 
   @ManyToOne(type => DataSet)
   @Field(type => DataSet, { nullable: false })

package/translations/en.json

@@ -14,6 +14,7 @@
   "field.data-key-set": "data key set",
   "field.data-sample": "data sample",
   "field.data-set": "data set",
+  "field.date": "date",
   "field.device-id": "device id",
   "field.download-url": "download url",
   "field.entry-role": "entry role",
@@ -38,7 +39,10 @@
   "field.next-schedule": "next schedule",
   "field.oos": "out of critical limit",
   "field.ooc": "out of control limit",
+  "field.time-period": "time period",
   "field.summary": "summary",
+  "field.summary-period": "summary period",
+  "field.next-summary-schedule": "next summary schedule",
   "field.stat-function": "stat func.",
   "field.count": "count",
   "field.count-oos": "oos count",