@things-factory/organization 8.0.0-beta.8 → 8.0.0

package/server/service/department/department.ts

@@ -0,0 +1,116 @@
+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 { Employee } from '../employee/employee'
+
+@Entity()
+@Index('ix_department_0', (department: Department) => [department.domain, department.name], {
+  unique: true,
+  where: '"deleted_at" IS NULL'
+})
+@Index('ix_department_1', (department: Department) => [department.domain, department.controlNo], {
+  unique: true,
+  where: '"deleted_at" IS NULL'
+})
+@ObjectType({ description: 'Entity for Department' })
+export class Department {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @VersionColumn()
+  @Field({ nullable: true })
+  version?: number = 1
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain)
+  domain?: Domain
+
+  @RelationId((department: Department) => department.domain)
+  domainId?: string
+
+  @Column()
+  @Field()
+  controlNo: string
+
+  @Column()
+  @Field({ nullable: true })
+  name?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description?: string
+
+  @ManyToOne(type => Department, department => department.children, { nullable: true })
+  @Field({ nullable: true })
+  parent?: Department
+
+  @RelationId((department: Department) => department.parent)
+  parentId?: string
+
+  @OneToMany(type => Department, department => department.parent)
+  @Field(type => [Department])
+  children?: Department[]
+
+  @OneToMany(type => Employee, employee => employee.department)
+  @Field(type => [Employee])
+  members?: Employee[]
+
+  @ManyToOne(type => Employee, manager => manager.manages, { nullable: true })
+  @Field(type => Employee, { nullable: true })
+  manager?: Employee
+
+  @RelationId((department: Department) => department.manager)
+  managerId?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  extension?: string
+
+  @Field(type => String, { nullable: true })
+  picture?: string
+
+  @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((department: Department) => department.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((department: Department) => department.updater)
+  updaterId?: string
+}

package/server/service/department/event-subscriber.ts

@@ -0,0 +1,17 @@
+import { EventSubscriber } from 'typeorm'
+
+import { HistoryEntitySubscriber } from '@operato/typeorm-history'
+
+import { Department } from './department'
+import { DepartmentHistory } from './department-history'
+
+@EventSubscriber()
+export class DepartmentHistoryEntitySubscriber extends HistoryEntitySubscriber<Department, DepartmentHistory> {
+  public get entity() {
+    return Department
+  }
+
+  public get historyEntity() {
+    return DepartmentHistory
+  }
+}

package/server/service/department/index.ts

@@ -0,0 +1,9 @@
+import { Department } from './department'
+import { DepartmentHistory } from './department-history'
+import { DepartmentQuery } from './department-query'
+import { DepartmentMutation } from './department-mutation'
+import { DepartmentHistoryEntitySubscriber } from './event-subscriber'
+
+export const entities = [Department, DepartmentHistory]
+export const resolvers = [DepartmentQuery, DepartmentMutation]
+export const subscribers = [DepartmentHistoryEntitySubscriber]

package/server/service/employee/employee-history.ts

@@ -0,0 +1,173 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import { Column, Entity, Index, ManyToOne, OneToMany, PrimaryGeneratedColumn, RelationId } from 'typeorm'
+
+import {
+  HistoryActionColumn,
+  HistoryActionType,
+  HistoryEntityInterface,
+  HistoryOriginalIdColumn
+} from '@operato/typeorm-history'
+
+import { User } from '@things-factory/auth-base'
+import { Contact } from '@things-factory/contact'
+
+import { config } from '@things-factory/env'
+import { Domain } from '@things-factory/shell'
+
+import { Employee, EmployeeType } from './employee'
+import { Department } from '../department/department'
+
+const ORMCONFIG = config.get('ormconfig', {})
+const DATABASE_TYPE = ORMCONFIG.type
+
+@Entity()
+@Index(
+  'ix_employee_history_0',
+  (employeeHistory: EmployeeHistory) => [employeeHistory.originalId, employeeHistory.version],
+  { unique: true }
+)
+@Index(
+  'ix_employee_history_1',
+  (employeeHistory: EmployeeHistory) => [employeeHistory.domain, employeeHistory.originalId, employeeHistory.version],
+  { unique: true }
+)
+@ObjectType({ description: 'History Entity of Employee' })
+export class EmployeeHistory implements HistoryEntityInterface<Employee> {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @Column({ nullable: true, default: 1 })
+  @Field({ nullable: true })
+  version?: number = 1
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain)
+  domain?: Domain
+
+  @RelationId((employee: Employee) => employee.domain)
+  domainId?: string
+
+  @Column()
+  @Field()
+  controlNo: string
+
+  @Column()
+  @Field({ nullable: true })
+  name?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  alias?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  jobResponsibility?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  jobPosition?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  note?: string
+
+  @ManyToOne(type => Employee, supervisor => supervisor.supervises, { nullable: true })
+  @Field({ nullable: true })
+  supervisor?: Employee
+
+  @RelationId((employee: Employee) => employee.supervisor)
+  supervisorId?: string
+
+  @OneToMany(type => Employee, employee => employee.supervisor)
+  @Field(type => [Employee])
+  supervises?: Employee[]
+
+  @OneToMany(type => Department, department => department.manager)
+  @Field(type => [Department])
+  manages?: Department[]
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  type?: EmployeeType
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  hiredOn?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  retiredAt?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  extension?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  deletedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((employee: Employee) => employee.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((employee: Employee) => employee.updater)
+  updaterId?: string
+
+  @Field(type => String, { nullable: true })
+  photo?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  user?: User
+
+  @RelationId((employee: Employee) => employee.user)
+  userId?: string
+
+  @ManyToOne(type => Contact, { nullable: true })
+  @Field({ nullable: true })
+  contact?: Contact
+
+  @RelationId((employee: Employee) => employee.contact)
+  contactId?: string
+
+  @HistoryOriginalIdColumn()
+  public originalId!: string
+
+  @HistoryActionColumn({
+    nullable: false,
+    type:
+      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
+        ? 'enum'
+        : DATABASE_TYPE == 'oracle'
+          ? 'varchar2'
+          : DATABASE_TYPE == 'mssql'
+            ? 'nvarchar'
+            : 'varchar',
+    enum:
+      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
+        ? HistoryActionType
+        : undefined,
+    length: DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb' ? undefined : 10
+  })
+  public action!: HistoryActionType
+}

