@things-factory/dataset 8.0.0-beta.8 → 8.0.0

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

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

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

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

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

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

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

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

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

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

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

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

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

package/server/utils/config-resolver.ts

@@ -0,0 +1,29 @@
+
+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('/')
+}