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

package/server/service/checklist-type/checklist-type-mutation.ts

@@ -1,66 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { In } from 'typeorm'
-import { ChecklistType } from './checklist-type'
-import { ChecklistTypePatch } from './checklist-type-type'
-
-@Resolver(ChecklistType)
-export class ChecklistTypeMutation {
-  @Directive('@transaction')
-  @Mutation(returns => [ChecklistType], { description: "To modify multiple ChecklistTypes' information" })
-  async updateMultipleChecklistType(
-    @Arg('patches', type => [ChecklistTypePatch]) patches: ChecklistTypePatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<ChecklistType[]> {
-    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 checklistTypeRepo = tx.getRepository(ChecklistType)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await checklistTypeRepo.save({
-          ...newRecord,
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const updateRecord = _updateRecords[i]
-        const checklistType = await checklistTypeRepo.findOneBy({ id: updateRecord.id })
-
-        const result = await checklistTypeRepo.save({
-          ...checklistType,
-          ...updateRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple ChecklistTypes' })
-  async deleteChecklistTypes(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(ChecklistType).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    return true
-  }
-}

package/server/service/checklist-type/checklist-type-query.ts

@@ -1,39 +0,0 @@
-import { Resolver, Query, FieldResolver, Root, Args, Ctx } from 'type-graphql'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { ChecklistType } from './checklist-type'
-import { ChecklistTypeList } from './checklist-type-type'
-
-@Resolver(ChecklistType)
-export class ChecklistTypeQuery {
-  @Query(returns => ChecklistTypeList, { description: 'To fetch multiple ChecklistTypes' })
-  async checklistTypes(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ChecklistTypeList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: await getRepository(ChecklistType),
-      searchables: ['mainType', 'detailType']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() checklistType: ChecklistType): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: checklistType.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() checklistType: ChecklistType): Promise<User> {
-    return await getRepository(User).findOneBy({ id: checklistType.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() checklistType: ChecklistType): Promise<User> {
-    return await getRepository(User).findOneBy({ id: checklistType.creatorId })
-  }
-}

package/server/service/checklist-type/checklist-type-type.ts

@@ -1,26 +0,0 @@
-import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
-import { ChecklistType, ChecklistTypeMainType } from './checklist-type'
-
-@InputType()
-export class ChecklistTypePatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  mainType: ChecklistTypeMainType
-
-  @Field({ nullable: true })
-  detailType: string
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class ChecklistTypeList {
-  @Field(type => [ChecklistType])
-  items: ChecklistType[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/checklist-type/checklist-type.ts

@@ -1,64 +0,0 @@
-import { CreateDateColumn, UpdateDateColumn, Entity, Index, Column, RelationId, ManyToOne, PrimaryGeneratedColumn } from 'typeorm'
-import { ObjectType, Field, ID, registerEnumType } from 'type-graphql'
-import { Domain } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-
-export enum ChecklistTypeMainType {
-  BASIC = '10',
-  NON_BASIC = '20'
-}
-
-registerEnumType(ChecklistTypeMainType, {
-  name: 'ChecklistTypeMainType',
-  description: '체크리스트 구분 메인 구분'
-})
-
-@Entity({ comment: '체크리스트 구분' })
-@Index(
-  'ix_checklist_type_0',
-  (checklistType: ChecklistType) => [checklistType.domain, checklistType.mainType, checklistType.detailType],
-  { unique: true }
-)
-@ObjectType()
-export class ChecklistType {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field({ nullable: true })
-  domain?: Domain
-
-  @RelationId((checklistType: ChecklistType) => checklistType.domain)
-  domainId?: string
-
-  @Column({ nullable: false, comment: '메인 구분 (10: 기본 업무, 20: 기본 외 업무)' })
-  @Field({ nullable: false })
-  mainType: ChecklistTypeMainType
-
-  @Column({ nullable: false, comment: '상세 구분' })
-  @Field({ nullable: false })
-  detailType: string
-
-  @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((checklistType: ChecklistType) => checklistType.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((checklistType: ChecklistType) => checklistType.updater)
-  updaterId?: string
-}

package/server/service/checklist-type/index.ts

@@ -1,6 +0,0 @@
-import { ChecklistType } from './checklist-type'
-import { ChecklistTypeQuery } from './checklist-type-query'
-import { ChecklistTypeMutation } from './checklist-type-mutation'
-
-export const entities = [ChecklistType]
-export const resolvers = [ChecklistTypeQuery, ChecklistTypeMutation]

package/server/service/index.ts

@@ -1,88 +0,0 @@
-/* EXPORT ENTITY TYPES */
-export * from './action-plan/action-plan'
-export * from './issue/issue'
-export * from './project-report/project-report'
-export * from './supervisor/supervisor'
-export * from './checklist-type/checklist-type'
-export * from './checklist/checklist'
-export * from './checklist-item/checklist-item'
-export * from './checklist-item-comment/checklist-item-comment'
-export * from './checklist-template/checklist-template'
-export * from './checklist-template-item/checklist-template-item'
-export * from './building-inspection/building-inspection'
-
-/* IMPORT ENTITIES AND RESOLVERS */
-import {
-  entities as ActionPlanEntities,
-  resolvers as ActionPlanResolvers,
-  subscribers as ActionPlanSubscribers
-} from './action-plan'
-import { entities as IssueEntities, resolvers as IssueResolvers, subscribers as IssueSubscribers } from './issue'
-import {
-  entities as ProjectReportEntities,
-  resolvers as ProjectReportResolvers,
-  subscribers as ProjectReportSubscribers
-} from './project-report'
-import {
-  entities as SupervisorEntities,
-  resolvers as SupervisorResolvers,
-  subscribers as SupervisorSubscribers
-} from './supervisor'
-import { entities as ChecklistEntities, resolvers as ChecklistResolvers, subscribers as ChecklistSubscribers } from './checklist'
-import { entities as ChecklistItemEntities, resolvers as ChecklistItemResolvers } from './checklist-item'
-import {
-  entities as ChecklistItemCommentEntities,
-  resolvers as ChecklistItemCommentResolvers,
-  subscribers as ChecklistItemCommentSubscribers
-} from './checklist-item-comment'
-import { entities as ChecklistTypeEntities, resolvers as ChecklistTypeResolvers } from './checklist-type'
-import { entities as ChecklistTemplateEntities, resolvers as ChecklistTemplateResolvers } from './checklist-template'
-import { entities as ChecklistTemplateItemEntities, resolvers as ChecklistTemplateItemResolvers } from './checklist-template-item'
-import {
-  entities as BuildingInspectionEntities,
-  resolvers as BuildingInspectionResolvers,
-  subscribers as BuildingInspectionSubscribers
-} from './building-inspection'
-
-export const entities = [
-  /* ENTITIES */
-  ...ActionPlanEntities,
-  ...IssueEntities,
-  ...ProjectReportEntities,
-  ...SupervisorEntities,
-  ...ChecklistEntities,
-  ...ChecklistItemEntities,
-  ...ChecklistItemCommentEntities,
-  ...ChecklistTypeEntities,
-  ...ChecklistTemplateItemEntities,
-  ...ChecklistTemplateEntities,
-  ...BuildingInspectionEntities
-]
-
-export const subscribers = [
-  /* SUBSCRIBERS */
-  ...ActionPlanSubscribers,
-  ...IssueSubscribers,
-  ...ProjectReportSubscribers,
-  ...SupervisorSubscribers,
-  ...BuildingInspectionSubscribers,
-  ...ChecklistSubscribers,
-  ...ChecklistItemCommentSubscribers
-]
-
-export const schema = {
-  resolverClasses: [
-    /* RESOLVER CLASSES */
-    ...ActionPlanResolvers,
-    ...IssueResolvers,
-    ...ProjectReportResolvers,
-    ...SupervisorResolvers,
-    ...ChecklistResolvers,
-    ...ChecklistItemResolvers,
-    ...ChecklistItemCommentResolvers,
-    ...ChecklistTypeResolvers,
-    ...ChecklistTemplateItemResolvers,
-    ...ChecklistTemplateResolvers,
-    ...BuildingInspectionResolvers
-  ]
-}

package/server/service/issue/index.ts

@@ -1,7 +0,0 @@
-import { Issue } from './issue'
-import { IssueQuery } from './issue-query'
-import { IssueMutation } from './issue-mutation'
-
-export const entities = [Issue]
-export const resolvers = [IssueQuery, IssueMutation]
-export const subscribers = []

package/server/service/issue/issue-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 { Issue } from './issue'
-import { NewIssue, IssuePatch } from './issue-type'
-
-@Resolver(Issue)
-export class IssueMutation {
-  @Directive('@transaction')
-  @Mutation(returns => Issue, { description: 'To create new Issue' })
-  async createIssue(@Arg('issue') issue: NewIssue, @Ctx() context: ResolverContext): Promise<Issue> {
-    const { domain, user, tx } = context.state
-
-    const result = await tx.getRepository(Issue).save({
-      ...issue,
-      domain,
-      creator: user,
-      updater: user
-    })
-
-    if (issue.thumbnail) {
-      await createAttachment(
-        null,
-        {
-          attachment: {
-            file: issue.thumbnail,
-            refType: Issue.name,
-            refBy: result.id
-          }
-        },
-        context
-      )
-    }
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Issue, { description: 'To modify Issue information' })
-  async updateIssue(
-    @Arg('id') id: string,
-    @Arg('patch') patch: IssuePatch,
-    @Ctx() context: ResolverContext
-  ): Promise<Issue> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(Issue)
-    const issue = await repository.findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-
-    const result = await repository.save({
-      ...issue,
-      ...patch,
-      updater: user
-    })
-
-    if (patch.thumbnail) {
-      await deleteAttachmentsByRef(null, { refBys: [result.id] }, context)
-      await createAttachment(
-        null,
-        {
-          attachment: {
-            file: patch.thumbnail,
-            refType: Issue.name,
-            refBy: result.id
-          }
-        },
-        context
-      )
-    }
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [Issue], { description: "To modify multiple Issues' information" })
-  async updateMultipleIssue(
-    @Arg('patches', type => [IssuePatch]) patches: IssuePatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<Issue[]> {
-    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 issueRepo = tx.getRepository(Issue)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await issueRepo.save({
-          ...newRecord,
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        if (newRecord.thumbnail) {
-          await createAttachment(
-            null,
-            {
-              attachment: {
-                file: newRecord.thumbnail,
-                refType: Issue.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 issue = await issueRepo.findOneBy({ id: updateRecord.id })
-
-        const result = await issueRepo.save({
-          ...issue,
-          ...updateRecord,
-          updater: user
-        })
-
-        if (updateRecord.thumbnail) {
-          await deleteAttachmentsByRef(null, { refBys: [result.id] }, context)
-          await createAttachment(
-            null,
-            {
-              attachment: {
-                file: updateRecord.thumbnail,
-                refType: Issue.name,
-                refBy: result.id
-              }
-            },
-            context
-          )
-        }
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete Issue' })
-  async deleteIssue(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Issue).delete({ domain: { id: domain.id }, id })
-    await deleteAttachmentsByRef(null, { refBys: [id] }, context)
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple Issues' })
-  async deleteIssues(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Issue).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 Issues' })
-  async importIssues(
-    @Arg('issues', type => [IssuePatch]) issues: IssuePatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await Promise.all(
-      issues.map(async (issue: IssuePatch) => {
-        const createdIssue: Issue = await tx.getRepository(Issue).save({ domain, ...issue })
-      })
-    )
-
-    return true
-  }
-}

package/server/service/issue/issue-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 { Issue } from './issue'
-import { IssueList } from './issue-type'
-
-@Resolver(Issue)
-export class IssueQuery {
-  @Query(returns => Issue!, { nullable: true, description: 'To fetch a Issue' })
-  async issue(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Issue> {
-    const { domain } = context.state
-
-    return await getRepository(Issue).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Query(returns => IssueList, { description: 'To fetch multiple Issues' })
-  async issues(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<IssueList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: await getRepository(Issue),
-      searchables: ['name', 'description']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => String)
-  async thumbnail(@Root() issue: Issue): Promise<string | undefined> {
-    const attachment: Attachment = await getRepository(Attachment).findOne({
-      where: {
-        domain: { id: issue.domainId },
-        refType: Issue.name,
-        refBy: issue.id
-      }
-    })
-
-    return attachment?.fullpath
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() issue: Issue): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: issue.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() issue: Issue): Promise<User> {
-    return await getRepository(User).findOneBy({ id: issue.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() issue: Issue): Promise<User> {
-    return await getRepository(User).findOneBy({ id: issue.creatorId })
-  }
-}

package/server/service/issue/issue-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 { Issue, IssueStatus } from './issue'
-
-@InputType()
-export class NewIssue {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field(type => IssueStatus, { nullable: true })
-  state?: IssueStatus
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field({ nullable: true })
-  params?: string
-
-  @Field(type => GraphQLUpload, { nullable: true })
-  thumbnail?: FileUpload
-}
-
-@InputType()
-export class IssuePatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field(type => IssueStatus, { nullable: true })
-  state?: IssueStatus
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field(type => GraphQLUpload, { nullable: true })
-  thumbnail?: FileUpload
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class IssueList {
-  @Field(type => [Issue])
-  items: Issue[]
-
-  @Field(type => Int)
-  total: number
-}