@things-factory/dataset 8.0.0-beta.9 → 8.0.2

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

@@ -0,0 +1,201 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { createAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
+
+import { DataKeySet } from './data-key-set'
+import { DataKeySetPatch, NewDataKeySet } from './data-key-set-type'
+
+@Resolver(DataKeySet)
+export class DataKeySetMutation {
+  @Directive('@transaction')
+  @Mutation(returns => DataKeySet, { description: 'To create new DataKeySet' })
+  async createDataKeySet(
+    @Arg('dataKeySet') dataKeySet: NewDataKeySet,
+    @Ctx() context: ResolverContext
+  ): Promise<DataKeySet> {
+    const { domain, user, tx } = context.state
+
+    const result = await tx.getRepository(DataKeySet).save({
+      ...dataKeySet,
+      domain,
+      creator: user,
+      updater: user
+    })
+
+    if (dataKeySet.thumbnail) {
+      await createAttachment(
+        null,
+        {
+          attachment: {
+            file: dataKeySet.thumbnail,
+            refType: DataKeySet.name,
+            refBy: result.id
+          }
+        },
+        context
+      )
+    }
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => DataKeySet, { description: 'To modify DataKeySet information' })
+  async updateDataKeySet(
+    @Arg('id') id: string,
+    @Arg('patch') patch: DataKeySetPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<DataKeySet> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(DataKeySet)
+    const dataKeySet = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    const result = await repository.save({
+      ...dataKeySet,
+      ...patch,
+      updater: user
+    })
+
+    if (patch.thumbnail) {
+      await deleteAttachmentsByRef(null, { refBys: [result.id] }, context)
+      await createAttachment(
+        null,
+        {
+          attachment: {
+            file: patch.thumbnail,
+            refType: DataKeySet.name,
+            refBy: result.id
+          }
+        },
+        context
+      )
+    }
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [DataKeySet], { description: "To modify multiple DataKeySets' information" })
+  async updateMultipleDataKeySet(
+    @Arg('patches', type => [DataKeySetPatch]) patches: DataKeySetPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<DataKeySet[]> {
+    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 dataKeySetRepo = tx.getRepository(DataKeySet)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await dataKeySetRepo.save({
+          ...newRecord,
+          domain,
+          creator: user,
+          updater: user
+        })
+
+        if (newRecord.thumbnail) {
+          await createAttachment(
+            null,
+            {
+              attachment: {
+                file: newRecord.thumbnail,
+                refType: DataKeySet.name,
+                refBy: result.id
+              }
+            },
+            context
+          )
+        }
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const updateRecord = _updateRecords[i]
+        const dataKeySet = await dataKeySetRepo.findOneBy({ id: updateRecord.id })
+
+        const result = await dataKeySetRepo.save({
+          ...dataKeySet,
+          ...updateRecord,
+          updater: user
+        })
+
+        if (updateRecord.thumbnail) {
+          await deleteAttachmentsByRef(null, { refBys: [result.id] }, context)
+          await createAttachment(
+            null,
+            {
+              attachment: {
+                file: updateRecord.thumbnail,
+                refType: DataKeySet.name,
+                refBy: result.id
+              }
+            },
+            context
+          )
+        }
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete DataKeySet' })
+  async deleteDataKeySet(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(DataKeySet).delete({ domain: { id: domain.id }, id })
+    await deleteAttachmentsByRef(null, { refBys: [id] }, context)
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple DataKeySets' })
+  async deleteDataKeySets(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(DataKeySet).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+
+    await deleteAttachmentsByRef(null, { refBys: ids }, context)
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To import multiple DataKeySets' })
+  async importDataKeySets(
+    @Arg('dataKeySets', type => [DataKeySetPatch]) dataKeySets: DataKeySetPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await Promise.all(
+      dataKeySets.map(async (dataKeySet: DataKeySetPatch) => {
+        const createdDataKeySet: DataKeySet = await tx.getRepository(DataKeySet).save({ domain, ...dataKeySet })
+      })
+    )
+
+    return true
+  }
+}

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

@@ -0,0 +1,68 @@
+import { In } from 'typeorm'
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+
+import { Attachment } from '@things-factory/attachment-base'
+import { User } from '@things-factory/auth-base'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { DataKeySet } from './data-key-set'
+import { DataKeySetList } from './data-key-set-type'
+
+@Resolver(DataKeySet)
+export class DataKeySetQuery {
+  @Query(returns => DataKeySet!, { nullable: true, description: 'To fetch a DataKeySet' })
+  async dataKeySet(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<DataKeySet> {
+    const { domain } = context.state
+
+    return await getRepository(DataKeySet).findOne({
+      where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, id }
+    })
+  }
+
+  @Query(returns => DataKeySetList, { description: 'To fetch multiple DataKeySets' })
+  async dataKeySets(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<DataKeySetList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(DataKeySet),
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => String)
+  async thumbnail(@Root() dataKeySet: DataKeySet): Promise<string | undefined> {
+    const attachment: Attachment = await getRepository(Attachment).findOne({
+      where: {
+        domain: { id: dataKeySet.domainId },
+        refType: DataKeySet.name,
+        refBy: dataKeySet.id
+      }
+    })
+
+    return attachment?.fullpath
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() dataKeySet: DataKeySet): Promise<Domain> {
+    return dataKeySet.domainId && (await getRepository(Domain).findOneBy({ id: dataKeySet.domainId }))
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() dataKeySet: DataKeySet): Promise<User> {
+    return dataKeySet.updaterId && (await getRepository(User).findOneBy({ id: dataKeySet.updaterId }))
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() dataKeySet: DataKeySet): Promise<User> {
+    return dataKeySet.creatorId && (await getRepository(User).findOneBy({ id: dataKeySet.creatorId }))
+  }
+}

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

@@ -0,0 +1,70 @@
+import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
+import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
+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 {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field({ nullable: true })
+  reportType?: DataSetReportType
+
+  @Field({ nullable: true })
+  reportView?: string
+
+  @Field(type => [DataKeyItemPatch], { nullable: true })
+  dataKeyItems?: DataKeyItemPatch[]
+
+  @Field(type => GraphQLUpload, { nullable: true })
+  thumbnail?: FileUpload
+}
+
+@InputType()
+export class DataKeySetPatch {
+  @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 })
+  reportType?: DataSetReportType
+
+  @Field({ nullable: true })
+  reportView?: string
+
+  @Field(type => [DataKeyItemPatch], { nullable: true })
+  dataKeyItems?: DataKeyItemPatch[]
+
+  @Field(type => GraphQLUpload, { nullable: true })
+  thumbnail?: FileUpload
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class DataKeySetList {
+  @Field(type => [DataKeySet])
+  items: DataKeySet[]
+
+  @Field(type => Int)
+  total: number
+}

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

@@ -0,0 +1,86 @@
+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 } 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 })
+@ObjectType({ description: 'Entity for DataKeySet' })
+export class DataKeySet {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain)
+  domain?: Domain
+
+  @RelationId((dataKeySet: DataKeySet) => dataKeySet.domain)
+  domainId?: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  description?: string
+
+  @Column({
+    nullable: true
+  })
+  @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[]
+
+  @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((dataKeySet: DataKeySet) => dataKeySet.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((dataKeySet: DataKeySet) => dataKeySet.updater)
+  updaterId?: string
+
+  @Field(type => String, { nullable: true })
+  thumbnail?: string
+}

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

@@ -0,0 +1,6 @@
+import { DataKeySet } from './data-key-set'
+import { DataKeySetQuery } from './data-key-set-query'
+import { DataKeySetMutation } from './data-key-set-mutation'
+
+export const entities = [DataKeySet]
+export const resolvers = [DataKeySetQuery, DataKeySetMutation]

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

@@ -0,0 +1,154 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+
+import { DataOoc, DataOocStatus } from './data-ooc'
+import { DataOocPatch, NewDataOoc } from './data-ooc-type'
+
+@Resolver(DataOoc)
+export class DataOocMutation {
+  @Directive('@privilege(category: "data-ooc", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => DataOoc, { description: 'To create new DataOoc' })
+  async createDataOoc(@Arg('dataOoc') dataOoc: NewDataOoc, @Ctx() context: ResolverContext): Promise<DataOoc> {
+    const { domain, user, tx } = context.state
+
+    const state = dataOoc.state || DataOocStatus.ISSUED
+    const history = [
+      {
+        user: {
+          id: user.id,
+          name: user.name
+        },
+        state,
+        timestamp: Date.now()
+      }
+    ]
+
+    return await tx.getRepository(DataOoc).save({
+      ...dataOoc,
+      state,
+      domain,
+      history,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@privilege(category: "data-ooc", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => DataOoc, { description: 'To modify DataOoc information' })
+  async updateDataOoc(
+    @Arg('id') id: string,
+    @Arg('patch') patch: DataOocPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<DataOoc> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(DataOoc)
+    const dataOoc = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    const state = patch.state || dataOoc.state
+
+    const history = dataOoc.history || []
+    history.push({
+      user: {
+        id: user.id,
+        name: user.name
+      },
+      state,
+      comment: patch.correctiveAction || '',
+      timestamp: Date.now()
+    })
+
+    const more = {} as any
+
+    if (dataOoc.state !== patch.state) {
+      if (patch.state === DataOocStatus.CORRECTED) {
+        more.corrector = user
+      } else {
+        more.corrector = null
+      }
+    }
+
+    return await repository.save({
+      ...dataOoc,
+      ...patch,
+      ...more,
+      state,
+      history,
+      updater: user
+    })
+  }
+
+  // @Directive('@privilege(category: "data-ooc", privilege: "mutation", domainOwnerGranted: true)')
+  // @Directive('@transaction')
+  // @Mutation(returns => [DataOoc], { description: "To modify multiple DataOoc' information" })
+  // async updateMultipleDataOoc(
+  //   @Arg('patches', type => [DataOocPatch]) patches: DataOocPatch[],
+  //   @Ctx() context: ResolverContext
+  // ): Promise<DataOoc[]> {
+  //   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 dataOocRepo = tx.getRepository(DataOoc)
+
+  //   if (_createRecords.length > 0) {
+  //     for (let i = 0; i < _createRecords.length; i++) {
+  //       const newRecord = _createRecords[i]
+
+  //       const result = await dataOocRepo.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 dataOoc = await dataOocRepo.findOneBy({id: newRecord.id})
+
+  //       const result = await dataOocRepo.save({
+  //         ...dataOoc,
+  //         ...newRecord,
+  //         updater: user
+  //       })
+
+  //       results.push({ ...result, cuFlag: 'M' })
+  //     }
+  //   }
+
+  //   return results
+  // }
+
+  // @Directive('@privilege(category: "data-ooc", privilege: "mutation", domainOwnerGranted: true)')
+  // @Directive('@transaction')
+  // @Mutation(returns => Boolean, { description: 'To delete DataOoc' })
+  // async deleteDataOoc(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+  //   const { domain, tx } = context.state
+
+  //   await tx.getRepository(DataOoc).delete({ domain: { id: domain.id }, id })
+  //   return true
+  // }
+
+  // @Directive('@privilege(category: "data-ooc", privilege: "mutation", domainOwnerGranted: true)')
+  // @Directive('@transaction')
+  // @Mutation(returns => Boolean, { description: 'To delete multiple dataOocs' })
+  // async deleteDataOocs(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
+  //   const { domain, tx } = context.state
+
+  //   await tx.getRepository(DataOoc).delete({
+  //     domain,
+  //     id: In(ids)
+  //   })
+
+  //   return true
+  // }
+}

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

@@ -0,0 +1,106 @@
+import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+
+import { User } from '@things-factory/auth-base'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+import { ActivityInstance } from '@things-factory/worklist'
+
+import { DataSetHistory } from '../data-set-history/data-set-history'
+import { DataItem } from '../data-set/data-item-type'
+import { DataSet } from '../data-set/data-set'
+import { DataSample } from '../data-sample/data-sample'
+import { DataOoc } from './data-ooc'
+import { DataOocList } from './data-ooc-type'
+
+@Resolver(DataOoc)
+export class DataOocQuery {
+  @Directive('@privilege(category: "data-ooc", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => DataOoc, { description: 'To fetch a DataOoc' })
+  async dataOoc(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<DataOoc> {
+    const { domain } = context.state
+
+    return await getRepository(DataOoc).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Directive('@privilege(category: "data-ooc", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => DataOocList, { description: 'To fetch multiple DataOoc' })
+  async dataOocs(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<DataOocList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      repository: getRepository(DataOoc),
+      params,
+      domain,
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => [DataItem])
+  async dataItems(@Root() dataOoc: DataOoc): Promise<DataItem[]> {
+    const dataSetHistory: DataSetHistory =
+      dataOoc.dataSetId &&
+      (await getRepository(DataSetHistory).findOne({
+        where: {
+          originalId: dataOoc.dataSetId,
+          version: dataOoc.dataSetVersion
+        }
+      }))
+    return dataSetHistory?.dataItems.filter(item => item.active) || []
+  }
+
+  @FieldResolver(type => DataSample)
+  async dataSample(@Root() dataOoc: DataOoc): Promise<DataSample> {
+    return dataOoc.dataSampleId && (await getRepository(DataSample).findOneBy({ id: dataOoc.dataSampleId }))
+  }
+
+  @FieldResolver(type => DataSet)
+  async dataSet(@Root() dataOoc: DataOoc): Promise<DataSet> {
+    return dataOoc.dataSetId && (await getRepository(DataSet).findOneBy({ id: dataOoc.dataSetId }))
+  }
+
+  @FieldResolver(type => ActivityInstance)
+  async reviewActivityInstance(@Root() dataOoc: DataOoc): Promise<ActivityInstance> {
+    return (
+      dataOoc.reviewActivityInstanceId &&
+      (await getRepository(ActivityInstance).findOneBy({ id: dataOoc.reviewActivityInstanceId }))
+    )
+  }
+
+  @FieldResolver(type => ActivityInstance)
+  async resolveActivityInstance(@Root() dataOoc: DataOoc): Promise<ActivityInstance> {
+    return (
+      dataOoc.resolveActivityInstanceId &&
+      (await getRepository(ActivityInstance).findOneBy({ id: dataOoc.resolveActivityInstanceId }))
+    )
+  }
+
+  @FieldResolver(type => User)
+  async corrector(@Root() dataOoc: DataOoc): Promise<User> {
+    return dataOoc.correctorId && (await getRepository(User).findOneBy({ id: dataOoc.correctorId }))
+  }
+
+  @FieldResolver(type => User)
+  async reviewer(@Root() dataOoc: DataOoc): Promise<User> {
+    return dataOoc.reviewerId && (await getRepository(User).findOneBy({ id: dataOoc.reviewerId }))
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() dataOoc: DataOoc): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: dataOoc.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() dataOoc: DataOoc): Promise<User> {
+    return dataOoc.updaterId && (await getRepository(User).findOneBy({ id: dataOoc.updaterId }))
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() dataOoc: DataOoc): Promise<User> {
+    return dataOoc.creatorId && (await getRepository(User).findOneBy({ id: dataOoc.creatorId }))
+  }
+}