@things-factory/dataset 5.0.13 → 5.0.15

package/helps/dataset/data-archive.md

@@ -0,0 +1,6 @@
+# DataArchive
+데이터셋의 원형 데이터(raw data)를 csv.gz 파일로 다운로드할 수 있습니다. <br>
+요청 후 시간이 수 분 소요될 수 있으며, 정상적으로 요청이 수행되면 다운로드 가능한 링크를 알림으로 알려줍니다. 알림의 링크를 클릭하여 파일을 다운로드 할 수 있습니다. <br>
+조회 페이지에서도 다운로드 주소를 확인할 수 있습니다. <br>
+다운로드 링크는 유효기간이 있으며, 만료되면 더 이상 다운로드할 수 없습니다. <br>
+요청시간 초과(timeout)가 발생하는 경우에는 관리자에게 문의하시기 바랍니다.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/dataset",
-  "version": "5.0.13",
+  "version": "5.0.15",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -34,14 +34,14 @@
     "@operato/shell": "^1.0.1",
     "@operato/styles": "^1.0.0",
     "@operato/utils": "^1.0.1",
-    "@things-factory/auth-base": "^5.0.11",
-    "@things-factory/aws-base": "^5.0.11",
-    "@things-factory/board-service": "^5.0.11",
+    "@things-factory/auth-base": "^5.0.15",
+    "@things-factory/aws-base": "^5.0.15",
+    "@things-factory/board-service": "^5.0.15",
     "@things-factory/env": "^5.0.0",
-    "@things-factory/shell": "^5.0.11",
-    "@things-factory/work-shift": "^5.0.11",
+    "@things-factory/shell": "^5.0.15",
+    "@things-factory/work-shift": "^5.0.15",
     "cron-parser": "^4.3.0",
     "moment-timezone": "^0.5.34"
   },
-  "gitHead": "72dfd33e398eab9872600e91d1b13fef0595c174"
+  "gitHead": "87b738da786f92983d009d72548918be93e4ae2c"
 }

package/server/controllers/create-data-sample.ts

@@ -11,6 +11,9 @@ import { NewDataSample } from '../service/data-sample/data-sample-type'
 import { DataSet } from '../service/data-set/data-set'
 import { DataUseCase } from './data-use-case'
 
