@things-factory/dataset 8.0.0 → 9.0.0-beta.3

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

@@ -1,7 +0,0 @@
-import { DataSetHistory } from './data-set-history'
-import { DataSetHistoryQuery } from './data-set-history-query'
-import { DataSetHistoryEntitySubscriber } from './event-subscriber'
-
-export const entities = [DataSetHistory]
-export const resolvers = [DataSetHistoryQuery]
-export const subscribers = [DataSetHistoryEntitySubscriber]

package/server/service/data-spec/data-spec-manager.ts

@@ -1,21 +0,0 @@
-import { DataSpec } from './data-spec'
-
-export class DataSpecManager {
-  static specRegistry: { [type: string]: DataSpec } = {}
-
-  static getDataSpec(type: string): DataSpec {
-    return DataSpecManager.specRegistry[type]
-  }
-
-  static registerDataSpec(type: string, dataSpec: DataSpec) {
-    DataSpecManager.specRegistry[type] = dataSpec
-  }
-
-  static unregisterDataSpec(type: string) {
-    delete DataSpecManager.specRegistry[type]
-  }
-
-  static getDataSpecs(): DataSpec[] {
-    return Object.values(DataSpecManager.specRegistry)
-  }
-}

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

@@ -1,21 +0,0 @@
-import { Resolver, Query, Arg } from 'type-graphql'
-import { DataSpec, DataSpecList } from './data-spec'
-import { DataSpecManager } from './data-spec-manager'
-
-@Resolver(DataSpec)
-export class DataSpecQuery {
-  @Query(returns => DataSpec, { description: 'To fetch a data-spec' })
-  dataSpec(@Arg('name') name: string): DataSpec {
-    return DataSpecManager.getDataSpec(name)
-  }
-
-  @Query(returns => DataSpecList, { description: 'To fetch all data-specs' })
-  dataSpecs(): DataSpecList {
-    const items = DataSpecManager.getDataSpecs()
-
-    return {
-      items,
-      total: items.length
-    }
-  }
-}

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

@@ -1,45 +0,0 @@
-import { Field, Int, ObjectType } from 'type-graphql'
-
-import { ScalarObject } from '@things-factory/shell'
-
-@ObjectType()
-export class DataSpecItem {
-  @Field()
-  type: string
-
-  @Field()
-  label: string
-
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  placeholder?: string
-
-  @Field(type => ScalarObject, { nullable: true })
-  property?: { [key: string]: any }
-}
-
-@ObjectType()
-export class DataSpec {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description: string
-
-  @Field({ nullable: true })
-  help: string
-
-  @Field(type => [DataSpecItem], { nullable: true })
-  specItems: DataSpecItem[]
-}
-
-@ObjectType()
-export class DataSpecList {
-  @Field(type => [DataSpec])
-  items: DataSpec[]
-
-  @Field(type => Int)
-  total: number
-}

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

@@ -1,5 +0,0 @@
-import { DataSpec } from './data-spec'
-import { DataSpecQuery } from './data-spec-query'
-
-export const entities = [DataSpec]
-export const resolvers = [DataSpecQuery]

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

@@ -1,45 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-
-import { DataSummary } from './data-summary'
-
-import { finalizeDataCollection, finalizeLatestDataCollection } from '../../controllers/finalize-data-collection'
-
-@Resolver(DataSummary)
-export class DataSummaryMutation {
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, {
-    description: 'Deprecated. Use finalizeLatestDataCollection',
-    deprecationReason: 'This resolver has been replaced by finalizeLatestDataCollection'
-  })
-  async generateLatestDataSummaries(@Arg('dataSetId') dataSetId: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    return await finalizeLatestDataCollection(dataSetId, context)
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To finalize new Data Summaries' })
-  async finalizeLatestDataCollection(@Arg('dataSetId') dataSetId: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    return await finalizeLatestDataCollection(dataSetId, context)
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'Deprecated. Use finalizeDataCollection', deprecationReason: 'This resolver has been replaced by finalizeDataCollection' })
-  async generateDataSummaries(
-    @Arg('dataSetId') dataSetId: string,
-    @Arg('date') date: string,
-    @Arg('period') period: string,
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    return await finalizeDataCollection(dataSetId, date, period, context)
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To finalize data collection for the given period' })
-  async finalizeDataCollection(
-    @Arg('dataSetId') dataSetId: string,
-    @Arg('date') date: string,
-    @Arg('period') period: string,
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    return await finalizeDataCollection(dataSetId, date, period, context)
-  }
-}

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