package/server/service/employee/employee-mutation.ts

@@ -0,0 +1,386 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { getRepository } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { createAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
+import { Contact } from '@things-factory/contact'
+
+import { Employee } from './employee'
+import { NewEmployee, EmployeePatch } from './employee-type'
+import { Department } from '../department/department'
+
+import {
+  onDeleteEmployeeAsSystemUser,
+  onUpdateEmployeeAsSystemUser,
+  registerEmployeeAsSystemUser
+} from '../../controllers/register-employee-as-system-user'
+
+@Resolver(Employee)
+export class EmployeeMutation {
+  @Directive('@transaction')
+  @Directive('@privilege(category: "employee", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => Employee, {
+    description:
+      'Creates a new employee record with the provided details. Optionally associates the employee with a supervisor, department, and system user. If a photo is provided, it will be attached to the employee record.'
+  })
+  async createEmployee(@Arg('employee') employee: NewEmployee, @Ctx() context: ResolverContext): Promise<Employee> {
+    const { domain, user, tx } = context.state
+
+    const supervisor =
+      'supervisor' in employee
+        ? employee.supervisor && (await getRepository(Employee, tx).findOneBy({ id: employee.supervisor.id }))
+        : undefined
+
+    const department =
+      'department' in employee
+        ? employee.department && (await getRepository(Department, tx).findOneBy({ id: employee.department.id }))
+        : undefined
+
+    const connectedUser =
+      'user' in employee
+        ? employee.user && (await getRepository(User, tx).findOneBy({ id: employee.user.id }))
+        : undefined
+
+    const result = await getRepository(Employee, tx).save({
+      ...employee,
+      supervisor,
+      department,
+      user: connectedUser,
+      domain,
+      creator: user,
+      updater: user
+    })
+
+    if (employee.photo) {
+      await createAttachment(
+        null,
+        {
+          attachment: {
+            file: employee.photo,
+            refType: Employee.name,
+            refBy: result.id
+          }
+        },
+        context
+      )
+    }
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "employee", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => Employee, {
+    description:
+      'Updates the details of an existing employee identified by the given ID. Optionally updates the supervisor, department, system user, and photo associated with the employee.'
+  })
+  async updateEmployee(
+    @Arg('id') id: string,
+    @Arg('patch') patch: EmployeePatch,
+    @Ctx() context: ResolverContext
+  ): Promise<Employee> {
+    const { domain, user, tx } = context.state
+
+    const supervisor =
+      'supervisor' in patch
+        ? patch.supervisor && (await getRepository(Employee, tx).findOneBy({ id: patch.supervisor.id }))
+        : undefined
+
+    const department =
+      'department' in patch
+        ? patch.department && (await getRepository(Department, tx).findOneBy({ id: patch.department.id }))
+        : undefined
+
+    const connectedUser =
+      'user' in patch ? patch.user && (await getRepository(User, tx).findOneBy({ id: patch.user.id })) : undefined
+
+    const repository = getRepository(Employee, tx)
+    const employee = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    await onUpdateEmployeeAsSystemUser(patch, context)
+
+    const result = await repository.save({
+      ...employee,
+      ...patch,
+      supervisor,
+      department,
+      user: connectedUser,
+      updater: user
+    })
+
+    if (patch.photo) {
+      await deleteAttachmentsByRef(null, { refBys: [result.id] }, context)
+      await createAttachment(
+        null,
+        {
+          attachment: {
+            file: patch.photo,
+            refType: Employee.name,
+            refBy: result.id
+          }
+        },
+        context
+      )
+    }
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "employee", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => [Employee], {
+    description:
+      'Updates or creates multiple employee records based on the provided patches. New employees are created if the "cuFlag" is "+", and existing employees are updated if the "cuFlag" is "M".'
+  })
+  async updateMultipleEmployee(
+    @Arg('patches', type => [EmployeePatch]) patches: EmployeePatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<Employee[]> {
+    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 employeeRepo = getRepository(Employee, tx)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const supervisor =
+          'supervisor' in newRecord
+            ? newRecord.supervisor && (await getRepository(Employee, tx).findOneBy({ id: newRecord.supervisor.id }))
+            : undefined
+
+        const department =
+          'department' in newRecord
+            ? newRecord.department && (await getRepository(Department, tx).findOneBy({ id: newRecord.department.id }))
+            : undefined
+
+        const connectedUser =
+          'user' in newRecord
+            ? newRecord.user && (await getRepository(User, tx).findOneBy({ id: newRecord.user.id }))
+            : undefined
+
+        const result = await employeeRepo.save({
+          ...newRecord,
+          supervisor,
+          department,
+          user: connectedUser,
+          domain,
+          creator: user,
+          updater: user
+        })
+
+        if (newRecord.photo) {
+          await createAttachment(
+            null,
+            {
+              attachment: {
+                file: newRecord.photo,
+                refType: Employee.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 supervisor =
+          'supervisor' in updateRecord
+            ? updateRecord.supervisor &&
+              (await getRepository(Employee, tx).findOneBy({ id: updateRecord.supervisor.id }))
+            : undefined
+
+        const department =
+          'department' in updateRecord
+            ? updateRecord.department &&
+              (await getRepository(Department, tx).findOneBy({ id: updateRecord.department.id }))
+            : undefined
+
+        const connectedUser =
+          'user' in updateRecord
+            ? updateRecord.user && (await getRepository(User, tx).findOneBy({ id: updateRecord.user.id }))
+            : undefined
+
+        const employee = await employeeRepo.findOneBy({ id: updateRecord.id })
+
+        await onUpdateEmployeeAsSystemUser(updateRecord, context)
+
+        const result = await employeeRepo.save({
+          ...employee,
+          ...updateRecord,
+          supervisor,
+          department,
+          user: connectedUser,
+          updater: user
+        })
+
+        if (updateRecord.photo) {
+          await deleteAttachmentsByRef(null, { refBys: [result.id] }, context)
+          await createAttachment(
+            null,
+            {
+              attachment: {
+                file: updateRecord.photo,
+                refType: Employee.name,
+                refBy: result.id
+              }
+            },
+            context
+          )
+        }
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "employee", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => Boolean, {
+    description:
+      'Deletes an employee record identified by the given ID. Also deletes any attachments associated with the employee.'
+  })
+  async deleteEmployee(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await onDeleteEmployeeAsSystemUser(id, context)
+    await getRepository(Employee, tx).delete({ domain: { id: domain.id }, id })
+    await deleteAttachmentsByRef(null, { refBys: [id] }, context)
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "employee", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => Boolean, {
+    description:
+      'Deletes multiple employee records identified by the given IDs. Also deletes any attachments associated with each employee.'
+  })
+  async deleteEmployees(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    for (let id of ids) {
+      await await onDeleteEmployeeAsSystemUser(id, context)
+    }
+
+    await getRepository(Employee, tx).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+
+    await deleteAttachmentsByRef(null, { refBys: ids }, context)
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "employee", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => Boolean, {
+    description:
+      'Imports multiple employee records into the system. Each employee record must be provided in the EmployeePatch format.'
+  })
+  async importEmployees(
+    @Arg('employees', type => [EmployeePatch]) employees: EmployeePatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await Promise.all(
+      employees.map(async (employee: EmployeePatch) => {
+        const createdEmployee: Employee = await getRepository(Employee, tx).save({ domain, ...employee })
+      })
+    )
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "employee", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => Employee, {
+    description:
+      'Attaches an existing contact to an employee. The contact is identified by its ID and the employee is identified by their ID.'
+  })
+  async attachContact(
+    @Arg('id') id: string,
+    @Arg('contactId') contactId: string,
+    @Ctx() context: ResolverContext
+  ): Promise<Employee> {
+    const { domain, user, tx } = context.state
+
+    const employeeRepository = getRepository(Employee, tx)
+    const employee = await employeeRepository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    const contactRepository = getRepository(Contact, tx)
+    const contact = await contactRepository.findOne({
+      where: { domain: { id: domain.id }, id: contactId }
+    })
+
+    if (!contact) {
+      throw Error(`Contact not found with given contactId(${contactId}).`)
+    }
+
+    const result = await employeeRepository.save({
+      ...employee,
+      name: contact.name,
+      contact: { id: contactId },
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "employee", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => Employee, {
+    description: 'Detaches an existing contact from an employee. The employee is identified by their ID.'
+  })
+  async detachContact(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Employee> {
+    const { domain, user, tx } = context.state
+
+    const repository = getRepository(Employee, tx)
+    const employee = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    const result = await repository.save({
+      ...employee,
+      contact: null,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "user", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => Boolean, {
+    description:
+      'Registers an existing employee as a system user, granting them access to the system. The employee is identified by their ID.'
+  })
+  async registerEmployeeAsSystemUser(
+    @Arg('employeeId', { description: 'Employee Id' }) employeeId: string,
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    return !!(await registerEmployeeAsSystemUser(employeeId, context))
+  }
+}