+// See README.md at ## Data Samples
+process.env.TZ = 'UTC'
+
 const fillDataKeys = (dataKeySet, data) => {
   const keys = dataKeySet?.dataKeyItems || []
   return keys.reduce((sum, key, index) => {
@@ -93,6 +96,7 @@ export async function createDataSample(
     name: dataSet.name,
     description: dataSet.description,
     useCase: dataSet.useCase,
+    type: dataSet.type,
     ...dataSample,
     ...dataKeys,
     dataSetVersion: dataSet.version,

package/server/controllers/jasper-report.ts

@@ -104,20 +104,23 @@ function parseJsonDataField(rows) {
 const athenaClient = new AthenaController()
 
 async function queryAthena(params) {
-  const { table, domain, dataSetId, fromWorkDate, toWorkDate, workShift, timezone } = params
+  const { table, domain, datasetId, startDate, endDate, workShift, timezone } = params
   const queryData = {
-    sql: `SELECT name, description, data, spec, workdate, workshift, 
+    sql: `SELECT ds.name, ds.description, ds.data, dsh.data_items as spec, ds.workdate, ds.workshift,
     DATE_FORMAT(
       FROM_UNIXTIME(collected_at / 1000 / 1000) AT TIME ZONE '${timezone || 'UTC'}', 
       '%Y-%m-%d %H:%i:%s'
-    ) AS collected_at
-    FROM ${table} 
-    WHERE domain='${domain}' 
-    AND datasetid = '${dataSetId}'
-    AND workdate >= '${fromWorkDate}'
-    AND workdate <= '${toWorkDate}'
-    ${workShift ? "AND workshift = '" + workShift + "'" : ''}
-    ORDER BY collected_at`,
+    ) AS dscollected_at
+    FROM ${table} ds
+    JOIN data_set_histories dsh 
+      ON (ds.datasetid = dsh.original_id
+        and ds.data_set_version = dsh.version)
+    WHERE ds.domain='${domain}' 
+    AND ds.datasetid = '${datasetId}'
+    AND ds.workdate >= '${startDate}'
+    AND ds.workdate <= '${endDate}'
+    ${workShift ? "AND ds.workshift = '" + workShift + "'" : ''}
+    ORDER BY ds.collected_at`,
     db: DATABASE
   }
   // and json_extract_scalar(data, '$.dauid') = 'A8032AD81730'
@@ -131,7 +134,7 @@ export async function renderJasperReport(context: any) {
     query
   } = context
 
-  const template = await STORAGE.readFile(query['template'] || 'dynamic_header_sample.jrxml', 'utf-8')
+  const template = await STORAGE.readFile(query['reportTemplate'] || 'dynamic_header_sample.jrxml', 'utf-8')
   let templateType = query['templateType'] || 'crosstab'
   let parsedData = []
 
@@ -169,7 +172,9 @@ export async function renderJasperReport(context: any) {
     formData.append('jsonString', JSON.stringify(parsedData))
     formData.append('parameters', JSON.stringify(parameters))
 
-    const reportUrl = `${PROTOCOL || 'http'}://${HOST}:${PORT}/rest/report/show_html`
+    const { reportView } = query
+    const subpath = reportView ? reportView.split('/').filter(x => x).join('/') : ''
+    const reportUrl = `${PROTOCOL || 'http'}://${HOST}:${PORT}/${subpath}`
     const response = await fetch(reportUrl, {
       method: 'POST',
       body: formData

package/server/controllers/shiny-report.ts

@@ -0,0 +1,63 @@
+import FormData from 'form-data'
+import fetch from 'node-fetch'
+import { config } from '@things-factory/env'
+
+const querystring = require('querystring')
+const debug = require('debug')('things-factory:dataset:shiny-report')
+const dataReportConfig = config.get('dataReport')
+const {
+  shiny: {
+    endpoint: { protocol: PROTOCOL, host: HOST, port: PORT },
+    datasource: { database: DATABASE }
+  }
+} = Object.assign({
+  shiny: {
+    endpoint: {},
+    datasource: {}
+  }}, dataReportConfig)
+
+
+export async function renderShinyReport(context: any) {
+  debug('render:context', context)
+  
+  try {
+    const { access_token: token } = querystring.parse(context.header.cookie, ';')
+    const {
+      state: { domain },
+      query,
+      response,
+    } = context
+    
+    const urlParams = querystring.stringify({ 
+      token,
+      ...query, 
+      ...{ database: DATABASE,  
+      domain: domain?.subdomain }
+    })
+    
+    // const jsonParams = JSON.stringify({ 
+    //   ...query, 
+    //   ...{ database: DATABASE,  
+    //   domain: domain?.subdomain }
+    // })
+    
+    const protocol = `${PROTOCOL || 'http'}://`
+    const host = `${HOST}:${PORT}/`
+    const subpath = query?.reportView || ''
+
+    if (!subpath) {
+      return context.body = ''
+    }
+
+    // filter not empty and join '/'
+    const url = host.split('/').concat(subpath.split('/'))
+      .filter(x => x).join('/')
+    // const reportUrl = `${protocol}${url}/?params=${jsonParams}`
+    const reportUrl = `${protocol}${url}/?${urlParams}`
+
+    response.redirect(reportUrl)
+  } catch(ex) {
+    context.body = `Error: ${ex.message} || ''`
+  }
+  
+}

package/server/routes.ts

@@ -4,6 +4,7 @@ import { User } from '@things-factory/auth-base'
 
 import { createDataSample } from './controllers/create-data-sample'
 import { renderJasperReport } from './controllers/jasper-report'
+import { renderShinyReport } from './controllers/shiny-report'
 import { DataSensor } from './service/data-sensor/data-sensor'
 
 process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRouter) => {
@@ -89,4 +90,14 @@ process.on('bootstrap-module-domain-private-route' as any, (app, domainPrivateRo
   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,234 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+import fetch from 'node-fetch'
+
+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: any): Promise<DataArchive> {
+    const { domain, user, tx } = context.state
+    // const dataArchiveRepo = tx.getRepository(DataArchive)
+
+    const { dataset: { endpoint: { host, port=80 }, datasource: { database } }} = config.get('dataArchive')
+    
+    const body = JSON.stringify({ 
+      domain: domain?.subdomain,
+      database,
+      ...patch?.requestParams
+    })
+
+    const fetched = await fetch(`${host}:${port}`, {
+      method: 'POST',
+      headers: {'Content-Type': 'application/json'},
+      body
+    })
+    
+    let result
+    if (fetched.ok) {
+      const response = await fetched.json()
+      patch.downloadUrl = response['presignedUrl']
+      patch.status = 'done'
+
+      result = await this.updateDataArchive(patch.id, patch, context)
+    } else {
+      console.log(fetched.text())
+      patch.status = 'error'
+
+      result = await this.updateDataArchive(patch.id, patch, context)
+    }
+
+    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: any): 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: any): Promise<DataArchive> {
+    const { domain, user, tx } = context.state
+    const dataArchiveRepo = tx.getRepository(DataArchive)
+
+    const dataArchive = await dataArchiveRepo.findOne({
+      where: { domain, 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: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(DataArchive).delete({ domain, 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: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(DataArchive).delete({
+      domain,
+      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: any
+  ): 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: any): Promise<DataArchive[]> {
+    const { domain, user, tx } = context.state
+    const dataArchiveRepo = tx.getRepository(DataArchive)
+
+    const originals = await dataArchiveRepo.find({
+      where: {
+        id: In(ids),
+        domain
+      },
+      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,56 @@
+import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository } from 'typeorm'
+
+import { Role, User } from '@things-factory/auth-base'
+import { Domain, getQueryBuilderFromListParams, ListParam } 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: any): Promise<DataArchive> {
+    const { domain } = context.state
+
+    return await getRepository(DataArchive).findOne({
+      where: { domain, id }
+    })
+  }
+
+  @Directive('@privilege(category: "data-archive", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => DataArchiveList, { description: 'To fetch multiple DataArchives' })
+  async dataArchives(@Args() params: ListParam, @Ctx() context: any): 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 await getRepository(Domain).findOne(dataArchive.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() dataArchive: DataArchive): Promise<User> {
+    return await getRepository(User).findOne(dataArchive.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() dataArchive: DataArchive): Promise<User> {
+    return await getRepository(User).findOne(dataArchive.creatorId)
+  }
+}

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

@@ -0,0 +1,49 @@
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+import { DataArchive } from './data-archive'
+import { ObjectRef, 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({ nullable: true })
+  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({ nullable: true })
+  creator?: User
+
+  @RelationId((dataArchive: DataArchive) => dataArchive.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((dataArchive: DataArchive) => dataArchive.creator)
+  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-set-type.ts

@@ -4,6 +4,7 @@ import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
 
 import { DataKeyItemPatch } from './data-key-item-type'
 import { DataKeySet } from './data-key-set'
+import { DataSetReportType } from '../data-set/data-set'
 
 @InputType()
 export class NewDataKeySet {
@@ -16,6 +17,12 @@ export class NewDataKeySet {
   @Field({ nullable: true })
   active?: boolean
 
+  @Field({ nullable: true })
+  reportType?: DataSetReportType
+
+  @Field({ nullable: true })
+  reportView?: string
+
   @Field(type => [DataKeyItemPatch], { nullable: true })
   dataKeyItems?: DataKeyItemPatch[]
 
@@ -37,6 +44,12 @@ export class DataKeySetPatch {
   @Field({ nullable: true })
   active?: boolean
 
+  @Field({ nullable: true })
+  reportType?: DataSetReportType
+
+  @Field({ nullable: true })
+  reportView?: string
+
   @Field(type => [DataKeyItemPatch], { nullable: true })
   dataKeyItems?: DataKeyItemPatch[]
 

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

@@ -14,6 +14,7 @@ import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
 
 import { DataKeyItem } from './data-key-item-type'
+import { DataSetReportType } from '../data-set/data-set'
 
 @Entity()
 @Index('ix_data_key_set_0', (dataKeySet: DataKeySet) => [dataKeySet.domain, dataKeySet.name], { unique: true })
@@ -46,6 +47,14 @@ export class DataKeySet {
   @Field({ nullable: true })
   active?: boolean
 
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  reportType?: DataSetReportType
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  reportView?: string
+
   @Column('simple-json', { nullable: true })
   @Field(type => [DataKeyItem], { nullable: true })
   dataKeyItems: DataKeyItem[]

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

@@ -21,7 +21,9 @@ export enum DataSetEntryType {
   Generated = 'generated',
   Board = 'board',
   Page = 'page',
-  ExternalURL = 'external'
+  ExternalURL = 'external',
+  Jasper = 'jasper',
+  Shiny = 'shiny'
 }
 
 registerEnumType(DataSetEntryType, {