@things-factory/worklist 7.0.0-alpha.8 → 7.0.0

package/server/service/activity-template/activity-template-history.ts

@@ -1,140 +0,0 @@
-import { Field, ID, ObjectType } from 'type-graphql'
-import { Column, Entity, Index, ManyToOne, PrimaryGeneratedColumn, RelationId } from 'typeorm'
-
-import {
-  HistoryActionColumn,
-  HistoryActionType,
-  HistoryEntityInterface,
-  HistoryOriginalIdColumn
-} from '@operato/typeorm-history'
-import { User } from '@things-factory/auth-base'
-import { config } from '@things-factory/env'
-import { Domain } from '@things-factory/shell'
-
-import { ActivityStatus, ActivityType, ActivityUIType } from '../activity/activity'
-import { ActivityModelItem } from '../activity/activity-model-type'
-import { ActivityTemplate, ActivityTemplateVisibility } from './activity-template'
-
-const ORMCONFIG = config.get('ormconfig', {})
-const DATABASE_TYPE = ORMCONFIG.type
-
-@Entity()
-@Index(
-  'ix_activity_template_history_0',
-  (activityTemplateHistory: ActivityTemplateHistory) => [
-    activityTemplateHistory.originalId,
-    activityTemplateHistory.version
-  ],
-  { unique: true }
-)
-@Index(
-  'ix_activity_template_history_1',
-  (activityTemplateHistory: ActivityTemplateHistory) => [
-    activityTemplateHistory.domain,
-    activityTemplateHistory.originalId,
-    activityTemplateHistory.version
-  ],
-  { unique: true }
-)
-@ObjectType({ description: 'Entity for ActivityTemplateHistory' })
-export class ActivityTemplateHistory implements HistoryEntityInterface<ActivityTemplate> {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @Column({ default: 1, nullable: true })
-  @Field({ nullable: true })
-  version?: number = 1
-
-  @ManyToOne(type => Domain)
-  @Field({ nullable: true })
-  domain?: Domain
-
-  @RelationId((activityTemplate: ActivityTemplate) => activityTemplate.domain)
-  domainId?: string
-
-  @Column()
-  @Field({ nullable: true })
-  name?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  category?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  visibility?: ActivityTemplateVisibility
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  activityType?: ActivityType
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  state?: ActivityStatus
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => [ActivityModelItem], { nullable: true })
-  model?: ActivityModelItem[]
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  uiType?: ActivityUIType
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  uiSource?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  reportType?: ActivityUIType
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  reportSource?: string
-
-  @Column()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @Column()
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field({ nullable: true })
-  creator?: User
-
-  @RelationId((activityTemplate: ActivityTemplate) => activityTemplate.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field({ nullable: true })
-  updater?: User
-
-  @RelationId((activityTemplate: ActivityTemplate) => activityTemplate.updater)
-  updaterId?: string
-
-  @HistoryOriginalIdColumn()
-  public originalId!: string
-
-  @HistoryActionColumn({
-    nullable: false,
-    type:
-      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
-        ? 'enum'
-        : DATABASE_TYPE == 'oracle'
-        ? 'varchar2'
-        : 'smallint',
-    enum: HistoryActionType
-  })
-  public action!: HistoryActionType
-}

package/server/service/activity-template/activity-template-mutation.ts

