@things-factory/dataset 8.0.39 → 9.0.0-9.0.0-beta.59.0

package/server/routes.ts

@@ -1,188 +0,0 @@
-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

@@ -1,273 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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
-}