@things-factory/dataset 5.0.0-alpha.1

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

@@ -0,0 +1,137 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { DataItem } from '../data-item/data-item'
+import { DataSet } from '../data-set/data-set'
+import { DataSample } from './data-sample'
+import { DataSamplePatch, NewDataSample } from './data-sample-type'
+
+@Resolver(DataSample)
+export class DataSampleMutation {
+  @Directive('@privilege(category: "data-sample", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => DataSample, { description: 'To create new data sample' })
+  async createDataSample(@Arg('dataSample') dataSample: NewDataSample, @Ctx() context: any): Promise<DataSample> {
+    const { domain, user, tx } = context.state
+
+    const dataSet = await tx.getRepository(DataSet).findOne({ id: dataSample.dataSetId })
+    const dataItems = await tx.getRepository(DataItem).find({
+      select: {
+        domain,
+        dataSetId: dataSample.dataSetId
+      },
+      order: {
+        sequence: 'DESC'
+      }
+    })
+
+    var spec = {} as any
+
+    dataItems.sortforEach(dataItem => {
+      spec[dataItem.name] = dataItem.spec
+    })
+
+    return await tx.getRepository(DataSample).save({
+      name: dataSet.name,
+      description: dataSet.description,
+      ...dataSample,
+      domain,
+      spec,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@privilege(category: "data-sample", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => DataSample, { description: 'To modify data sample information' })
+  async updateDataSample(
+    @Arg('id') id: string,
+    @Arg('patch') patch: DataSamplePatch,
+    @Ctx() context: any
+  ): Promise<DataSample> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(DataSample)
+    const dataSample = await repository.findOne({
+      where: { domain, id }
+    })
+
+    return await repository.save({
+      ...dataSample,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@privilege(category: "data-sample", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => [DataSample], { description: "To modify multiple data samples' information" })
+  async updateMultipleDataSample(
+    @Arg('patches', type => [DataSamplePatch]) patches: DataSamplePatch[],
+    @Ctx() context: any
+  ): Promise<DataSample[]> {
+    const { domain, user, tx } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const dataSampleRepo = tx.getRepository(DataSample)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await dataSampleRepo.save({
+          ...newRecord,
+          domain,
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const dataSample = await dataSampleRepo.findOne(newRecord.id)
+
+        const result = await dataSampleRepo.save({
+          ...dataSample,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@privilege(category: "data-sample", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete a data sample' })
+  async deleteDataSample(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(DataSample).delete({ domain, id })
+    return true
+  }
+
+  @Directive('@privilege(category: "data-sample", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple data samples' })
+  async deleteDataSamples(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(DataSample).delete({
+      domain,
+      id: In(ids)
+    })
+
+    return true
+  }
+}

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

@@ -0,0 +1,53 @@
+import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { convertListParams, Domain, ListParam } from '@things-factory/shell'
+
+import { DataSet } from '../data-set/data-set'
+import { DataSample } from './data-sample'
+import { DataSampleList } from './data-sample-type'
+
+@Resolver(DataSample)
+export class DataSampleQuery {
+  @Directive('@privilege(category: "data-sample", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => DataSample, { description: 'To fetch a data sample' })
+  async dataSample(@Arg('id') id: string, @Ctx() context: any): Promise<DataSample> {
+    const { domain } = context.state
+
+    return await getRepository(DataSample).findOne({
+      where: { domain, id }
+    })
+  }
+
+  @Directive('@privilege(category: "data-sample", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => DataSampleList, { description: 'To fetch multiple data samples' })
+  async dataSamples(@Args() params: ListParam, @Ctx() context: any): Promise<DataSampleList> {
+    const { domain } = context.state
+
+    const convertedParams = convertListParams(params, domain.id)
+    const [items, total] = await getRepository(DataSample).findAndCount(convertedParams)
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => DataSet)
+  async dataSet(@Root() dataSample: DataSample): Promise<Domain> {
+    return await getRepository(DataSet).findOne(dataSample.dataSetId)
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() dataSample: DataSample): Promise<Domain> {
+    return await getRepository(Domain).findOne(dataSample.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() dataSample: DataSample): Promise<User> {
+    return await getRepository(User).findOne(dataSample.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() dataSample: DataSample): Promise<User> {
+    return await getRepository(User).findOne(dataSample.creatorId)
+  }
+}

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

@@ -0,0 +1,50 @@
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ScalarObject } from '@things-factory/shell'
+
+import { DataSample } from './data-sample'
+
+@InputType()
+export class NewDataSample {
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  dataSetId?: string
+
+  @Field(type => ScalarObject, { nullable: true })
+  data?: object
+}
+
+@InputType()
+export class DataSamplePatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  dataSetId?: string
+
+  @Field(type => ScalarObject, { nullable: true })
+  data?: object
+
+  @Field()
+  cuFlag: string
+}
+
+@ObjectType()
+export class DataSampleList {
+  @Field(type => [DataSample])
+  items: DataSample[]
+
+  @Field(type => Int)
+  total: number
+}

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

@@ -0,0 +1,84 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain, ScalarObject } from '@things-factory/shell'
+
+import { DataSet } from '../data-set/data-set'
+
+@Entity()
+@Index('ix_data_sample_0', (dataSample: DataSample) => [dataSample.domain, dataSample.dataSet], { unique: false })
+@ObjectType({ description: 'Entity for DataSample' })
+export class DataSample {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((dataSample: DataSample) => dataSample.domain)
+  domainId?: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  description?: string
+
+  @ManyToOne(type => DataSet, dataSet => dataSet.dataSamples)
+  @Field(type => DataSet, { nullable: true })
+  dataSet?: DataSet
+
+  @RelationId((dataSample: DataSample) => dataSample.dataSet)
+  @Field({ nullable: true })
+  dataSetId?: string
+
+  @Column('simple-json', { nullable: true })
+  @Field(type => ScalarObject, { nullable: true })
+  data?: object
+
+  @Column('simple-json', { nullable: true })
+  @Field(type => ScalarObject, { nullable: true })
+  spec?: object
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((dataSample: DataSample) => dataSample.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((dataSample: DataSample) => dataSample.creator)
+  updaterId?: string
+}

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

@@ -0,0 +1,6 @@
+import { DataSample } from './data-sample'
+import { DataSampleQuery } from './data-sample-query'
+import { DataSampleMutation } from './data-sample-mutation'
+
+export const entities = [DataSample]
+export const resolvers = [DataSampleQuery, DataSampleMutation]

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

@@ -0,0 +1,209 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, In } from 'typeorm'
+import uuid from 'uuid/v4'
+
+import { Domain } from '@things-factory/shell'
+
+import { DataItem } from '../data-item/data-item'
+import { DataSet } from './data-set'
+import { DataSetPatch, NewDataSet } from './data-set-type'
+
+@Resolver(DataSet)
+export class DataSetMutation {
+  @Directive('@privilege(category: "data-set", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => DataSet, { description: 'To create new DataSet' })
+  async createDataSet(@Arg('dataSet') dataSet: NewDataSet, @Ctx() context: any): Promise<DataSet> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(DataSet).save({
+      ...dataSet,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@privilege(category: "data-set", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => DataSet, { description: 'To modify DataSet information' })
+  async updateDataSet(@Arg('id') id: string, @Arg('patch') patch: DataSetPatch, @Ctx() context: any): Promise<DataSet> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(DataSet)
+    const dataSet = await repository.findOne({
+      where: { domain, id }
+    })
+
+    return await repository.save({
+      ...dataSet,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@privilege(category: "data-set", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => [DataSet], { description: "To modify multiple DataSets' information" })
+  async updateMultipleDataSet(
+    @Arg('patches', type => [DataSetPatch]) patches: DataSetPatch[],
+    @Ctx() context: any
+  ): Promise<DataSet[]> {
+    const { domain, user, tx } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const dataSetRepo = tx.getRepository(DataSet)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await dataSetRepo.save({
+          ...newRecord,
+          domain,
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const dataSet = await dataSetRepo.findOne(newRecord.id)
+
+        const result = await dataSetRepo.save({
+          ...dataSet,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@privilege(category: "data-set", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete DataSet' })
+  async deleteDataSet(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(DataSet).delete({ domain, id })
+    return true
+  }
+
+  @Directive('@privilege(category: "data-set", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple dataSets' })
+  async deleteDataSets(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(DataSet).delete({
+      domain,
+      id: In(ids)
+    })
+
+    return true
+  }
+
+  @Directive('@privilege(category: "data-set", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To import multiple data-sets' })
+  async importDataSets(
+    @Arg('dataSets', type => [DataSetPatch]) dataSets: DataSet[],
+    @Ctx() context: any
+  ): Promise<boolean> {
+    const tx: EntityManager = context.state.tx
+    const domain: Domain = context.state.domain
+    await Promise.all(
+      dataSets.map(async (dataSet: DataSet) => {
+        const createdDataSet: DataSet = await tx.getRepository(DataSet).save({ domain, ...dataSet })
+        if (dataSet.dataItems?.length) {
+          await tx.getRepository(DataItem).save(
+            dataSet.dataItems.map((dataItem: DataItem) => {
+              dataItem.domain = domain
+              dataItem.dataSet = createdDataSet
+              return dataItem
+            })
+          )
+        }
+      })
+    )
+
+    return true
+  }
+
+  @Directive('@privilege(category: "data-set", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => [DataSet], { description: 'To copy multiple data-sets' })
+  async copyDataSets(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<DataSet[]> {
+    const { domain, user, tx } = context.state
+
+    const originals = await tx.getRepository(DataSet).find({
+      where: {
+        id: In(ids),
+        domain
+      },
+      relations: ['domain', 'dataItems']
+    })
+
+    if (originals.length == 0) {
+      return []
+    }
+
+    var newDataItems = []
+
+    var newCopys = originals.map(dataSet => {
+      let dataSetId = uuid()
+      newDataItems.push(
+        ...dataSet.dataItems.map(dataItem => {
+          return {
+            dataSet: dataSetId,
+            name: dataItem.name,
+            description: dataItem.description,
+            sequence: dataItem.sequence,
+            task: dataItem.task,
+            connection: dataItem.connection,
+            params: dataItem.params,
+
+            domain,
+            creator: user,
+            updater: user
+          }
+        })
+      )
+
+      return {
+        id: dataSetId,
+        name: dataSet.name + ' (' + dataSetId + ')',
+        type: dataSet.type,
+        description: dataSet.description,
+        active: false,
+        schedule: dataSet.schedule,
+        timezone: dataSet.timezone,
+
+        domain,
+        creator: user,
+        updater: user
+      }
+    })
+
+    var copiedDataSets = await tx.getRepository(DataSet).save(newCopys)
+    var copiedDataItems = await tx.getRepository(DataItem).save(newDataItems)
+
+    return copiedDataSets.map(dataSet => {
+      dataSet.dataItems = copiedDataItems.filter(dataItem => dataItem.dataSet == dataSet.id)
+      return {
+        ...dataSet,
+        state: 'UNLOADED' // DataSetInstanceStatus.UNLOADED
+      }
+    })
+  }
+}

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

@@ -0,0 +1,55 @@
+import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { convertListParams, Domain, ListParam } from '@things-factory/shell'
+
+import { DataItem } from '../data-item/data-item'
+import { DataSet } from './data-set'
+import { DataSetList } from './data-set-type'
+
+@Resolver(DataSet)
+export class DataSetQuery {
+  @Directive('@privilege(category: "data-set", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => DataSet, { description: 'To fetch a DataSet' })
+  async dataSet(@Arg('id') id: string, @Ctx() context: any): Promise<DataSet> {
+    const { domain } = context.state
+
+    return await getRepository(DataSet).findOne({
+      where: { domain, id }
+    })
+  }
+
+  @Directive('@privilege(category: "data-set", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => DataSetList, { description: 'To fetch multiple DataSets' })
+  async dataSets(@Args() params: ListParam, @Ctx() context: any): Promise<DataSetList> {
+    const { domain } = context.state
+
+    const convertedParams = convertListParams(params, domain.id)
+    const [items, total] = await getRepository(DataSet).findAndCount(convertedParams)
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => [DataItem])
+  async dataItems(@Root() dataSet: DataSet): Promise<DataItem[]> {
+    return await getRepository(DataItem).find({
+      dataSet
+    })
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() dataSet: DataSet): Promise<Domain> {
+    return await getRepository(Domain).findOne(dataSet.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() dataSet: DataSet): Promise<User> {
+    return await getRepository(User).findOne(dataSet.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() dataSet: DataSet): Promise<User> {
+    return await getRepository(User).findOne(dataSet.creatorId)
+  }
+}

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

@@ -0,0 +1,54 @@
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+
+import { DataSet } from './data-set'
+
+@InputType()
+export class NewDataSet {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field({ nullable: true })
+  schedule?: string
+
+  @Field({ nullable: true })
+  timezone?: string
+}
+
+@InputType()
+export class DataSetPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field({ nullable: true })
+  schedule?: string
+
+  @Field({ nullable: true })
+  timezone?: string
+
+  @Field()
+  cuFlag: string
+}
+
+@ObjectType()
+export class DataSetList {
+  @Field(type => [DataSet])
+  items: DataSet[]
+
+  @Field(type => Int)
+  total: number
+}