@things-factory/dataset 8.0.0-beta.9 → 8.0.2

package/server/routes.ts

@@ -0,0 +1,188 @@
+import { In } from 'typeorm'
+
+import { Domain, getDataSource } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { runScenario } from '@things-factory/integration-base'
+import { ScheduleRegisterRequest } from '@things-factory/scheduler-client'
+
+import { createDataSample } from './controllers/create-data-sample'
+import { renderJasperReport } from './controllers/jasper-report'
+import { renderShinyReport } from './controllers/shiny-report'
+import { issueDataCollectionTask } from './controllers/issue-data-collection-task'
+import { DataSensor } from './service/data-sensor/data-sensor'
+import { DataSet } from './service/data-set/data-set'
+
+process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRouter) => {
+  /*
+   * can add global public routes to application (auth not required, tenancy not required)
+   *
+   * ex) routes.get('/path', async(context, next) => {})
+   * ex) routes.post('/path', async(context, next) => {})
+   */
+
+  globalPublicRouter.post('/sensor-data', async (context, next) => {
+    // 데이타 검증
+    const { deviceId, data, rawData, timestamp = Date.now() } = context.request.body
+    if (!deviceId) {
+      throw new Error(`The deviceId(${deviceId}) property are mandatory`)
+    }
+
+    // make new data-sample
+    await getDataSource().transaction(async tx => {
+      // find sensor through deviceId
+      const sensor = await tx.getRepository(DataSensor).findOne({
+        where: { deviceId },
+        relations: ['domain', 'appliance', 'dataSet', 'decoder']
+      })
+
+      if (!sensor) {
+        throw new Error(`Sensor having given deviceId(${deviceId}) not found`)
+      }
+
+      if (!sensor.active) {
+        throw new Error(`State of the sensor given deviceId(${deviceId}) is not active`)
+      }
+
+      if (!sensor.appliance) {
+        throw new Error(`Appliance of the sensor given deviceId(${deviceId}) is not set up`)
+      }
+
+      const domain = sensor.domain
+      const dataSet = sensor.dataSet
+
+      /* 
+        원칙적으로 user 인증정보를 가지고 요청해야 하지만, 인증정보를 보낼 수 없는 상황이라고 전제하여 처리한다.
+        앞으로, 보완되어야 한다.
+      */
+      const user: User =
+        context.user ||
+        (await tx.getRepository(User).findOne({
+          where: {
+            reference: sensor.appliance.id,
+            userType: 'appliance'
+          }
+        }))
+
+      context.state = {
+        user,
+        ...context.state,
+        domain,
+        tx
+      }
+
+      var decoded
+      if (sensor.decoder) {
+        const { name: scenarioName } = sensor.decoder
+        const variables = {
+          dataSensor: sensor,
+          source: deviceId,
+          data,
+          rawData,
+          timestamp
+        }
+
+        decoded = (await runScenario(null, scenarioName, variables, context))?.result
+      }
+
+      if (dataSet) {
+        await createDataSample(
+          {
+            dataSet,
+            data,
+            rawData,
+            source: deviceId,
+            collectedAt: new Date(timestamp),
+            ...decoded
+          },
+          context
+        )
+      }
+
+      context.status = 200
+      context.body = {
+        data,
+        ...decoded
+      }
+    })
+  })
+
+  /* When a callback occurs from the scheduler when a scheduled dataset is on schedule, data collection task for the dataset should be issued. */
+  globalPublicRouter.post('/callback-schedule-for-dataset', 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 issueDataCollectionTask(domainId, dataSetId, context)
+
+    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: In([domain.id, domain.parentId].filter(Boolean)) }, id: dataSetId } })
+
+      // do what you gotta do
+    })
+
+    context.status = 200
+  })
+})
+
+process.on('bootstrap-module-global-private-route' as any, (app, globalPrivateRouter) => {
+  /*
+   * can add global private routes to application (auth required, tenancy not required)
+   */
+})
+
+process.on('bootstrap-module-domain-public-route' as any, (app, domainPublicRouter) => {
+  /*
+   * can add domain public routes to application (auth not required, tenancy required)
+   */
+})
+
+process.on('bootstrap-module-domain-private-route' as any, (app, domainPrivateRouter) => {
+  /*
+   * can add domain private routes to application (auth required, tenancy required)
+   */
+  domainPrivateRouter.get('/data-report/jasper', async (context, next) => {
+    context.body = await renderJasperReport(context)
+  })
+
+  domainPrivateRouter.get('/data-report/shiny', async (context, next) => {
+    await renderShinyReport(context)
+  })
+
+  domainPrivateRouter.get('/data-report/:reportType', async (context, next) => {
+    let { reportType } = context.params
+    context.body = `${reportType} Not Implemented.`
+  })
+})

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

