@things-factory/biz-base 8.0.0-beta.9 → 8.0.0

package/server/service/company/company.ts

@@ -0,0 +1,105 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { Bizplace } from '../bizplace/bizplace'
+
+@Entity()
+@Index('ix_companies_0', (company: Company) => [company.name], { unique: true })
+@Index('ix_companies_1', (company: Company) => [company.domain], { unique: false })
+@ObjectType()
+export class Company {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain)
+  domain?: Domain
+
+  @RelationId((company: Company) => company.domain)
+  @Field()
+  domainId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  description: string
+
+  @Column()
+  @Field()
+  countryCode: string
+
+  @Column()
+  @Field()
+  brn: string
+
+  @Column()
+  @Field()
+  address: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  postalCode: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  type: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  status: string
+
+  @OneToMany(type => Bizplace, bizplace => bizplace.company)
+  @Field(type => [Bizplace])
+  bizplaces: Bizplace[]
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field(type => User, { nullable: true })
+  creator: User
+
+  @RelationId((company: Company) => company.creator)
+  creatorId: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field(type => User, { nullable: true })
+  updater: User
+
+  @RelationId((company: Company) => company.updater)
+  updaterId: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt: Date
+}

package/server/service/company/index.ts

@@ -0,0 +1,6 @@
+import { Company } from './company'
+import { CompanyMutation } from './company-mutation'
+import { CompanyQuery } from './company-query'
+
+export const entities = [Company]
+export const resolvers = [CompanyQuery, CompanyMutation]

package/server/service/contact-point/contact-point-mutation.ts

