@things-factory/dataset 5.0.0-alpha.4 → 5.0.0-alpha.40

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

@@ -20,6 +20,11 @@ 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',
+  (dataSample: DataSample) => [dataSample.domain, dataSample.dataSet, dataSample.collectedAt],
+  { unique: false }
+)
 @ObjectType({ description: 'Entity for DataSample' })
 export class DataSample {
   @PrimaryGeneratedColumn('uuid')
@@ -49,16 +54,21 @@ export class DataSample {
   @Field({ nullable: true })
   type?: string
 
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  useCase?: string
+
   @Column('simple-json', { nullable: true })
   @Field(type => ScalarObject, { nullable: true })
   partitionKeys?: ScalarObject
 
-  @ManyToOne(type => DataSet, dataSet => dataSet.dataSamples)
-  @Field(type => DataSet, { nullable: true })
+  @ManyToOne(type => DataSet)
+  @Field(type => DataSet, { nullable: false })
   dataSet?: DataSet
 
   @RelationId((dataSample: DataSample) => dataSample.dataSet)
-  @Field({ nullable: true })
   dataSetId?: string
 
   @Column('simple-json', { nullable: true })
@@ -87,6 +97,26 @@ export class DataSample {
   @Field({ nullable: true })
   source?: string
 
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  ooc?: boolean
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  oos?: boolean
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  workDate?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  workShift?: string
+
   @Column({ nullable: true })
   @Field({ nullable: true })
   collectedAt?: Date

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

@@ -2,7 +2,7 @@ import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graph
 import { getRepository } from 'typeorm'
 
 import { Appliance, User } from '@things-factory/auth-base'
-import { convertListParams, Domain, ListParam } from '@things-factory/shell'
+import { Domain, getQueryBuilderFromListParams, ListParam } from '@things-factory/shell'
 
 import { DataSet } from '../data-set/data-set'
 import { DataSensor } from './data-sensor'
@@ -23,8 +23,14 @@ export class DataSensorQuery {
   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)
+    const queryBuilder = getQueryBuilderFromListParams({
+      repository: getRepository(DataSensor),
+      params,
+      domain,
+      alias: 'datasensor'
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
 
     return { items, total }
   }

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

@@ -200,10 +200,7 @@ export class DataSetMutation {
 
     return copiedDataSets.map(dataSet => {
       dataSet.dataItems = copiedDataItems.filter(dataItem => dataItem.dataSet == dataSet.id)
-      return {
-        ...dataSet,
-        state: 'UNLOADED' // DataSetInstanceStatus.UNLOADED
-      }
+      return dataSet
     })
   }
 }

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

@@ -1,13 +1,17 @@
 import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
 import { getRepository } from 'typeorm'
 
-import { User } from '@things-factory/auth-base'
-import { convertListParams, Domain, ListParam } from '@things-factory/shell'
+import { Role, User } from '@things-factory/auth-base'
+import { Board } from '@things-factory/board-service'
+import { Domain, getQueryBuilderFromListParams, ListParam } from '@things-factory/shell'
 
 import { DataItem } from '../data-item/data-item'
+import { DataSample } from '../data-sample/data-sample'
 import { DataSet } from './data-set'
 import { DataSetList } from './data-set-type'
 
+var parser = require('cron-parser')
+
 @Resolver(DataSet)
 export class DataSetQuery {
   @Directive('@privilege(category: "data-set", privilege: "query", domainOwnerGranted: true)')
@@ -25,8 +29,66 @@ export class DataSetQuery {
   async dataSets(@Args() params: ListParam, @Ctx() context: any): Promise<DataSetList> {
     const { domain } = context.state
 
-    const convertedParams = convertListParams(params, domain.id)
-    const [items, total] = await getRepository(DataSet).findAndCount(convertedParams)
+    const queryBuilder = getQueryBuilderFromListParams({
+      repository: getRepository(DataSet),
+      params,
+      domain,
+      alias: 'dataset'
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @Query(returns => DataSetList, { description: 'To fetch multiple DataSets for data entry manually' })
+  async dataSetsForEntry(@Args() params: ListParam, @Ctx() context: any): Promise<DataSetList> {
+    var { domain, user } = context.state
+
+    /* 조회한 사용자가 entry-role을 가진 data-set 리스트만 반환 */
+    user = await getRepository(User).findOne({
+      where: { id: user.id },
+      relations: ['roles']
+    })
+    const roles = user.roles.filter(role => role.domainId === domain.id).map(role => role.id)
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      repository: getRepository(DataSet),
+      params,
+      domain,
+      alias: 'dataset'
+    })
+
+    queryBuilder.andWhere(`dataset.active = :active`, { active: true })
+    queryBuilder.andWhere(`dataset.entry_role_id IN (:...roles)`, { roles })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @Query(returns => DataSetList, { description: 'To fetch multiple DataSets to see data report' })
+  async dataSetsForReport(@Args() params: ListParam, @Ctx() context: any): Promise<DataSetList> {
+    var { domain, user } = context.state
+
+    /* 조회한 사용자가 supervisory 역할을 가진 data-set 리스트만 반환 */
+    user = await getRepository(User).findOne({
+      where: { id: user.id },
+      relations: ['roles']
+    })
+    const roles = user.roles.filter(role => role.domainId === domain.id).map(role => role.id)
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      repository: getRepository(DataSet),
+      params,
+      domain,
+      alias: 'dataset'
+    })
+
+    queryBuilder.andWhere(`dataset.active = :active`, { active: true })
+    queryBuilder.andWhere(`dataset.supervisory_role_id IN (:...roles)`, { roles })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
 
     return { items, total }
   }
@@ -38,6 +100,34 @@ export class DataSetQuery {
     })
   }
 
+  @FieldResolver(type => Role)
+  async entryRole(@Root() dataSet: DataSet): Promise<Role> {
+    return await getRepository(Role).findOne({
+      id: dataSet.entryRoleId
+    })
+  }
+
+  @FieldResolver(type => Role)
+  async supervisoryRole(@Root() dataSet: DataSet): Promise<Role> {
+    return await getRepository(Role).findOne({
+      id: dataSet.supervisoryRoleId
+    })
+  }
+
+  @FieldResolver(type => Board, { nullable: true })
+  async entryBoard(@Root() dataSet: DataSet) {
+    if (dataSet.entryType == 'board' && dataSet.entryView) {
+      return await getRepository(Board).findOne({ id: dataSet.entryView })
+    }
+  }
+
+  @FieldResolver(type => Board, { nullable: true })
+  async monitorBoard(@Root() dataSet: DataSet) {
+    if (dataSet.monitorType == 'board' && dataSet.monitorView) {
+      return await getRepository(Board).findOne({ id: dataSet.monitorView })
+    }
+  }
+
   @FieldResolver(type => Domain)
   async domain(@Root() dataSet: DataSet): Promise<Domain> {
     return await getRepository(Domain).findOne(dataSet.domainId)
@@ -52,4 +142,45 @@ export class DataSetQuery {
   async creator(@Root() dataSet: DataSet): Promise<User> {
     return await getRepository(User).findOne(dataSet.creatorId)
   }
+
+  @FieldResolver(type => Date, { nullable: true })
+  async latestCollectedAt(@Root() dataSet: DataSet): Promise<Date> {
+    const sample = await getRepository(DataSample).findOne({
+      select: ['collectedAt'],
+      where: { dataSet },
+      order: { collectedAt: 'DESC' }
+    })
+
+    return sample?.collectedAt
+  }
+
+  @FieldResolver(type => Date, { nullable: true })
+  async nextSchedule(@Root() dataSet: DataSet): Promise<Date> {
+    const { domainId, schedule, timezone } = dataSet
+
+    if (!schedule) {
+      return
+    }
+
+    var interval = parser.parseExpression(schedule, {
+      tz: timezone || ((await getRepository(Domain).findOne(domainId)) as Domain).timezone || 'UTC'
+    })
+
+    return interval.next().toDate()
+  }
+
+  @FieldResolver(type => Date, { nullable: true })
+  async prevSchedule(@Root() dataSet: DataSet): Promise<Date> {
+    const { domainId, schedule, timezone } = dataSet
+
+    if (!schedule) {
+      return
+    }
+
+    var interval = parser.parseExpression(schedule, {
+      tz: timezone || ((await getRepository(Domain).findOne(domainId)) as Domain).timezone || 'UTC'
+    })
+
+    return interval.prev().toDate()
+  }
 }

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

@@ -1,8 +1,8 @@
 import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
 
-import { ScalarObject } from '@things-factory/shell'
+import { ObjectRef, ScalarObject } from '@things-factory/shell'
 
-import { DataSet } from './data-set'
+import { DataSet, DataSetEntryType, DataSetMonitorType, DataSetReportType } from './data-set'
 
 @InputType()
 export class NewDataSet {
@@ -12,11 +12,20 @@ export class NewDataSet {
   @Field({ nullable: true })
   description?: string
 
+  @Field(type => ObjectRef, { nullable: true })
+  entryRole?: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  supervisoryRole?: ObjectRef
+
   @Field({ nullable: true })
   active?: boolean
 
   @Field({ nullable: true })
-  type?: string
+  type?: 'manual' | 'automatic' | string
+
+  @Field({ nullable: true })
+  useCase?: string
 
   @Field(type => ScalarObject, { nullable: true })
   partitionKeys?: ScalarObject
@@ -26,6 +35,24 @@ export class NewDataSet {
 
   @Field({ nullable: true })
   timezone?: string
+
+  @Field({ nullable: true })
+  entryType?: DataSetEntryType
+
+  @Field({ nullable: true })
+  entryView?: string
+
+  @Field({ nullable: true })
+  monitorType?: DataSetMonitorType
+
+  @Field({ nullable: true })
+  monitorView?: string
+
+  @Field({ nullable: true })
+  reportType?: DataSetReportType
+
+  @Field({ nullable: true })
+  reportView?: string
 }
 
 @InputType()
@@ -39,11 +66,20 @@ export class DataSetPatch {
   @Field({ nullable: true })
   description?: string
 
+  @Field(type => ObjectRef, { nullable: true })
+  supervisoryRole?: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  entryRole?: ObjectRef
+
   @Field({ nullable: true })
   active?: boolean
 
   @Field({ nullable: true })
-  type?: string
+  type?: 'manual' | 'automatic' | string
+
+  @Field({ nullable: true })
+  useCase?: string
 
   @Field(type => ScalarObject, { nullable: true })
   partitionKeys?: ScalarObject
@@ -54,6 +90,24 @@ export class DataSetPatch {
   @Field({ nullable: true })
   timezone?: string
 
+  @Field({ nullable: true })
+  entryType?: DataSetEntryType
+
+  @Field({ nullable: true })
+  entryView?: string
+
+  @Field({ nullable: true })
+  monitorType?: DataSetMonitorType
+
+  @Field({ nullable: true })
+  monitorView?: string
+
+  @Field({ nullable: true })
+  reportType?: DataSetReportType
+
+  @Field({ nullable: true })
+  reportView?: string
+
   @Field()
   cuFlag: string
 }

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

@@ -1,4 +1,4 @@
-import { Field, ID, ObjectType } from 'type-graphql'
+import { Field, ID, ObjectType, registerEnumType } from 'type-graphql'
 import {
   Column,
   CreateDateColumn,
@@ -11,11 +11,46 @@ import {
   UpdateDateColumn
 } from 'typeorm'
 
-import { User } from '@things-factory/auth-base'
+import { Role, User } from '@things-factory/auth-base'
 import { Domain, ScalarObject } from '@things-factory/shell'
 
 import { DataItem } from '../data-item/data-item'
-import { DataSample } from '../data-sample/data-sample'
+
+export enum DataSetEntryType {
+  Generated = 'generated',
+  Board = 'board',
+  Page = 'page',
+  ExternalURL = 'external'
+}
+
+registerEnumType(DataSetEntryType, {
+  name: 'DataSetEntryType',
+  description: 'entry type enumeration for data-set'
+})
+
+export enum DataSetMonitorType {
+  Generated = 'generated',
+  Board = 'board',
+  Page = 'page',
+  ExternalURL = 'external'
+}
+
+registerEnumType(DataSetMonitorType, {
+  name: 'DataSetMonitorType',
+  description: 'monitor type enumeration for data-set'
+})
+
+export enum DataSetReportType {
+  Generated = 'generated',
+  Board = 'board',
+  Page = 'page',
+  ExternalURL = 'external'
+}
+
+registerEnumType(DataSetReportType, {
+  name: 'DataSetReportType',
+  description: 'report type enumeration for data-set'
+})
 
 @Entity()
 @Index('ix_data_set_0', (dataSet: DataSet) => [dataSet.domain, dataSet.name], { unique: true })
@@ -48,30 +83,80 @@ export class DataSet {
   @Field({ nullable: true })
   active?: boolean
 
+  @ManyToOne(type => Role, {
+    nullable: true
+  })
+  @Field(type => Role, { nullable: true })
+  entryRole?: Role
+
+  @RelationId((dataSet: DataSet) => dataSet.entryRole)
+  entryRoleId?: string
+
+  @ManyToOne(type => Role, {
+    nullable: true
+  })
+  @Field(type => Role, { nullable: true })
+  supervisoryRole?: Role
+
+  @RelationId((dataSet: DataSet) => dataSet.supervisoryRole)
+  supervisoryRoleId?: string
+
   @Column({
     nullable: true
   })
   @Field({ nullable: true })
-  type?: string
+  type?: 'manual' | 'automatic' | string
 
-  @Column('simple-json', { nullable: true })
-  @Field(type => ScalarObject, { nullable: true })
-  partitionKeys?: ScalarObject
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  entryType?: DataSetEntryType
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  entryView?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  monitorType?: DataSetMonitorType
 
   @Column({
     nullable: true
   })
   @Field({ nullable: true })
-  slugger?: string
+  monitorView?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  reportType?: DataSetReportType
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  reportView?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  useCase?: string
+
+  @Column('simple-json', { nullable: true })
+  @Field(type => ScalarObject, { nullable: true })
+  partitionKeys?: ScalarObject
 
   @OneToMany(type => DataItem, dataItem => dataItem.dataSet)
   @Field(type => [DataItem], { nullable: true })
   dataItems: DataItem[]
 
-  @OneToMany(type => DataSample, dataSample => dataSample.dataSet)
-  @Field(type => [DataSample], { nullable: true })
-  dataSamples: DataSample[]
-
   @Column({
     nullable: true
   })

package/server/service/index.ts

@@ -1,11 +1,13 @@
+import { entities as DataItemEntities, resolvers as DataItemResolvers } from './data-item'
 /* IMPORT ENTITIES AND RESOLVERS */
-import { entities as DataSensorEntities, resolvers as DataSensorResolvers } from './data-sensor'
+import { entities as DataOocEntities, resolvers as DataOocResolvers } from './data-ooc'
 import { entities as DataSampleEntities, resolvers as DataSampleResolvers } from './data-sample'
-import { entities as DataItemEntities, resolvers as DataItemResolvers } from './data-item'
+import { entities as DataSensorEntities, resolvers as DataSensorResolvers } from './data-sensor'
 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-ooc/data-ooc'
 export * from './data-sensor/data-sensor'
 export * from './data-sample/data-sample'
 export * from './data-item/data-item'
@@ -14,6 +16,7 @@ export * from './data-spec/data-spec'
 
 export const entities = [
   /* ENTITIES */
+  ...DataOocEntities,
   ...DataSensorEntities,
   ...DataSampleEntities,
   ...DataItemEntities,
@@ -24,6 +27,7 @@ export const entities = [
 export const schema = {
   resolverClasses: [
     /* RESOLVER CLASSES */
+    ...DataOocResolvers,
     ...DataSensorResolvers,
     ...DataSampleResolvers,
     ...DataItemResolvers,

package/things-factory.config.js

@@ -5,16 +5,28 @@ export default {
   route,
   routes: [
     {
-      tagname: 'data-set-page',
-      page: 'data-set'
+      tagname: 'data-set-list-page',
+      page: 'data-set-list'
     },
     {
-      tagname: 'data-sensor-page',
-      page: 'data-sensor'
+      tagname: 'data-sensor-list-page',
+      page: 'data-sensor-list'
     },
     {
-      tagname: 'data-sample-page',
-      page: 'data-sample'
+      tagname: 'data-sample-list-page',
+      page: 'data-sample-list'
+    },
+    {
+      tagname: 'data-ooc-list-page',
+      page: 'data-ooc-list'
+    },
+    {
+      tagname: 'data-entry-list-page',
+      page: 'data-entry-list'
+    },
+    {
+      tagname: 'data-report-list-page',
+      page: 'data-report-list'
     }
   ],
   bootstrap

package/translations/en.json

@@ -1,21 +1,63 @@
 {
+  "button.corrected": "corrected",
+  "button.reviewed": "reviewed",
   "field.appliance": "appliance",
   "field.collected_at": "collected at",
+  "field.corrective-action": "corrective action",
+  "field.corrector": "corrector",
+  "field.corrected-at": "corrected at",
   "field.data": "data",
-  "field.dataSet": "data set",
+  "field.data-sample": "data sample",
+  "field.data-set": "data set",
   "field.device-id": "device id",
+  "field.entry-role": "entry role",
+  "field.entry-type": "entry type",
+  "field.entry-view": "entry view",
+  "field.hidden": "hidden",
+  "field.latest-collected-at": "latest collected at",
+  "field.monitor-type": "monitor type",
+  "field.monitor-view": "monitor view",
   "field.netmask": "network mask",
+  "field.next-schedule": "next schedule",
+  "field.oos": "out of critical limit",
+  "field.ooc": "out of control limit",
   "field.options": "options",
-  "field.partitionKeys": "partition keys",
+  "field.partition-keys": "partition keys",
+  "field.prev-schedule": "previous schedule",
   "field.quota": "sampling #",
   "field.raw-data": "raw data",
   "field.ref-by": "ref. by",
+  "field.report-type": "report type",
+  "field.report-view": "report view",
   "field.serial-no": "serial #",
   "field.spec": "spec",
+  "field.state": "state",
+  "field.supervisory-role": "supervisory role",
   "field.tag": "tag name",
+  "field.unit": "unit",
+  "field.use-case": "use case",
+  "field.work-date": "work date",
+  "field.work-shift": "work shift",
+  "label.acceptables": "acceptables",
+  "label.critical limits": "critical limits",
+  "label.minimum value": "minimum value",
+  "label.maximum value": "maximum value",
+  "label.pass limits": "pass limits",
+  "label.target limits": "target limits",
+  "text.automatically collected": "automatically collected",
+  "text.data sample created successfully": "a data sample created successfully",
+  "text.data ooc updated successfully": "a data ooc updated successfully",
+  "text.manually collected": "manually collected",
   "title.data-entry-form": "data entry form",
+  "title.data-entry list": "data entry list",
   "title.data-item list": "data item list",
+  "title.data-monitor-view": "data monitor view",
+  "title.data-report-view": "data report view",
+  "title.data-ooc list": "data OOC list",
+  "title.data-ooc view": "data OOC view",
   "title.data-sample list": "data sample list",
+  "title.data-sample view": "data sample view",
   "title.data-sensor list": "data sensor list",
-  "title.data-set list": "data set list"
+  "title.data-set list": "data set list",
+  "title.edit code": "edit code"
 }