@@ -1,203 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { createAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
-
-import { ActivityTemplate } from './activity-template'
-import { ActivityTemplatePatch, NewActivityTemplate } from './activity-template-type'
-
-@Resolver(ActivityTemplate)
-export class ActivityTemplateMutation {
-  @Directive('@transaction')
-  @Mutation(returns => ActivityTemplate, { description: 'To create new ActivityTemplate' })
-  async createActivityTemplate(
-    @Arg('activityTemplate') activityTemplate: NewActivityTemplate,
-    @Ctx() context: ResolverContext
-  ): Promise<ActivityTemplate> {
-    const { domain, user, tx } = context.state
-
-    const result = await tx.getRepository(ActivityTemplate).save({
-      ...activityTemplate,
-      domain,
-      creator: user,
-      updater: user
-    })
-
-    if (activityTemplate.thumbnail) {
-      await createAttachment(
-        null,
-        {
-          attachment: {
-            file: activityTemplate.thumbnail,
-            refType: ActivityTemplate.name,
-            refBy: result.id
-          }
-        },
-        context
-      )
-    }
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => ActivityTemplate, { description: 'To modify ActivityTemplate information' })
-  async updateActivityTemplate(
-    @Arg('id') id: string,
-    @Arg('patch') patch: ActivityTemplatePatch,
-    @Ctx() context: ResolverContext
-  ): Promise<ActivityTemplate> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(ActivityTemplate)
-    const activityTemplate = await repository.findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-
-    const result = await repository.save({
-      ...activityTemplate,
-      ...patch,
-      updater: user
-    })
-
-    if (patch.thumbnail) {
-      await deleteAttachmentsByRef(null, { refBys: [result.id] }, context)
-      await createAttachment(
-        null,
-        {
-          attachment: {
-            file: patch.thumbnail,
-            refType: ActivityTemplate.name,
-            refBy: result.id
-          }
-        },
-        context
-      )
-    }
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [ActivityTemplate], { description: "To modify multiple ActivityTemplates' information" })
-  async updateMultipleActivityTemplate(
-    @Arg('patches', type => [ActivityTemplatePatch]) patches: ActivityTemplatePatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<ActivityTemplate[]> {
-    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 activityTemplateRepo = tx.getRepository(ActivityTemplate)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await activityTemplateRepo.save({
-          ...newRecord,
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        if (newRecord.thumbnail) {
-          await createAttachment(
-            null,
-            {
-              attachment: {
-                file: newRecord.thumbnail,
-                refType: ActivityTemplate.name,
-                refBy: result.id
-              }
-            },
-            context
-          )
-        }
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const newRecord = _updateRecords[i]
-        const activityTemplate = await activityTemplateRepo.findOneBy({ id: newRecord.id })
-
-        const result = await activityTemplateRepo.save({
-          ...activityTemplate,
-          ...newRecord,
-          updater: user
-        })
-
-        if (newRecord.thumbnail) {
-          await deleteAttachmentsByRef(null, { refBys: [activityTemplate.id] }, context)
-          await createAttachment(
-            null,
-            {
-              attachment: {
-                file: newRecord.thumbnail,
-                refType: 'activity-template',
-                refBy: activityTemplate.id
-              }
-            },
-            context
-          )
-        }
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete ActivityTemplate' })
-  async deleteActivityTemplate(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(ActivityTemplate).delete({ domain: { id: domain.id }, id })
-    await deleteAttachmentsByRef(null, { refBys: [id] }, context)
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple ActivityTemplates' })
-  async deleteActivityTemplates(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(ActivityTemplate).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 ActivityTemplates' })
-  async importActivityTemplates(
-    @Arg('activityTemplates', type => [ActivityTemplatePatch]) activityTemplates: ActivityTemplatePatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await Promise.all(
-      activityTemplates.map(async (activityTemplate: ActivityTemplatePatch) => {
-        const createdActivityTemplate: ActivityTemplate = await tx
-          .getRepository(ActivityTemplate)
-          .save({ domain, ...activityTemplate })
-      })
-    )
-
-    return true
-  }
-}

package/server/service/activity-template/activity-template-query.ts

@@ -1,75 +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 { ActivityModelItem } from '../activity/activity-model-type'
-import { ActivityTemplate } from './activity-template'
-import { ActivityTemplateList } from './activity-template-type'
-
-@Resolver(ActivityTemplate)
-export class ActivityTemplateQuery {
-  @Query(returns => ActivityTemplate!, { nullable: true, description: 'To fetch a ActivityTemplate' })
-  async activityTemplate(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<ActivityTemplate> {
-    const { domain } = context.state
-
-    return await getRepository(ActivityTemplate).findOne({
-      where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, id }
-    })
-  }
-
-  @Query(returns => ActivityTemplateList, { description: 'To fetch multiple ActivityTemplates' })
-  async activityTemplates(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ActivityTemplateList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: getRepository(ActivityTemplate),
-      searchables: ['name', 'description']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => [ActivityModelItem])
-  async model(@Root() activityTemplate: ActivityTemplate): Promise<ActivityModelItem[]> {
-    if (activityTemplate.model instanceof Array) {
-      return activityTemplate.model.filter(model => model.name)
-    }
-
-    return []
-  }
-
-  @FieldResolver(type => String)
-  async thumbnail(@Root() activityTemplate: ActivityTemplate): Promise<string | undefined> {
-    const attachment: Attachment = await getRepository(Attachment).findOne({
-      where: {
-        domain: { id: activityTemplate.domainId },
-        refType: ActivityTemplate.name,
-        refBy: activityTemplate.id
-      }
-    })
-
-    return attachment?.fullpath
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() activityTemplate: ActivityTemplate): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: activityTemplate.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() activityTemplate: ActivityTemplate): Promise<User> {
-    return activityTemplate.updaterId && (await getRepository(User).findOneBy({ id: activityTemplate.updaterId }))
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() activityTemplate: ActivityTemplate): Promise<User> {
-    return activityTemplate.creatorId && (await getRepository(User).findOneBy({ id: activityTemplate.creatorId }))
-  }
-}

package/server/service/activity-template/activity-template-type.ts

@@ -1,120 +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 { ScalarObject } from '@things-factory/shell'
-
-import { ActivityStatus, ActivityType, ActivityUIType } from '../activity/activity'
-import { ActivityModelItem } from '../activity/activity-model-type'
-import { ActivityTemplate, ActivityTemplateVisibility } from './activity-template'
-
-@InputType()
-export class NewActivityTemplate {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  category?: string
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field({ nullable: true })
-  visibility?: ActivityTemplateVisibility
-
-  @Field({ nullable: true })
-  activityType?: ActivityType
-
-  @Field({ nullable: true })
-  state?: ActivityStatus
-
-  @Field(type => ScalarObject, { nullable: true })
-  model?: ActivityModelItem[]
-
-  @Field({ nullable: true })
-  uiType?: ActivityUIType
-
-  @Field({ nullable: true })
-  uiSource?: string
-
-  @Field({ nullable: true })
-  viewType?: ActivityUIType
-
-  @Field({ nullable: true })
-  viewSource?: string
-
-  @Field({ nullable: true })
-  reportType?: ActivityUIType
-
-  @Field({ nullable: true })
-  reportSource?: string
-
-  @Field(type => GraphQLUpload, { nullable: true })
-  thumbnail?: FileUpload
-}
-
-@InputType()
-export class ActivityTemplatePatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  category?: string
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field({ nullable: true })
-  visibility?: ActivityTemplateVisibility
-
-  @Field({ nullable: true })
-  activityType?: ActivityType
-
-  @Field({ nullable: true })
-  state?: ActivityStatus
-
-  @Field(type => ScalarObject, { nullable: true })
-  model?: ActivityModelItem[]
-
-  @Field({ nullable: true })
-  uiType?: ActivityUIType
-
-  @Field({ nullable: true })
-  uiSource?: string
-
-  @Field({ nullable: true })
-  viewType?: ActivityUIType
-
-  @Field({ nullable: true })
-  viewSource?: string
-
-  @Field({ nullable: true })
-  reportType?: ActivityUIType
-
-  @Field({ nullable: true })
-  reportSource?: string
-
-  @Field(type => GraphQLUpload, { nullable: true })
-  thumbnail?: FileUpload
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class ActivityTemplateList {
-  @Field(type => [ActivityTemplate])
-  items: ActivityTemplate[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/activity-template/activity-template.ts

@@ -1,134 +0,0 @@
-import { Field, ID, ObjectType, registerEnumType } from 'type-graphql'
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn,
-  VersionColumn
-} from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-
-import { ActivityStatus, ActivityType, ActivityUIType } from '../activity/activity'
-import { ActivityModelItem } from '../activity/activity-model-type'
-
-export enum ActivityTemplateVisibility {
-  Public = 'public',
-  Private = 'private',
-  Limited = 'limited'
-}
-
-registerEnumType(ActivityTemplateVisibility, {
-  name: 'ActivityTemplateVisibility',
-  description: 'visibility enumeration of a activityTemplate'
-})
-
-@Entity()
-@Index(
-  'ix_activity_template_0',
-  (activityTemplate: ActivityTemplate) => [activityTemplate.domain, activityTemplate.name],
-  { unique: true }
-)
-@ObjectType({ description: 'Entity for ActivityTemplate' })
-export class ActivityTemplate {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @VersionColumn()
-  @Field({ nullable: true })
-  version?: number = 1
-
-  @ManyToOne(type => Domain)
-  @Field({ nullable: true })
-  domain?: Domain
-
-  @RelationId((activityTemplate: ActivityTemplate) => activityTemplate.domain)
-  domainId?: string
-
-  @Column()
-  @Field({ nullable: true })
-  name?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  category?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Column({ default: 'private', nullable: true })
-  @Field({ nullable: true })
-  visibility?: ActivityTemplateVisibility = ActivityTemplateVisibility.Private
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  activityType?: ActivityType
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  state?: ActivityStatus
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => [ActivityModelItem], { nullable: true })
-  model?: ActivityModelItem[]
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  uiType?: ActivityUIType
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  uiSource?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  viewType?: ActivityUIType
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  viewSource?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  reportType?: ActivityUIType
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  reportSource?: string
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field({ nullable: true })
-  creator?: User
-
-  @RelationId((activityTemplate: ActivityTemplate) => activityTemplate.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field({ nullable: true })
-  updater?: User
-
-  @RelationId((activityTemplate: ActivityTemplate) => activityTemplate.updater)
-  updaterId?: string
-
-  @Field(type => String, { nullable: true })
-  thumbnail?: string
-}

package/server/service/activity-template/event-subscriber.ts

@@ -1,20 +0,0 @@
-import { EventSubscriber } from 'typeorm'
-
-import { HistoryEntitySubscriber } from '@operato/typeorm-history'
-
-import { ActivityTemplate } from './activity-template'
-import { ActivityTemplateHistory } from './activity-template-history'
-
-@EventSubscriber()
-export class ActivityTemplateHistoryEntitySubscriber extends HistoryEntitySubscriber<
-  ActivityTemplate,
-  ActivityTemplateHistory
-> {
-  public get entity() {
-    return ActivityTemplate
-  }
-
-  public get historyEntity() {
-    return ActivityTemplateHistory
-  }
-}

package/server/service/activity-template/index.ts

@@ -1,9 +0,0 @@
-import { ActivityTemplate } from './activity-template'
-import { ActivityTemplateHistory } from './activity-template-history'
-import { ActivityTemplateMutation } from './activity-template-mutation'
-import { ActivityTemplateQuery } from './activity-template-query'
-import { ActivityTemplateHistoryEntitySubscriber } from './event-subscriber'
-
-export const entities = [ActivityTemplate, ActivityTemplateHistory]
-export const resolvers = [ActivityTemplateQuery, ActivityTemplateMutation]
-export const subscribers = [ActivityTemplateHistoryEntitySubscriber]