@@ -0,0 +1,273 @@
+import i18next from 'i18next'
+import fetch from 'node-fetch'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { getEndpointUrl } from '../../utils/config-resolver'
+import { DataArchive } from './data-archive'
+import { DataArchivePatch, NewDataArchive } from './data-archive-type'
+
+const { config } = require('@things-factory/env')
+const crypto = require('crypto')
+
+@Resolver(DataArchive)
+export class DataArchiveMutation {
+  /**
+   * It may use 'func-[dev]-data-set-download' in https://github.com/operatochef/serverless
+   * This function requests athena query and save the result as csv.gz in s3
+   */
+  @Directive('@privilege(category: "data-archive", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => DataArchive, { description: 'To create new DataArchive' })
+  async generatePresignedUrl(
+    @Arg('patch') patch: DataArchivePatch,
+    @Ctx() context: ResolverContext
+  ): Promise<DataArchive> {
+    const { domain, user, tx, notify, lng } = context.state
+    // const dataArchiveRepo = tx.getRepository(DataArchive)
+    const t = i18next.getFixedT(lng, 'translations')
+    const {
+      dataset: {
+        endpoint,
+        datasource: { database }
+      }
+    } = config.get('dataArchive')
+
+    const body = JSON.stringify({
+      domain: domain?.subdomain,
+      database,
+      ...patch?.requestParams
+    })
+
+    const url = getEndpointUrl(endpoint)
+
+    const fetched = await fetch(`${url}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body
+    })
+
+    const message = {
+      receivers: [user.email],
+      mode: 'in-app',
+      title: '',
+      body: '',
+      url: ''
+    }
+
+    if (fetched.ok) {
+      const response = await fetched.json()
+      patch.downloadUrl = response['presignedUrl']
+      patch.status = 'done'
+
+      message['title'] = t('title.data-archive downloads ready')
+      message['url'] = patch.downloadUrl
+    } else {
+      const error = await fetched.text()
+      console.log(error)
+      patch.status = 'error'
+
+      message['title'] = t('title.data-archive request failed')
+      // may not user-friendly message
+      message['body'] = error
+    }
+
+    const result = await this.updateDataArchive(patch.id, patch, context)
+
+    notify && notify(message)
+
+    return result
+  }
+
+  @Directive('@privilege(category: "data-archive", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => DataArchive, { description: 'To create new DataArchive' })
+  async createDataArchive(
+    @Arg('dataArchive') dataArchive: NewDataArchive,
+    @Ctx() context: ResolverContext
+  ): Promise<DataArchive> {
+    const { domain, user, tx } = context.state
+    const dataArchiveRepo = tx.getRepository(DataArchive)
+
+    const result = await dataArchiveRepo.save({
+      ...dataArchive,
+      domain,
+      creator: user,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@privilege(category: "data-archive", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => DataArchive, { description: 'To modify DataArchive information' })
+  async updateDataArchive(
+    @Arg('id') id: string,
+    @Arg('patch') patch: DataArchivePatch,
+    @Ctx() context: ResolverContext
+  ): Promise<DataArchive> {
+    const { domain, user, tx } = context.state
+    const dataArchiveRepo = tx.getRepository(DataArchive)
+
+    const dataArchive = await dataArchiveRepo.findOne({
+      where: { domain: { id: domain.id }, id },
+      relations: ['domain', 'creator', 'updater']
+    })
+
+    const result = await dataArchiveRepo.save({
+      ...dataArchive,
+      ...patch,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@privilege(category: "data-archive", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => [DataArchive], { description: "To modify multiple DataArchives' information" })
+  async updateMultipleDataArchive(
+    @Arg('patches', type => [DataArchivePatch]) patches: DataArchivePatch[],
+    @Ctx() context: any
+  ): Promise<DataArchive[]> {
+    const { domain, user, tx } = context.state
+    const dataArchiveRepo = tx.getRepository(DataArchive)
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+
+    if (_createRecords.length > 0) {
+      const cuFlag = '+'
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await dataArchiveRepo.save({
+          ...newRecord,
+          domain,
+          creator: user,
+          updater: user
+        })
+
+        results.push({
+          ...result,
+          cuFlag
+        })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      const cuFlag = 'M'
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const dataArchive = await dataArchiveRepo.findOne(newRecord.id, {
+          relations: ['domain', 'creator', 'updater']
+        })
+
+        const result = await dataArchiveRepo.save({
+          ...dataArchive,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({
+          ...result,
+          cuFlag
+        })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@privilege(category: "data-archive", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete DataArchive' })
+  async deleteDataArchive(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(DataArchive).delete({ domain: { id: domain.id }, id })
+    return true
+  }
+
+  @Directive('@privilege(category: "data-archive", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple dataArchives' })
+  async deleteDataArchives(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(DataArchive).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+
+    return true
+  }
+
+  @Directive('@privilege(category: "data-archive", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To import multiple data-archives' })
+  async importDataArchives(
+    @Arg('dataArchives', type => [DataArchivePatch]) dataArchives: DataArchive[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+    const dataArchiveRepo = tx.getRepository(DataArchive)
+
+    await Promise.all(
+      dataArchives.map(async (dataArchive: DataArchive) => {
+        const createdDataArchive: DataArchive = await dataArchiveRepo.save({
+          domain,
+          ...dataArchive
+        })
+      })
+    )
+
+    return true
+  }
+
+  @Directive('@privilege(category: "data-archive", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => [DataArchive], { description: 'To copy multiple data-archives' })
+  async copyDataArchives(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<DataArchive[]> {
+    const { domain, user, tx } = context.state
+    const dataArchiveRepo = tx.getRepository(DataArchive)
+
+    const originals = await dataArchiveRepo.find({
+      where: {
+        id: In(ids),
+        domain: { id: domain.id }
+      },
+      relations: ['domain']
+    })
+
+    if (originals.length == 0) {
+      return []
+    }
+
+    var newCopys = originals.map(dataArchive => {
+      let dataArchiveId = crypto.randomUUID()
+
+      return {
+        ...dataArchive,
+        id: dataArchiveId,
+        domain,
+        creator: user,
+        updater: user,
+        updatedAt: undefined,
+        createdAt: undefined
+      }
+    })
+
+    var copiedDataArchives = await dataArchiveRepo.save(newCopys)
+
+    return copiedDataArchives
+  }
+}

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

@@ -0,0 +1,58 @@
+import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+
+import { Role, User } from '@things-factory/auth-base'
+import { Domain, getQueryBuilderFromListParams, ListParam, getRepository } from '@things-factory/shell'
+
+import { DataArchive } from './data-archive'
+import { DataArchiveList } from './data-archive-type'
+
+var parser = require('cron-parser')
+
+@Resolver(DataArchive)
+export class DataArchiveQuery {
+  @Directive('@privilege(category: "data-archive", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => DataArchive, { description: 'To fetch a DataArchive' })
+  async dataArchive(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<DataArchive> {
+    const { domain } = context.state
+
+    return await getRepository(DataArchive).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Directive('@privilege(category: "data-archive", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => DataArchiveList, { description: 'To fetch multiple DataArchives' })
+  async dataArchives(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<DataArchiveList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      repository: getRepository(DataArchive),
+      params,
+      domain,
+      alias: 'dataArchive',
+      searchables: []
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() dataArchive: DataArchive): Promise<Domain> {
+    return dataArchive.domainId && (await getRepository(Domain).findOneBy({ id: dataArchive.domainId }))
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() dataArchive: DataArchive): Promise<User> {
+    return dataArchive.updaterId && (await getRepository(User).findOneBy({ id: dataArchive.updaterId }))
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() dataArchive: DataArchive): Promise<User> {
+    return dataArchive.creatorId && (await getRepository(User).findOneBy({ id: dataArchive.creatorId }))
+  }
+}

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

@@ -0,0 +1,48 @@
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+import { DataArchive } from './data-archive'
+import { ScalarObject } from '@things-factory/shell'
+
+@InputType()
+export class NewDataArchive {
+  @Field({ nullable: true })
+  type?: 'manual' | 'automatic' | string
+
+  @Field(type => ScalarObject, { nullable: true })
+  requestParams?: { [key: string]: any }
+
+  @Field({ nullable: true })
+  downloadUrl?: string
+
+  @Field({ nullable: true })
+  status?: string
+}
+
+@InputType()
+export class DataArchivePatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  type?: 'manual' | 'automatic' | string
+
+  @Field(type => ScalarObject, { nullable: true })
+  requestParams?: { [key: string]: any }
+
+  @Field({ nullable: true })
+  downloadUrl?: string
+
+  @Field({ nullable: true })
+  status?: string
+
+  @Field({ nullable: true })
+  cuFlag: string
+}
+
+@ObjectType()
+export class DataArchiveList {
+  @Field(type => [DataArchive])
+  items: DataArchive[]
+
+  @Field(type => Int)
+  total: number
+}

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

@@ -0,0 +1,69 @@
+import { Field, ID, ObjectType, registerEnumType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn,
+  VersionColumn
+} from 'typeorm'
+
+import { Role, User } from '@things-factory/auth-base'
+import { Domain, ScalarObject } from '@things-factory/shell'
+
+@Entity()
+@Index('ix_data_archive_0', (dataArchive: DataArchive) => [dataArchive.id], { unique: true })
+@ObjectType({ description: 'Entity for DataArchive' })
+export class DataArchive {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain)
+  domain?: Domain
+
+  @RelationId((dataArchive: DataArchive) => dataArchive.domain)
+  domainId?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  type?: 'manual' | 'automatic' | string
+
+  @Column('simple-json', { nullable: true })
+  @Field(type => ScalarObject, { nullable: true })
+  requestParams?: { [key: string]: any }
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  downloadUrl?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  status?: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((dataArchive: DataArchive) => dataArchive.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((dataArchive: DataArchive) => dataArchive.updater)
+  updaterId?: string
+}

package/server/service/data-archive/index.ts

@@ -0,0 +1,6 @@
+import { DataArchive } from './data-archive'
+import { DataArchiveMutation } from './data-archive-mutation'
+import { DataArchiveQuery } from './data-archive-query'
+
+export const entities = [DataArchive]
+export const resolvers = [DataArchiveQuery, DataArchiveMutation]

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

@@ -0,0 +1,31 @@
+import { Field, InputType, ObjectType } from 'type-graphql'
+
+@ObjectType({ description: 'Entity for DataKeyItem' })
+export class DataKeyItem {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  dataKey: string
+
+  @Field({ nullable: true })
+  tKey?: string
+}
+
+@InputType()
+export class DataKeyItemPatch {
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  dataKey?: string
+
+  @Field({ nullable: true })
+  tKey?: string
+}