@things-factory/dataset 8.0.39 → 9.0.0-9.0.0-beta.59.0

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

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

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

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

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

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

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

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