@@ -0,0 +1,165 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, Repository } from 'typeorm'
+
+import { getRepository } from '@things-factory/shell'
+
+import { Bizplace } from '../bizplace/bizplace'
+import { ContactPoint } from './contact-point'
+import { ContactPointPatch, NewContactPoint } from './contact-point-types'
+
+@Resolver(ContactPoint)
+export class ContactPointMutation {
+  @Directive('@privilege(category: "contact_point", privilege: "mutation")')
+  @Mutation(returns => ContactPoint)
+  async createContactPoint(
+    @Arg('contactPoint') contactPoint: NewContactPoint,
+    @Ctx() context: ResolverContext
+  ): Promise<ContactPoint> {
+    return await createContactPoint(contactPoint as any, context)
+  }
+
+  @Directive('@privilege(category: "contact_point", privilege: "mutation")')
+  @Mutation(returns => ContactPoint)
+  async updateContactPoint(
+    @Arg('id') id: string,
+    @Arg('patch') patch: ContactPointPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<ContactPoint> {
+    const contactPoint = await getRepository(ContactPoint).findOneBy({ id })
+
+    if (patch.bizplace && patch.bizplace.id) {
+      patch.bizplace = await getRepository(Bizplace).findOneBy({ id: patch.bizplace.id })
+    }
+
+    return await getRepository(ContactPoint).save({
+      ...contactPoint,
+      ...patch,
+      updater: context.state.user
+    })
+  }
+
+  @Directive('@privilege(category: "contact_point", privilege: "mutation")')
+  @Mutation(returns => [ContactPoint])
+  async updateMultipleContactPoint(
+    @Arg('patches', type => [ContactPointPatch]) patches: ContactPointPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<ContactPoint[]> {
+    const { tx } = context.state
+    let results = []
+    const { createRecords, updateRecords, deleteRecords } = patches.reduce(
+      (records, patch) => {
+        if (patch.cuFlag.toUpperCase() === '+') {
+          records.createRecords.push(patch)
+        } else if (patch.cuFlag.toUpperCase() === 'M') {
+          records.updateRecords.push(patch)
+        } else {
+          records.deleteRecords.push(patch)
+        }
+        return records
+      },
+      {
+        createRecords: [],
+        updateRecords: [],
+        deleteRecords: []
+      }
+    )
+
+    if (createRecords.length > 0) {
+      for (let i = 0; i < createRecords.length; i++) {
+        const result = await createContactPoint(createRecords[i], context, tx)
+        results.push(result)
+      }
+    }
+
+    if (updateRecords.length > 0) {
+      for (let i = 0; i < updateRecords.length; i++) {
+        const result = await updateContactPoint(updateRecords[i].id, updateRecords[i], context, tx)
+        results.push(result)
+      }
+    }
+
+    if (deleteRecords.length > 0) {
+      for (let i = 0; i < deleteRecords.length; i++) {
+        await deleteContactPoint(deleteRecords[i].id, tx)
+        results.push(deleteRecords[i])
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@privilege(category: "contact_point", privilege: "mutation")')
+  @Mutation(returns => Boolean)
+  async deleteContactPoint(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Boolean> {
+    await deleteContactPoint(id, context.state.tx)
+
+    return true
+  }
+
+  @Directive('@privilege(category: "contact_point", privilege: "mutation")')
+  @Mutation(returns => Boolean)
+  async deleteContactPoints(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<Boolean> {
+    await getRepository(ContactPoint).delete(ids)
+
+    return true
+  }
+}
+
+export async function createContactPoint(
+  contactPoint: Partial<ContactPoint>,
+  context: any,
+  tx?: EntityManager
+): Promise<ContactPoint> {
+  const { domain, user } = context.state
+
+  const bizplaceRepo: Repository<Bizplace> = tx?.getRepository(Bizplace) || getRepository(Bizplace)
+  const contactPointRepo: Repository<ContactPoint> = tx?.getRepository(ContactPoint) || getRepository(ContactPoint)
+
+  if (!contactPoint.bizplace?.id) {
+    contactPoint.bizplace = await bizplaceRepo.findOne({ where: { name: domain.name } })
+  } else {
+    contactPoint.bizplace = await bizplaceRepo.findOneBy({ id: contactPoint.bizplace.id })
+  }
+
+  return await contactPointRepo.save({
+    ...contactPoint,
+    domain,
+    creator: user,
+    updater: user
+  })
+}
+
+export async function updateContactPoint(
+  id: string,
+  patch: Partial<ContactPoint>,
+  context: any,
+  tx?: EntityManager
+): Promise<ContactPoint> {
+  const bizplaceRepo: Repository<Bizplace> = tx?.getRepository(Bizplace) || getRepository(Bizplace)
+  const contactPointRepo: Repository<ContactPoint> = tx?.getRepository(ContactPoint) || getRepository(ContactPoint)
+
+  const { domain, user } = context.state
+  let contactPoint: ContactPoint = await contactPointRepo.findOne({ where: { id }, relations: ['bizplace'] })
+
+  if (!contactPoint?.bizplace?.id) {
+    patch.bizplace = await bizplaceRepo.findOne({ where: { name: domain.name } })
+  }
+
+  if (patch?.bizplace?.id) {
+    patch.bizplace = await bizplaceRepo.findOneBy({ id: patch.bizplace.id })
+  }
+
+  return await contactPointRepo.save({
+    ...contactPoint,
+    ...patch,
+    updater: user
+  })
+}
+
+export async function deleteContactPoint(id: string, tx?: EntityManager): Promise<void> {
+  const contactPointRepo: Repository<ContactPoint> = tx?.getRepository(ContactPoint) || getRepository(ContactPoint)
+  await contactPointRepo.delete(id)
+}

package/server/service/contact-point/contact-point-query.ts

@@ -0,0 +1,43 @@
+import { Arg, Args, Ctx, Directive, Query, Resolver } from 'type-graphql'
+
+import { getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { ContactPoint } from './contact-point'
+import { ContactPointList } from './contact-point-types'
+
+@Resolver(ContactPoint)
+export class ContactPointQuery {
+  @Directive('@privilege(category: "contact_point", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => ContactPoint)
+  async contactPoint(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<ContactPoint> {
+    return await getRepository(ContactPoint).findOne({
+      where: { domain: { id: context.state.domain.id }, name },
+      relations: ['domain', 'bizplace', 'creator', 'updater']
+    })
+  }
+
+  @Directive('@privilege(category: "contact_point", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => ContactPointList)
+  async contactPoints(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<ContactPointList> {
+    const { domain } = context.state
+    const queryBuilder = await getQueryBuilderFromListParams({
+      repository: getRepository(ContactPoint),
+      alias: 'ContactPoint',
+      params,
+      domain,
+      searchables: ['name', 'address', 'postCode', 'phone', 'email']
+    })
+
+    const [items, total] = await queryBuilder
+      .leftJoinAndSelect('ContactPoint.domain', 'Domain')
+      .leftJoinAndSelect('ContactPoint.bizplace', 'Bizplace')
+      .leftJoinAndSelect('ContactPoint.creator', 'Creator')
+      .leftJoinAndSelect('ContactPoint.updater', 'Updater')
+      .getManyAndCount()
+
+    return { items, total }
+  }
+}

package/server/service/contact-point/contact-point-types.ts

@@ -0,0 +1,152 @@
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef } from '@things-factory/shell'
+
+import { ContactPoint } from './contact-point'
+
+@ObjectType()
+export class ContactPointList {
+  @Field(type => [ContactPoint], { nullable: true })
+  items: ContactPoint[]
+
+  @Field(type => Int, { nullable: true })
+  total: number
+}
+
+@InputType()
+export class ContactPointPatch {
+  @Field({ nullable: true })
+  id?: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  bizplace?: ObjectRef
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  email?: string
+
+  @Field({ nullable: true })
+  companyName?: string
+
+  @Field({ nullable: true })
+  representativeName?: string
+
+  @Field({ nullable: true })
+  managerName?: string
+
+  @Field({ nullable: true })
+  accountNo?: string
+
+  @Field({ nullable: true })
+  address?: string
+
+  @Field({ nullable: true })
+  address2?: string
+
+  @Field({ nullable: true })
+  city?: string
+
+  @Field({ nullable: true })
+  state?: string
+
+  @Field({ nullable: true })
+  postCode?: string
+
+  @Field({ nullable: true })
+  billingAddress?: string
+
+  @Field({ nullable: true })
+  fax?: string
+
+  @Field({ nullable: true })
+  fax2?: string
+
+  @Field({ nullable: true })
+  phone?: string
+
+  @Field({ nullable: true })
+  phone2?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  type?: string
+
+  @Field({ nullable: true })
+  registrationNo?: string
+
+  @Field({ nullable: true })
+  businessType?: string
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@InputType()
+export class NewContactPoint {
+  @Field(type => ObjectRef)
+  bizplace: ObjectRef
+
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  email?: string
+
+  @Field({ nullable: true })
+  companyName?: string
+
+  @Field({ nullable: true })
+  accountNo?: string
+
+  @Field({ nullable: true })
+  address?: string
+
+  @Field({ nullable: true })
+  address2?: string
+
+  @Field({ nullable: true })
+  city?: string
+
+  @Field({ nullable: true })
+  state?: string
+
+  @Field({ nullable: true })
+  postCode?: string
+
+  @Field({ nullable: true })
+  billingAddress?: string
+
+  @Field({ nullable: true })
+  fax?: string
+
+  @Field({ nullable: true })
+  fax2?: string
+
+  @Field({ nullable: true })
+  phone?: string
+
+  @Field({ nullable: true })
+  phone2?: string
+
+  @Field({ nullable: true })
+  representativeName?: string
+
+  @Field({ nullable: true })
+  managerName?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  type?: string
+
+  @Field({ nullable: true })
+  registrationNo?: string
+
+  @Field({ nullable: true })
+  businessType?: string
+}

package/server/service/contact-point/contact-point.ts

@@ -0,0 +1,132 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import { Column, CreateDateColumn, Entity, Index, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { Bizplace } from '../bizplace/bizplace'
+
+@Entity()
+@Index(
+  'ix_contact_points_0',
+  (contactPoint: ContactPoint) => [
+    contactPoint.name,
+    contactPoint.email,
+    contactPoint.companyName,
+    contactPoint.address,
+    contactPoint.billingAddress,
+    contactPoint.accountNo
+  ],
+  { unique: true }
+)
+@Index('ix_contact_points_1', (contactPoint: ContactPoint) => [contactPoint.registrationNo, contactPoint.type])
+@ObjectType()
+export class ContactPoint {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain)
+  domain?: Domain
+
+  @ManyToOne(type => Bizplace)
+  @Field(type => Bizplace)
+  bizplace: Bizplace
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  email: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  address: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  address2: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  postCode: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  city: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  state: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  billingAddress: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  fax: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  fax2: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  phone: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  phone2: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  companyName: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  representativeName: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  managerName: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  accountNo: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  type: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  registrationNo: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  businessType: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  creator: User
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  updater: User
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt: Date
+}

package/server/service/contact-point/index.ts

@@ -0,0 +1,6 @@
+import { ContactPoint } from './contact-point'
+import { ContactPointMutation } from './contact-point-mutation'
+import { ContactPointQuery } from './contact-point-query'
+
+export const entities = [ContactPoint]
+export const resolvers = [ContactPointQuery, ContactPointMutation]

package/server/service/index.ts

@@ -0,0 +1,46 @@
+/* IMPORT ENTITIES AND RESOLVERS */
+import { entities as BizOptionEntities, resolvers as BizOptionResolvers } from './biz-option'
+import { entities as BizOptionDetailEntities, resolvers as BizOptionDetailResolvers } from './biz-option-detail'
+import { entities as BizplaceEntities, resolvers as BizplaceResolvers } from './bizplace'
+import { entities as CompanyEntities, resolvers as CompanyResolvers } from './company'
+import { entities as ContactPointEntities, resolvers as ContactPointResolvers } from './contact-point'
+import { entities as WorkerEntities, resolvers as WorkerResolvers } from './worker'
+
+/* EXPORT ENTITY TYPES */
+export * from './company/company'
+export * from './bizplace/bizplace'
+export * from './biz-option/biz-option'
+export * from './biz-option-detail/biz-option-detail'
+export * from './contact-point/contact-point'
+export * from './worker/worker'
+
+/* EXPORT TYPES */
+export * from './company/company-types'
+export * from './bizplace/bizplace-types'
+export * from './biz-option/biz-option-types'
+export * from './biz-option-detail/biz-option-detail-types'
+export * from './contact-point/contact-point-types'
+export * from './worker/worker-types'
+
+export const entities = [
+  ...CompanyEntities,
+  ...BizplaceEntities,
+  ...BizOptionEntities,
+  ...BizOptionDetailEntities,
+  ...ContactPointEntities,
+  ...WorkerEntities
+]
+
+export const schema = {
+  resolverClasses: [
+    ...CompanyResolvers,
+    ...BizplaceResolvers,
+    ...BizOptionResolvers,
+    ...BizOptionDetailResolvers,
+    ...ContactPointResolvers,
+    ...WorkerResolvers
+  ]
+}
+
+export { createCompany, deleteCompanies, deleteCompany, updateCompany } from './company/company-mutation'
+export { createWorker, deleteWorker, deleteWorkers, updateWorker } from './worker/worker-mutation'

package/server/service/worker/index.ts

@@ -0,0 +1,6 @@
+import { Worker } from './worker'
+import { WorkerMutation } from './worker-mutation'
+import { WorkerQuery } from './worker-query'
+
+export const entities = [Worker]
+export const resolvers = [WorkerQuery, WorkerMutation]