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

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

@@ -3,6 +3,7 @@ import { EntityManager, In } from 'typeorm'
 import uuid from 'uuid/v4'
 
 import { Domain } from '@things-factory/shell'
+import { createAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
 
 import { DataItem } from '../data-item/data-item'
 import { DataSet } from './data-set'
@@ -16,12 +17,16 @@ export class DataSetMutation {
   async createDataSet(@Arg('dataSet') dataSet: NewDataSet, @Ctx() context: any): Promise<DataSet> {
     const { domain, user, tx } = context.state
 
-    return await tx.getRepository(DataSet).save({
+    const result = await tx.getRepository(DataSet).save({
       ...dataSet,
       domain,
       creator: user,
       updater: user
     })
+
+    await this._createAttachment(context, dataSet.reportTemplate, { refId: result.id, cuFlag: '+' })
+
+    return result
   }
 
   @Directive('@privilege(category: "data-set", privilege: "mutation", domainOwnerGranted: true)')
@@ -35,11 +40,15 @@ export class DataSetMutation {
       where: { domain, id }
     })
 
-    return await repository.save({
+    const result = await repository.save({
       ...dataSet,
       ...patch,
       updater: user
     })
+
+    await this._createAttachment(context, dataSet.reportTemplate, { refId: result.id, cuFlag: 'M' })
+
+    return result
   }
 
   @Directive('@privilege(category: "data-set", privilege: "mutation", domainOwnerGranted: true)')
@@ -57,6 +66,7 @@ export class DataSetMutation {
     const dataSetRepo = tx.getRepository(DataSet)
 
     if (_createRecords.length > 0) {
+      const cuFlag = '+'
       for (let i = 0; i < _createRecords.length; i++) {
         const newRecord = _createRecords[i]
 
@@ -67,11 +77,14 @@ export class DataSetMutation {
           updater: user
         })
 
-        results.push({ ...result, cuFlag: '+' })
+        await this._createAttachment(context, newRecord.reportTemplate, { refId: result.id, cuFlag })
+
+        results.push({ ...result, cuFlag })
       }
     }
 
     if (_updateRecords.length > 0) {
+      const cuFlag = 'M'
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
         const dataSet = await dataSetRepo.findOne(newRecord.id)
@@ -82,7 +95,9 @@ export class DataSetMutation {
           updater: user
         })
 
-        results.push({ ...result, cuFlag: 'M' })
+        await this._createAttachment(context, newRecord.reportTemplate, { refId: result.id, cuFlag })
+
+        results.push({ ...result, cuFlag })
       }
     }
 
@@ -96,6 +111,7 @@ export class DataSetMutation {
     const { domain, tx } = context.state
 
     await tx.getRepository(DataSet).delete({ domain, id })
+    await deleteAttachmentsByRef(null, { refBys: [`report-${id}`] }, context)
     return true
   }
 
@@ -110,6 +126,8 @@ export class DataSetMutation {
       id: In(ids)
     })
 
+    await deleteAttachmentsByRef(null, { refBys: ids.map(id => `report-${id}`) } , context)
+
     return true
   }
 
@@ -169,10 +187,16 @@ export class DataSetMutation {
             name: dataItem.name,
             description: dataItem.description,
             sequence: dataItem.sequence,
-            task: dataItem.task,
-            connection: dataItem.connection,
-            params: dataItem.params,
-
+            tag: dataItem.tag,
+            active: dataItem.active,
+            type: dataItem.type,
+            quota: dataItem.quota,
+            spec: dataItem.spec,
+            unit: dataItem.unit,
+            options: dataItem.options,
+            hidden: dataItem.hidden,
+            // connection: dataItem.connection,
+            // params: dataItem.params,
             domain,
             creator: user,
             updater: user
@@ -200,10 +224,26 @@ export class DataSetMutation {
 
     return copiedDataSets.map(dataSet => {
       dataSet.dataItems = copiedDataItems.filter(dataItem => dataItem.dataSet == dataSet.id)
-      return {
-        ...dataSet,
-        state: 'UNLOADED' // DataSetInstanceStatus.UNLOADED
-      }
+      return dataSet
     })
   }
+
+
+  async _createAttachment(context, attachment, { refId, cuFlag }) {
+    if (attachment) {
+      const attachmentRef = 'report-' + refId
+      cuFlag == 'M' && await deleteAttachmentsByRef(null, { refBys: [attachmentRef] }, context)
+      await createAttachment(
+        null,
+        {
+          attachment: {
+            file: attachment,
+            refBy: attachmentRef
+          }
+        },
+        context
+      )
+    }
+  }
 }
+

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

@@ -1,13 +1,18 @@
 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 { Attachment } from '@things-factory/attachment-base'
 
 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 +30,74 @@ 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)
+
+    if (!roles.length) {
+      return { items: [], total: 0 }
+    }
+
+    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)
+
+    if (!roles.length) {
+      return { items: [], total: 0 }
+    }
+
+    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 +109,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 +151,57 @@ 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()
+  }
+
+  @FieldResolver(type => String)
+  async reportTemplate(@Root() dataset: DataSet): Promise<string | undefined> {
+    const attachment: Attachment = await getRepository(Attachment).findOne({
+      where: {
+        domain: dataset.domainId,
+        refBy: `report-${dataset.id}`
+      }
+    })
+
+    return attachment?.path
+  }
 }

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

@@ -1,8 +1,9 @@
 import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+import { FileUpload, GraphQLUpload } from 'graphql-upload'
 
-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 +13,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 +36,27 @@ 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
+
+  @Field(type => GraphQLUpload, { nullable: true })
+  reportTemplate?: FileUpload
 }
 
 @InputType()
@@ -39,11 +70,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 +94,27 @@ 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(type => GraphQLUpload, { nullable: true })
+  reportTemplate?: FileUpload
+
   @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,83 @@ 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 })
+  monitorView?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  reportType?: DataSetReportType
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  reportView?: string
+
+  @Field({ nullable: true })
+  reportTemplate?: string
 
   @Column({
     nullable: true
   })
   @Field({ nullable: true })
-  slugger?: string
+  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,17 +5,45 @@ 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'
+    },
+    {
+      tagname: 'jasper-report-samples-page',
+      page: 'jasper-report-samples'
+    },
+    {
+      tagname: 'jasper-report-samples-crosstab-page',
+      page: 'jasper-report-samples-crosstab'
+    },
+    {
+      tagname: 'jasper-report-oocs-page',
+      page: 'jasper-report-oocs'
+    },
+    {
+      tagname: 'data-report-embed-page',
+      page: 'data-report-embed'
+    },
   ],
   bootstrap
 }