@@ -1,179 +0,0 @@
-import { In } from 'typeorm'
-import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { DataKeySet } from '../data-key-set/data-key-set'
-import { DataItem } from '../data-set/data-item-type'
-import { DataSet } from '../data-set/data-set'
-import { DataSummary } from './data-summary'
-import { DataSummaryList, DynamicDataSummary } from './data-summary-type'
-import { queryDataSummaryByPeriod } from '../../controllers/query-data-summary-by-period'
-
-@Resolver(DataSummary)
-export class DataSummaryQuery {
-  @Query(returns => DataSummary!, { nullable: true, description: 'To fetch a DataSummary' })
-  async dataSummary(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<DataSummary> {
-    const { domain } = context.state
-
-    return await getRepository(DataSummary).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Query(returns => DataSummaryList, { description: 'To fetch multiple DataSummaries' })
-  async dataSummaries(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<DataSummaryList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: await getRepository(DataSummary),
-      searchables: ['name', 'description']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @Query(returns => [DynamicDataSummary], { description: 'To fetch multiple dynamically grouped DataSummaries' })
-  async dataSummaryByPeriod(
-    @Arg('period') period: 'today' | 'this month' | '30 days' | 'this year' | '12 months',
-    @Arg('dataSetName') dataSetName: string,
-    @Arg('dataKeys', type => [String], { nullable: true }) dataKeys: string[] | null,
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<DynamicDataSummary[]> {
-    return await queryDataSummaryByPeriod(period, dataSetName, dataKeys, params, context)
-  }
-
-  @Directive('@privilege(category: "data-summary", privilege: "query", domainOwnerGranted: true)')
-  @Query(returns => DataSummaryList, { description: 'To fetch multiple data summaries by data set name' })
-  async dataSummariesByDataSetName(
-    @Arg('dataSetName') dataSetName: string,
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<DataSummaryList> {
-    const { domain } = context.state
-
-    const dataSet = await getRepository(DataSet).findOne({
-      where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, name: dataSetName },
-      relations: ['dataKeySet']
-    })
-
-    if (!dataSet) {
-      throw new Error(`dataSet not found by the given dataSetName(${dataSetName})`)
-    }
-
-    const dataKeyItems = dataSet.dataKeySet?.dataKeyItems || []
-    const searchables = dataKeyItems.map((item, index) => `key0${index + 1}`)
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      repository: getRepository(DataSummary),
-      params,
-      domain,
-      alias: 'summary',
-      searchables: ['name', 'description'].concat(searchables)
-    }).innerJoin('summary.dataSet', 'ds', 'ds.id = :dataSetName', {
-      dataSetName: dataSet.id
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @Directive('@privilege(category: "data-summary", privilege: "query", domainOwnerGranted: true)')
-  @Query(returns => DataSummaryList, { description: 'To fetch multiple data summaries by data set' })
-  async dataSummariesByDataSet(
-    @Arg('dataSetId') dataSetId: string,
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<DataSummaryList> {
-    const { domain } = context.state
-
-    const dataSet = await getRepository(DataSet).findOne({
-      where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, id: dataSetId },
-      relations: ['dataKeySet']
-    })
-
-    if (!dataSet) {
-      throw new Error(`dataSet not found by the given dataSetId(${dataSetId})`)
-    }
-
-    const dataKeyItems = dataSet.dataKeySet?.dataKeyItems || []
-    const searchables = dataKeyItems.map((item, index) => `key0${index + 1}`)
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      repository: getRepository(DataSummary),
-      params,
-      domain,
-      alias: 'summary',
-      searchables: ['name', 'description'].concat(searchables)
-    }).innerJoin('summary.dataSet', 'ds', 'ds.id = :dataSetId', {
-      dataSetId
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @Directive('@privilege(category: "data-summary", privilege: "query", domainOwnerGranted: true)')
-  @Query(returns => DataSummaryList, { description: 'To fetch multiple data summaries by data key set' })
-  async dataSummariesByDataKeySet(
-    @Arg('dataKeySetId') dataKeySetId: string,
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<DataSummaryList> {
-    const { domain } = context.state
-
-    const dataKeySet = await getRepository(DataKeySet).findOneBy({ id: dataKeySetId })
-    const dataKeyItems = dataKeySet?.dataKeyItems || []
-    const searchables = dataKeyItems.map((item, index) => `key0${index + 1}`)
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      repository: getRepository(DataSummary),
-      params,
-      domain,
-      alias: 'summary',
-      searchables: ['name', 'description'].concat(searchables)
-    }).innerJoin('summary.dataSet', 'ds', 'ds.dataKeySet = :dataKeySetId', {
-      dataKeySetId
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => [DataItem])
-  async dataItems(@Root() dataSummary: DataSummary): Promise<DataItem[]> {
-    const dataSet = dataSummary.dataSetId && (await getRepository(DataSet).findOneBy({ id: dataSummary.dataSetId }))
-
-    return dataSet?.dataItems.filter(item => item.active) || []
-  }
-
-  @FieldResolver(type => DataSet)
-  async dataSet(@Root() dataSummary: DataSummary): Promise<DataSet> {
-    return dataSummary.dataSetId && (await getRepository(DataSet).findOneBy({ id: dataSummary.dataSetId }))
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() dataSummary: DataSummary): Promise<Domain> {
-    return dataSummary.domainId && (await getRepository(Domain).findOneBy({ id: dataSummary.domainId }))
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() dataSummary: DataSummary): Promise<User> {
-    return dataSummary.updaterId && (await getRepository(User).findOneBy({ id: dataSummary.updaterId }))
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() dataSummary: DataSummary): Promise<User> {
-    return dataSummary.creatorId && (await getRepository(User).findOneBy({ id: dataSummary.creatorId }))
-  }
-}

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

@@ -1,86 +0,0 @@
-import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
-import { DataSummary } from './data-summary'
-
-@InputType()
-export class NewDataSummary {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-}
-
-@InputType()
-export class DataSummaryPatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class DynamicDataSummary {
-  @Field({ nullable: true })
-  month?: string = ''
-
-  @Field({ nullable: true })
-  date?: string = ''
-
-  @Field({ nullable: true })
-  period?: string = ''
-
-  @Field({ nullable: true })
-  count?: number
-
-  @Field({ nullable: true })
-  countOoc?: number
-
-  @Field({ nullable: true })
-  countOos?: number
-
-  @Field({ nullable: true })
-  key01?: string = ''
-
-  @Field({ nullable: true })
-  key02?: string = ''
-
-  @Field({ nullable: true })
-  key03?: string = ''
-
-  @Field({ nullable: true })
-  key04?: string = ''
-
-  @Field({ nullable: true })
-  key05?: string = ''
-
-  @Field({ nullable: true })
-  data01?: number
-
-  @Field({ nullable: true })
-  data02?: number
-
-  @Field({ nullable: true })
-  data03?: number
-
-  @Field({ nullable: true })
-  data04?: number
-
-  @Field({ nullable: true })
-  data05?: number
-}
-
-@ObjectType()
-export class DataSummaryList {
-  @Field(type => [DataSummary])
-  items: DataSummary[]
-
-  @Field(type => Int)
-  total: number
-}

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

@@ -1,170 +0,0 @@
-import {
-  CreateDateColumn,
-  UpdateDateColumn,
-  Entity,
-  Index,
-  Column,
-  RelationId,
-  ManyToOne,
-  PrimaryGeneratedColumn
-} from 'typeorm'
-import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
-
-import { Domain, ScalarObject } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-
-import { DataItem } from '../data-set/data-item-type'
-import { DataSet, DataSetSummaryPeriodType } from '../data-set/data-set'
-
-@Entity()
-@Index(
-  'ix_data_summary_0',
-  (dataSummary: DataSummary) => [
-    dataSummary.domain,
-    dataSummary.dataSet,
-    dataSummary.key01,
-    dataSummary.key02,
-    dataSummary.key03,
-    dataSummary.key04,
-    dataSummary.key05,
-    dataSummary.date,
-    dataSummary.period
-  ],
-  { unique: true }
-)
-@Index(
-  'ix_data_summary_1',
-  (dataSummary: DataSummary) => [dataSummary.domain, dataSummary.dataSet, dataSummary.date, dataSummary.period],
-  { unique: false }
-)
-@ObjectType({ description: 'Entity for DataSummary' })
-export class DataSummary {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain)
-  domain?: Domain
-
-  @RelationId((dataSummary: DataSummary) => dataSummary.domain)
-  domainId?: string
-
-  @Column()
-  @Field({ nullable: true })
-  name?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  type?: DataSetSummaryPeriodType
-
-  @Column({ nullable: true, default: '', length: 20 })
-  @Field({ nullable: true })
-  date?: string = ''
-
-  @Column({ nullable: true, default: '', length: 20 })
-  @Field({ nullable: true })
-  period?: string = ''
-
-  @ManyToOne(type => DataSet)
-  @Field(type => DataSet, { nullable: false })
-  dataSet?: DataSet
-
-  @RelationId((dataSample: DataSummary) => dataSample.dataSet)
-  dataSetId?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  dataSetVersion?: number
-
-  @Field(type => [DataItem], { nullable: true })
-  dataItems?: DataItem[]
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => ScalarObject, { nullable: true })
-  summary?: any
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  count?: number
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  countOoc?: number
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  countOos?: number
-
-  @Column({ nullable: true, default: '', length: 100 })
-  @Field({ nullable: true })
-  key01?: string = ''
-
-  @Column({ nullable: true, default: '', length: 100 })
-  @Field({ nullable: true })
-  key02?: string = ''
-
-  @Column({ nullable: true, default: '', length: 100 })
-  @Field({ nullable: true })
-  key03?: string = ''
-
-  @Column({ nullable: true, default: '', length: 100 })
-  @Field({ nullable: true })
-  key04?: string = ''
-
-  @Column({ nullable: true, default: '', length: 100 })
-  @Field({ nullable: true })
-  key05?: string = ''
-
-  @Column({ type: 'real', nullable: true })
-  @Field({ nullable: true })
-  data01?: number
-
-  @Column({ type: 'real', nullable: true })
-  @Field({ nullable: true })
-  data02?: number
-
-  @Column({ type: 'real', nullable: true })
-  @Field({ nullable: true })
-  data03?: number
-
-  @Column({ type: 'real', nullable: true })
-  @Field({ nullable: true })
-  data04?: number
-
-  @Column({ type: 'real', nullable: true })
-  @Field({ nullable: true })
-  data05?: number
-
-  @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((dataSummary: DataSummary) => dataSummary.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((dataSummary: DataSummary) => dataSummary.updater)
-  updaterId?: string
-}

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

@@ -1,7 +0,0 @@
-import { DataSummary } from './data-summary'
-import { DataSummaryQuery } from './data-summary-query'
-import { DataSummaryMutation } from './data-summary-mutation'
-
-export const entities = [DataSummary]
-export const resolvers = [DataSummaryQuery, DataSummaryMutation]
-export const subscribers = []

package/server/service/index.ts

@@ -1,57 +0,0 @@
-import { entities as DataKeySetEntities, resolvers as DataKeySetResolvers } from './data-key-set'
-import { entities as DataOocEntities, resolvers as DataOocResolvers } from './data-ooc'
-import { entities as DataSampleEntities, resolvers as DataSampleResolvers } from './data-sample'
-import { entities as DataSensorEntities, resolvers as DataSensorResolvers } from './data-sensor'
-import { entities as DataSetEntities, resolvers as DataSetResolvers } from './data-set'
-import {
-  entities as DataSetHistoryEntities,
-  resolvers as DataSetHistoryResolvers,
-  subscribers as DataSetHistorySubscribers
-} from './data-set-history'
-import { entities as DataSummaryEntities, resolvers as DataSummaryResolvers } from './data-summary'
-import { entities as DataSpecEntities, resolvers as DataSpecResolvers } from './data-spec'
-import { entities as DataArchiveEntities, resolvers as DataArchiveResolvers } from './data-archive'
-
-/* EXPORT ENTITY TYPES */
-export * from './data-summary/data-summary'
-export * from './data-key-set/data-key-set'
-export * from './data-ooc/data-ooc'
-export * from './data-sensor/data-sensor'
-export * from './data-sample/data-sample'
-export * from './data-set/data-set'
-export * from './data-set-history/data-set-history'
-export * from './data-set/data-item-type'
-export * from './data-spec/data-spec'
-
-export const entities = [
-  /* ENTITIES */
-  ...DataSummaryEntities,
-  ...DataKeySetEntities,
-  ...DataOocEntities,
-  ...DataSensorEntities,
-  ...DataSampleEntities,
-  ...DataSetEntities,
-  ...DataSetHistoryEntities,
-  ...DataSpecEntities,
-  ...DataArchiveEntities
-]
-
-export const subscribers = [
-  /* SUBSCRIBERS */
-  ...DataSetHistorySubscribers
-]
-
-export const schema = {
-  resolverClasses: [
-    /* RESOLVER CLASSES */
-    ...DataSummaryResolvers,
-    ...DataKeySetResolvers,
-    ...DataOocResolvers,
-    ...DataSensorResolvers,
-    ...DataSampleResolvers,
-    ...DataSetResolvers,
-    ...DataSetHistoryResolvers,
-    ...DataSpecResolvers,
-    ...DataArchiveResolvers
-  ]
-}

package/server/tsconfig.json

@@ -1,10 +0,0 @@
-{
-  "extends": "../../tsconfig-base.json",
-  "compilerOptions": {
-    "strict": false,
-    "module": "commonjs",
-    "outDir": "../dist-server",
-    "baseUrl": "./"
-  },
-  "include": ["./**/*"]
-}

package/server/utils/config-resolver.ts

@@ -1,29 +0,0 @@
-
-export function getEndpointUrl(endpoint:any, subpath:string=''):string {
-    const { url='', protocol='http', host='', port=80 } = endpoint
-    
-    let _url = ''
-    let _protocol = protocol
-
-    if (url) {
-        _url = url
-    } else {
-        const hosts = host.split('://')
-        // host에 protocol을 포함한 경우
-        if (hosts.length == 2) {
-            const _host = hosts[1]
-            _protocol = hosts[0]
-            // host에 port를 포함한 경우
-            const _hosts = _host.split(':')
-            if (_hosts.length > 1) {
-                _url = `${_hosts[0]}:${_hosts[1]}`
-            } else {
-                _url = `${_host}:${port}`
-            }
-        } else if (hosts.length == 1) { 
-            _url = `${host}:${port}`
-        }
-    }
-
-    return _protocol + '://' + _url.split('/').concat(subpath.split('/')).filter(x=>x).join('/')
-}