@things-factory/organization 8.0.5 → 9.0.0-beta.12

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

@@ -1,172 +0,0 @@
-import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
-import { GraphQLEmailAddress } from 'graphql-scalars'
-import { Attachment } from '@things-factory/attachment-base'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { Contact, ContactItem, ContactField, Profile } from '@things-factory/contact'
-import { Employee } from './employee'
-import { EmployeeList } from './employee-type'
-import { Department } from '../department/department'
-
-async function getContactItem(contactId: string, type: string, label: string, context: ResolverContext) {
-  const { domain } = context.state
-  const contact: Contact = await getRepository(Contact).findOne({ where: { domain: { id: domain.id }, id: contactId } })
-  const { items } = contact
-
-  if (!items || !(items instanceof Array)) {
-    return
-  }
-
-  return items?.find(item => item.type === type && item.label === label)?.value
-}
-
-@Resolver(Employee)
-export class EmployeeQuery {
-  @Directive('@privilege(category: "employee", privilege: "query", domainOwnerGranted: true)')
-  @Query(returns => Employee!, {
-    nullable: true,
-    description:
-      'Fetches a specific employee by their unique ID. Returns the employee object if found, or null if not found.'
-  })
-  async employee(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Employee> {
-    const { domain } = context.state
-
-    return await getRepository(Employee).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Directive('@privilege(category: "employee", privilege: "query", domainOwnerGranted: true)')
-  @Query(returns => EmployeeList, {
-    description:
-      'Fetches a list of employees based on provided query parameters. Supports searching by name, control number, and alias.'
-  })
-  async employees(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<EmployeeList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: await getRepository(Employee),
-      searchables: ['name', 'controlNo', 'alias']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => String, { nullable: true })
-  async photo(@Root() employee: Employee): Promise<string | undefined> {
-    const attachment: Attachment = await getRepository(Attachment).findOne({
-      where: {
-        domain: { id: employee.domainId },
-        refType: Employee.name,
-        refBy: employee.id
-      }
-    })
-
-    return attachment?.fullpath
-  }
-
-  @FieldResolver(type => String, { nullable: true })
-  async phone(@Root() employee: Employee, @Ctx() context: ResolverContext): Promise<string> {
-    if (!employee.contactId) {
-      return
-    }
-
-    return await getContactItem(employee.contactId, ContactField.Phone, 'work', context)
-  }
-
-  @FieldResolver(type => String, { nullable: true })
-  async address(@Root() employee: Employee, @Ctx() context: ResolverContext): Promise<string | undefined> {
-    if (!employee.contactId) {
-      return
-    }
-
-    return await getContactItem(employee.contactId, ContactField.Address, 'work', context)
-  }
-
-  @FieldResolver(type => GraphQLEmailAddress, { nullable: true })
-  async email(@Root() employee: Employee, @Ctx() context: ResolverContext): Promise<string | undefined> {
-    if (!employee.contactId) {
-      return
-    }
-
-    return await getContactItem(employee.contactId, ContactField.Email, 'work', context)
-  }
-
-  @FieldResolver(type => Profile)
-  async profile(@Root() employee: Employee): Promise<Profile> {
-    if (!employee.contactId) {
-      return
-    }
-
-    let contact: Contact = employee.contact
-    if (!contact) {
-      contact = await getRepository(Contact).findOneBy({
-        id: employee.contactId
-      })
-
-      if (!contact) {
-        return
-      }
-    }
-
-    const { id: refBy } = contact
-    const { left, top, zoom } = contact.profile || {}
-
-    const attachment: Attachment = await getRepository(Attachment).findOne({
-      where: {
-        domain: { id: contact.domainId },
-        refType: Contact.name,
-        refBy
-      }
-    })
-
-    return { left, top, zoom, picture: attachment?.fullpath }
-  }
-
-  @FieldResolver(type => Department)
-  async department(@Root() employee: Employee): Promise<Department> {
-    if (employee.departmentId) {
-      return await getRepository(Department).findOneBy({ id: employee.departmentId })
-    }
-  }
-
-  @FieldResolver(type => User)
-  async user(@Root() employee: Employee): Promise<User> {
-    if (employee.userId) {
-      return await getRepository(User).findOneBy({ id: employee.userId })
-    }
-  }
-
-  @FieldResolver(type => Employee)
-  async supervisor(@Root() employee: Employee): Promise<Employee> {
-    if (employee.supervisorId) {
-      return await getRepository(Employee).findOneBy({ id: employee.supervisorId })
-    }
-  }
-
-  @FieldResolver(type => Contact)
-  async contact(@Root() employee: Employee): Promise<Contact> {
-    if (employee.contactId) {
-      return await getRepository(Contact).findOneBy({ id: employee.contactId })
-    }
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() employee: Employee): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: employee.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() employee: Employee): Promise<User> {
-    return await getRepository(User).findOneBy({ id: employee.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() employee: Employee): Promise<User> {
-    return await getRepository(User).findOneBy({ id: employee.creatorId })
-  }
-}

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

@@ -1,176 +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 { GraphQLEmailAddress } from 'graphql-scalars'
-
-import { ObjectRef, ScalarObject } from '@things-factory/shell'
-
-import { Employee, EmployeeType } from './employee'
-
-@InputType()
-export class ObjectRefForEmployee extends ObjectRef {
-  @Field({ nullable: true })
-  controlNo?: string
-
-  @Field(type => EmployeeType, { nullable: true })
-  type?: EmployeeType
-
-  @Field({ nullable: true })
-  alias?: string
-
-  @Field({ nullable: true })
-  photo?: string
-
-  @Field(type => GraphQLEmailAddress, { nullable: true })
-  email?: string
-
-  @Field({ nullable: true })
-  jobPosition?: string
-
-  @Field({ nullable: true })
-  jobResponsibility?: string
-
-  @Field({ nullable: true })
-  hiredOn?: string
-
-  @Field({ nullable: true })
-  active?: boolean
-}
-
-@InputType()
-export class ObjectRefForContact extends ObjectRef {
-  @Field(type => GraphQLEmailAddress, { nullable: true })
-  email?: string
-
-  @Field({ nullable: true })
-  phone?: string
-
-  @Field({ nullable: true })
-  address?: string
-}
-
-@InputType()
-export class ObjectRefForDepartment extends ObjectRef {
-  @Field({ nullable: true })
-  controlNo?: string
-}
-
-@InputType()
-export class ObjectRefForUser extends ObjectRef {
-  @Field(type => GraphQLEmailAddress, { nullable: true })
-  email?: string
-}
-
-@InputType()
-export class NewEmployee {
-  @Field()
-  controlNo: string
-
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  alias?: string
-
-  @Field({ nullable: true })
-  jobResponsibility?: string
-
-  @Field({ nullable: true })
-  jobPosition?: string
-
-  @Field(type => EmployeeType, { nullable: true })
-  type?: EmployeeType
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field({ nullable: true })
-  extension?: string
-
-  @Field({ nullable: true })
-  hiredOn?: string
-
-  @Field({ nullable: true })
-  retiredAt?: string
-
-  @Field(type => GraphQLUpload, { nullable: true })
-  photo?: FileUpload
-
-  @Field({ nullable: true })
-  note?: string
-
-  @Field(type => ObjectRefForEmployee, { nullable: true })
-  supervisor?: ObjectRefForEmployee
-
-  @Field(type => ObjectRefForDepartment, { nullable: true })
-  department?: ObjectRefForDepartment
-
-  @Field(type => ObjectRefForContact, { nullable: true })
-  contact?: ObjectRefForContact
-
-  @Field(type => ObjectRefForUser, { nullable: true })
-  user?: ObjectRefForUser
-}
-
-@InputType()
-export class EmployeePatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  controlNo?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  alias?: string
-
-  @Field({ nullable: true })
-  jobResponsibility?: string
-
-  @Field({ nullable: true })
-  jobPosition?: string
-
-  @Field(type => EmployeeType, { nullable: true })
-  type?: EmployeeType
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field({ nullable: true })
-  hiredOn?: string
-
-  @Field({ nullable: true })
-  retiredAt?: string
-
-  @Field(type => GraphQLUpload, { nullable: true })
-  photo?: FileUpload
-
-  @Field({ nullable: true })
-  note?: string
-
-  @Field(type => ObjectRefForEmployee, { nullable: true })
-  supervisor?: ObjectRefForEmployee
-
-  @Field(type => ObjectRefForDepartment, { nullable: true })
-  department?: ObjectRefForDepartment
-
-  @Field(type => ObjectRefForContact, { nullable: true })
-  contact?: ObjectRefForContact
-
-  @Field(type => ObjectRefForUser, { nullable: true })
-  user?: ObjectRefForUser
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class EmployeeList {
-  @Field(type => [Employee])
-  items: Employee[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/employee/employee.ts

@@ -1,177 +0,0 @@
-import {
-  CreateDateColumn,
-  UpdateDateColumn,
-  DeleteDateColumn,
-  Entity,
-  Index,
-  Column,
-  OneToMany,
-  RelationId,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  VersionColumn
-} from 'typeorm'
-import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
-import { GraphQLEmailAddress } from 'graphql-scalars'
-
-import { Domain } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { Contact, Profile } from '@things-factory/contact'
-
-import { Department } from '../department/department'
-import { ApprovalLine } from '../approval-line/approval-line'
-
-export enum EmployeeType {
-  FULLTIME = 'FULLTIME',
-  PARTTIME = 'PARTTIME',
-  TEMPORARY = 'TEMPORARY'
-}
-
-registerEnumType(EmployeeType, {
-  name: 'EmployeeType',
-  description: 'type enumeration of a employee'
-})
-
-@Entity()
-@Index('ix_employee_0', (employee: Employee) => [employee.domain, employee.controlNo, employee.deletedAt], {
-  unique: true
-})
-@ObjectType({ description: 'Entity for Employee' })
-export class Employee {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @VersionColumn()
-  @Field({ nullable: true })
-  version?: number = 1
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain)
-  domain?: Domain
-
-  @RelationId((employee: Employee) => employee.domain)
-  domainId?: string
-
-  @Column()
-  @Field({ nullable: false })
-  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
-
-  @ManyToOne(type => Employee, supervisor => supervisor.supervises, { nullable: true })
-  @Field(type => Employee, { nullable: true })
-  supervisor?: Employee
-
-  @RelationId((employee: Employee) => employee.supervisor)
-  supervisorId?: string
-
-  @OneToMany(type => Employee, employee => employee.supervisor)
-  @Field(type => [Employee])
-  supervises?: Employee[]
-
-  @ManyToOne(type => Department, department => department.members, { nullable: true })
-  @Field(type => Department, { nullable: true })
-  department?: Department
-
-  @RelationId((employee: Employee) => employee.department)
-  departmentId?: string
-
-  @OneToMany(type => Department, department => department.manager)
-  @Field(type => [Department])
-  manages?: Department[]
-
-  @OneToMany(type => ApprovalLine, employee => employee.ownerEmployee)
-  @Field(type => [ApprovalLine])
-  approvalLines?: ApprovalLine[]
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  type?: EmployeeType
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  extension?: 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
-
-  @Field(type => GraphQLEmailAddress, { nullable: true })
-  email?: string
-
-  @Field({ nullable: true })
-  phone?: string
-
-  @Field(type => Profile, { nullable: true })
-  profile?: Profile
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  note?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  hiredOn?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  retiredAt?: 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((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
-}

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

@@ -1,17 +0,0 @@
-import { EventSubscriber } from 'typeorm'
-
-import { HistoryEntitySubscriber } from '@operato/typeorm-history'
-
-import { Employee } from './employee'
-import { EmployeeHistory } from './employee-history'
-
-@EventSubscriber()
-export class EmployeeHistoryEntitySubscriber extends HistoryEntitySubscriber<Employee, EmployeeHistory> {
-  public get entity() {
-    return Employee
-  }
-
-  public get historyEntity() {
-    return EmployeeHistory
-  }
-}

package/server/service/employee/index.ts

@@ -1,9 +0,0 @@
-import { Employee } from './employee'
-import { EmployeeHistory } from './employee-history'
-import { EmployeeQuery } from './employee-query'
-import { EmployeeMutation } from './employee-mutation'
-import { EmployeeHistoryEntitySubscriber } from './event-subscriber'
-
-export const entities = [Employee, EmployeeHistory]
-export const resolvers = [EmployeeQuery, EmployeeMutation]
-export const subscribers = [EmployeeHistoryEntitySubscriber]

package/server/service/index.ts

@@ -1,39 +0,0 @@
-/* EXPORT ENTITY TYPES */
-export * from './approval-line/approval-line'
-export * from './department/department'
-export * from './employee/employee'
-
-/* IMPORT ENTITIES AND RESOLVERS */
-import { entities as ApprovalLineEntities, resolvers as ApprovalLineResolvers } from './approval-line'
-import {
-  entities as DepartmentEntities,
-  resolvers as DepartmentResolvers,
-  subscribers as DepartmentSubscribers
-} from './department'
-import {
-  entities as EmployeeEntities,
-  resolvers as EmployeeResolvers,
-  subscribers as EmployeeSubscribers
-} from './employee'
-
-export const entities = [
-  /* ENTITIES */
-  ...ApprovalLineEntities,
-  ...DepartmentEntities,
-  ...EmployeeEntities
-]
-
-export const subscribers = [
-  /* SUBSCRIBERS */
-  ...DepartmentSubscribers,
-  ...EmployeeSubscribers
-]
-
-export const schema = {
-  resolverClasses: [
-    /* RESOLVER CLASSES */
-    ...ApprovalLineResolvers,
-    ...DepartmentResolvers,
-    ...EmployeeResolvers
-  ]
-}

package/server/tsconfig.json

@@ -1,10 +0,0 @@
-{
-  "extends": "../../tsconfig-base.json",
-  "compilerOptions": {
-    "strict": false,
-    "module": "commonjs",
-    "outDir": "../dist-server",
-    "baseUrl": "./"
-  },
-  "include": ["./**/*"]
-}