@dssp/supervision 1.0.0-alpha.0 → 1.0.0-alpha.2

package/server/service/issue/issue.ts

@@ -1,100 +0,0 @@
-import {
-  CreateDateColumn,
-  UpdateDateColumn,
-  DeleteDateColumn,
-  Entity,
-  Index,
-  Column,
-  RelationId,
-  ManyToOne,
-  OneToMany,
-  PrimaryGeneratedColumn,
-  VersionColumn
-} from 'typeorm'
-import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
-
-import { Domain } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { ActionPlan } from '../action-plan/action-plan'
-
-export enum IssueStatus {
-  STATUS_A = 'STATUS_A',
-  STATUS_B = 'STATUS_B'
-}
-
-registerEnumType(IssueStatus, {
-  name: 'IssueStatus',
-  description: 'state enumeration of a issue'
-})
-
-@Entity()
-@Index('ix_issue_0', (issue: Issue) => [issue.domain, issue.name], {
-  unique: true,
-  where: '"deleted_at" IS NULL'
-})
-@ObjectType({ description: 'Entity for Issue' })
-export class Issue {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field({ nullable: true })
-  domain?: Domain
-
-  @RelationId((issue: Issue) => issue.domain)
-  domainId?: string
-
-  @Column()
-  @Field({ nullable: true })
-  name?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  state?: IssueStatus
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  params?: string
-
-  @Field(() => [ActionPlan])
-  @OneToMany(() => ActionPlan, actionPlan => actionPlan.issue)
-  actionPlans: ActionPlan[]
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @DeleteDateColumn()
-  @Field({ nullable: true })
-  deletedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((issue: Issue) => issue.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((issue: Issue) => issue.updater)
-  updaterId?: string
-
-  @Field(type => String, { nullable: true })
-  thumbnail?: string
-}

package/server/service/project-report/index.ts

@@ -1,7 +0,0 @@
-import { ProjectReport } from './project-report'
-import { ProjectReportQuery } from './project-report-query'
-import { ProjectReportMutation } from './project-report-mutation'
-
-export const entities = [ProjectReport]
-export const resolvers = [ProjectReportQuery, ProjectReportMutation]
-export const subscribers = []

package/server/service/project-report/project-report-mutation.ts

@@ -1,198 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { createAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
-
-import { ProjectReport } from './project-report'
-import { NewProjectReport, ProjectReportPatch } from './project-report-type'
-
-@Resolver(ProjectReport)
-export class ProjectReportMutation {
-  @Directive('@transaction')
-  @Mutation(returns => ProjectReport, { description: 'To create new ProjectReport' })
-  async createProjectReport(@Arg('projectReport') projectReport: NewProjectReport, @Ctx() context: ResolverContext): Promise<ProjectReport> {
-    const { domain, user, tx } = context.state
-
-    const result = await tx.getRepository(ProjectReport).save({
-      ...projectReport,
-      domain,
-      creator: user,
-      updater: user
-    })
-
-    if (projectReport.thumbnail) {
-      await createAttachment(
-        null,
-        {
-          attachment: {
-            file: projectReport.thumbnail,
-            refType: ProjectReport.name,
-            refBy: result.id
-          }
-        },
-        context
-      )
-    }
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => ProjectReport, { description: 'To modify ProjectReport information' })
-  async updateProjectReport(
-    @Arg('id') id: string,
-    @Arg('patch') patch: ProjectReportPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<ProjectReport> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(ProjectReport)
-    const projectReport = await repository.findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-
-    const result = await repository.save({
-      ...projectReport,
-      ...patch,
-      updater: user
-    })
-
-    if (patch.thumbnail) {
-      await deleteAttachmentsByRef(null, { refBys: [result.id] }, context)
-      await createAttachment(
-        null,
-        {
-          attachment: {
-            file: patch.thumbnail,
-            refType: ProjectReport.name,
-            refBy: result.id
-          }
-        },
-        context
-      )
-    }
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [ProjectReport], { description: "To modify multiple ProjectReports' information" })
-  async updateMultipleProjectReport(
-    @Arg('patches', type => [ProjectReportPatch]) patches: ProjectReportPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<ProjectReport[]> {
-    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 projectReportRepo = tx.getRepository(ProjectReport)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await projectReportRepo.save({
-          ...newRecord,
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        if (newRecord.thumbnail) {
-          await createAttachment(
-            null,
-            {
-              attachment: {
-                file: newRecord.thumbnail,
-                refType: ProjectReport.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 projectReport = await projectReportRepo.findOneBy({ id: updateRecord.id })
-
-        const result = await projectReportRepo.save({
-          ...projectReport,
-          ...updateRecord,
-          updater: user
-        })
-
-        if (updateRecord.thumbnail) {
-          await deleteAttachmentsByRef(null, { refBys: [result.id] }, context)
-          await createAttachment(
-            null,
-            {
-              attachment: {
-                file: updateRecord.thumbnail,
-                refType: ProjectReport.name,
-                refBy: result.id
-              }
-            },
-            context
-          )
-        }
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete ProjectReport' })
-  async deleteProjectReport(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(ProjectReport).delete({ domain: { id: domain.id }, id })
-    await deleteAttachmentsByRef(null, { refBys: [id] }, context)
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple ProjectReports' })
-  async deleteProjectReports(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(ProjectReport).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 ProjectReports' })
-  async importProjectReports(
-    @Arg('projectReports', type => [ProjectReportPatch]) projectReports: ProjectReportPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await Promise.all(
-      projectReports.map(async (projectReport: ProjectReportPatch) => {
-        const createdProjectReport: ProjectReport = await tx.getRepository(ProjectReport).save({ domain, ...projectReport })
-      })
-    )
-
-    return true
-  }
-}

package/server/service/project-report/project-report-query.ts

@@ -1,62 +0,0 @@
-import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
-import { Attachment } from '@things-factory/attachment-base'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { ProjectReport } from './project-report'
-import { ProjectReportList } from './project-report-type'
-
-@Resolver(ProjectReport)
-export class ProjectReportQuery {
-  @Query(returns => ProjectReport!, { nullable: true, description: 'To fetch a ProjectReport' })
-  async projectReport(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<ProjectReport> {
-    const { domain } = context.state
-
-    return await getRepository(ProjectReport).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Query(returns => ProjectReportList, { description: 'To fetch multiple ProjectReports' })
-  async projectReports(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ProjectReportList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: await getRepository(ProjectReport),
-      searchables: ['name', 'description']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => String)
-  async thumbnail(@Root() projectReport: ProjectReport): Promise<string | undefined> {
-    const attachment: Attachment = await getRepository(Attachment).findOne({
-      where: {
-        domain: { id: projectReport.domainId },
-        refType: ProjectReport.name,
-        refBy: projectReport.id
-      }
-    })
-
-    return attachment?.fullpath
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() projectReport: ProjectReport): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: projectReport.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() projectReport: ProjectReport): Promise<User> {
-    return await getRepository(User).findOneBy({ id: projectReport.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() projectReport: ProjectReport): Promise<User> {
-    return await getRepository(User).findOneBy({ id: projectReport.creatorId })
-  }
-}

package/server/service/project-report/project-report-type.ts

@@ -1,61 +0,0 @@
-import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
-import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
-import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
-
-import { ObjectRef, ScalarObject } from '@things-factory/shell'
-
-import { ProjectReport, ProjectReportStatus } from './project-report'
-
-@InputType()
-export class NewProjectReport {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field(type => ProjectReportStatus, { nullable: true })
-  state?: ProjectReportStatus
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field({ nullable: true })
-  params?: string
-
-  @Field(type => GraphQLUpload, { nullable: true })
-  thumbnail?: FileUpload
-}
-
-@InputType()
-export class ProjectReportPatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field(type => ProjectReportStatus, { nullable: true })
-  state?: ProjectReportStatus
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field(type => GraphQLUpload, { nullable: true })
-  thumbnail?: FileUpload
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class ProjectReportList {
-  @Field(type => [ProjectReport])
-  items: ProjectReport[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/project-report/project-report.ts

@@ -1,113 +0,0 @@
-import {
-  CreateDateColumn,
-  UpdateDateColumn,
-  DeleteDateColumn,
-  Entity,
-  Index,
-  Column,
-  RelationId,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  VersionColumn
-} from 'typeorm'
-import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
-
-import { Domain } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { Project } from '@dssp/project'
-
-import { Supervisor } from '../supervisor/supervisor'
-
-export enum ProjectReportStatus {
-  STATUS_A = 'STATUS_A',
-  STATUS_B = 'STATUS_B'
-}
-
-registerEnumType(ProjectReportStatus, {
-  name: 'ProjectReportStatus',
-  description: 'state enumeration of a projectReport'
-})
-
-@Entity()
-@Index('ix_project_report_0', (projectReport: ProjectReport) => [projectReport.domain, projectReport.name], {
-  unique: true,
-  where: '"deleted_at" IS NULL'
-})
-@ObjectType({ description: 'Entity for ProjectReport' })
-export class ProjectReport {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field({ nullable: true })
-  domain?: Domain
-
-  @RelationId((projectReport: ProjectReport) => projectReport.domain)
-  domainId?: string
-
-  @Column()
-  @Field({ nullable: true })
-  name?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  state?: ProjectReportStatus
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  params?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  content?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  date?: Date
-
-  @Field(() => Project)
-  @ManyToOne(() => Project)
-  project?: Project
-
-  @Field(() => Supervisor)
-  @ManyToOne(() => Supervisor, supervisor => supervisor.reports)
-  supervisor: Supervisor
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @DeleteDateColumn()
-  @Field({ nullable: true })
-  deletedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((projectReport: ProjectReport) => projectReport.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((projectReport: ProjectReport) => projectReport.updater)
-  updaterId?: string
-
-  @Field(type => String, { nullable: true })
-  thumbnail?: string
-}

package/server/service/supervisor/index.ts

@@ -1,7 +0,0 @@
-import { Supervisor } from './supervisor'
-import { SupervisorQuery } from './supervisor-query'
-import { SupervisorMutation } from './supervisor-mutation'
-
-export const entities = [Supervisor]
-export const resolvers = [SupervisorQuery, SupervisorMutation]
-export const subscribers = []