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

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

@@ -0,0 +1,111 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, In, Repository } from 'typeorm'
+
+import { Domain, getRepository } from '@things-factory/shell'
+
+import { getMyBizplace } from '../../utils'
+import { Worker } from './worker'
+import { NewWorker, WorkerPatch } from './worker-types'
+
+@Resolver(Worker)
+export class WorkerMutation {
+  @Directive('@privilege(category: "worker", privilege: "mutation")')
+  @Mutation(returns => Worker)
+  async createWorker(@Arg('worker') worker: NewWorker, @Ctx() context: ResolverContext): Promise<Worker> {
+    return await createWorker(worker, context.state.domain, context.state.user)
+  }
+
+  @Directive('@privilege(category: "worker", privilege: "mutation")')
+  @Mutation(returns => Worker)
+  async updateWorker(
+    @Arg('id') id: string,
+    @Arg('patch', type => WorkerPatch) patch: WorkerPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<Worker> {
+    return await updateWorker(id, patch, context.state.domain, context.state.user)
+  }
+
+  @Directive('@privilege(category: "worker", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => [Worker])
+  async updateMultipleWorker(
+    @Arg('patches', type => [WorkerPatch]) patches: WorkerPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<Worker[]> {
+    const { tx } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const patch: WorkerPatch = _createRecords[i]
+        const result = await createWorker(patch as NewWorker, context.state.domain, context.state.user, tx)
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const patch: WorkerPatch = _updateRecords[i]
+        const result = await updateWorker(patch.id, patch, context.state.domain, context.state.user, tx)
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@privilege(category: "worker", privilege: "mutation")')
+  @Mutation(returns => Boolean)
+  async deleteWorker(@Arg('id') id: string) {
+    return deleteWorker(id)
+  }
+
+  @Directive('@privilege(category: "worker", privilege: "mutation")')
+  @Mutation(returns => Boolean)
+  async deleteWorkers(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<Boolean> {
+    return deleteWorkers({ ids }, context)
+  }
+}
+
+export async function createWorker(worker: NewWorker, domain: Domain, user: any, trxMgr?: EntityManager) {
+  const repository: Repository<Worker> = trxMgr ? trxMgr.getRepository(Worker) : getRepository(Worker)
+
+  return await repository.save({
+    ...worker,
+    domain,
+    bizplace: await getMyBizplace(domain, user),
+    creator: user,
+    updater: user
+  })
+}
+
+export async function updateWorker(id: string, patch: WorkerPatch, domain: Domain, user: any, trxMgr?: EntityManager) {
+  const repository: Repository<Worker> = trxMgr ? trxMgr.getRepository(Worker) : getRepository(Worker)
+  const worker = await repository.findOneBy({
+    domain: { id: domain.id },
+    id
+  })
+
+  return repository.save({
+    ...worker,
+    ...patch,
+    updater: user
+  })
+}
+
+export async function deleteWorker(id: string, trxMgr?: EntityManager) {
+  const repository: Repository<Worker> = trxMgr ? trxMgr.getRepository(Worker) : getRepository(Worker)
+  return await repository.delete(id)
+}
+
+export async function deleteWorkers({ ids }, _context: any) {
+  const { domain } = _context.state
+  await getRepository(Worker).delete({
+    domain: { id: domain.id },
+    id: In(ids)
+  })
+  return true
+}

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

@@ -0,0 +1,37 @@
+import { Arg, Args, Ctx, Directive, Query, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { convertListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { getPermittedBizplaceIds } from '../../utils'
+import { Worker } from './worker'
+import { WorkerList } from './worker-types'
+
+@Resolver(Worker)
+export class WorkerQuery {
+  @Directive('@privilege(category: "worker", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => Worker)
+  async worker(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Worker> {
+    return await getRepository(Worker).findOne({
+      where: {
+        domain: { id: context.state.domain.id },
+        name,
+        bizplace: In(await getPermittedBizplaceIds(context.state.domain, context.state.user))
+      },
+      relations: ['domain', 'bizplace', 'creator', 'updater']
+    })
+  }
+
+  @Directive('@privilege(category: "worker", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => WorkerList)
+  async workers(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<WorkerList> {
+    const convertedParams = convertListParams(params)
+    convertedParams.where.bizplace = In(await getPermittedBizplaceIds(context.state.domain, context.state.user))
+    const [items, total] = await getRepository(Worker).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'bizplace', 'creator', 'updater']
+    })
+
+    return { items, total }
+  }
+}

package/server/service/worker/worker-types.ts

@@ -0,0 +1,50 @@
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef } from '@things-factory/shell'
+
+import { Worker } from './worker'
+
+@ObjectType()
+export class WorkerList {
+  @Field(type => [Worker], { nullable: true })
+  items?: Worker[]
+
+  @Field(type => Int, { nullable: true })
+  total?: number
+}
+
+@InputType()
+export class NewWorker {
+  @Field(type => ObjectRef)
+  bizplace: ObjectRef
+
+  @Field()
+  name: string
+
+  @Field()
+  type: string
+
+  @Field({ nullable: true })
+  description?: string
+}
+
+@InputType()
+export class WorkerPatch {
+  @Field({ nullable: true })
+  id?: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  bizplace?: ObjectRef
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  type?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}

package/server/service/worker/worker.ts

@@ -0,0 +1,58 @@
+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_worker_0', (worker: Worker) => [worker.domain, worker.name], { unique: true })
+@ObjectType()
+export class Worker {
+  @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()
+  @Field()
+  type: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  description: 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/utils/get-permitted-bizplaces.ts

@@ -0,0 +1,342 @@
+import { EntityManager, In, SelectQueryBuilder } from 'typeorm'
+
+import { checkUserBelongsDomain, Partner, User } from '@things-factory/auth-base'
+import { Domain, getRepository } from '@things-factory/shell'
+
+import { Bizplace } from '../service/bizplace/bizplace'
+
+/**
+ * @description 도메인과 사용자의 관계를 판단하여
+ * 접속한 도메인을 통해 접근 할 수 있는 대상 bizplaces를 찾아 return
+ *
+ * @param domain
+ * @param user
+ */
+export async function getPermittedBizplaces(domain: Domain, user: User, tx?: EntityManager): Promise<Bizplace[]> {
+  const bizplaceRepo = tx ? tx.getRepository(Bizplace) : getRepository(Bizplace)
+
+  // 1. Check whether `user` belongs to `domain` or not
+  let permittedBizplaces: Bizplace[] = []
+  if (await checkUserBelongsDomain(domain, user)) {
+    // If `user` belongs to `domain`
+    // return set of company bizplace, bizplace of passed domain, bizplaces of customers
+
+    if (domain.extType !== 'company') permittedBizplaces.push(await getCompanyBizplace(domain, user, null, tx))
+    permittedBizplaces.push(await bizplaceRepo.findOne({ where: { domain: { id: domain.id } } }))
+    permittedBizplaces = permittedBizplaces.concat(await getCustomerBizplaces(domain, tx))
+  } else {
+    // If `user` doesn't belong to `domain`
+    // return set of company bizplace, bizplaces which `user` can access
+    permittedBizplaces = await getUserBizplaces(user)
+  }
+
+  return permittedBizplaces
+}
+
+export async function getPermittedBizplaceIds(domain: Domain, user: User): Promise<string[] | any[]> {
+  const bizplaces: Bizplace[] = await getPermittedBizplaces(domain, user)
+  return bizplaces.map((bizplace: Bizplace) => bizplace.id || null)
+}
+
+export async function getMyBizplace(domain: Domain, user: User, tx?: EntityManager): Promise<Bizplace> {
+  const bizplaceRepo = tx ? tx.getRepository(Bizplace) : getRepository(Bizplace)
+
+  // Case 1. 도메인에 소속된 사용자
+  // 1. 현재 도메인을 릴레이션으로 가지고 있는 비즈플레이스를 리턴
+
+  if (await checkUserBelongsDomain(domain, user)) {
+    return await bizplaceRepo.findOne({ where: { domain: { id: domain.id } } })
+  } else {
+    const customerBizplaces: Bizplace[] = await getCustomerBizplaces(domain, tx)
+    const userBizplaces: Bizplace[] = await getUserBizplaces(user, tx)
+
+    const customerBizplaceIdSet: Set<string> = new Set(customerBizplaces.map((pb: Bizplace) => pb.id))
+    const userBizplaceIdSet: Set<string> = new Set(userBizplaces.map((ub: Bizplace) => ub.id))
+
+    const myBizplaceIds: string[] = Array.from(customerBizplaceIdSet).filter((pbId: string) =>
+      userBizplaceIdSet.has(pbId)
+    )
+    if (myBizplaceIds.length > 1) console.warn(`User has multiple bizplaces ${myBizplaceIds}`)
+
+    // TODO: 복수의 비즈플레이스를 가지고 있는 사용자는 조회 결과의 첫번째 비즈플레이스만 리턴 받도록 되어 있음
+    // 이런 케이스에 처리 방식을 결정하고 수정해야함
+    return await bizplaceRepo.findOne({
+      where: { id: In(myBizplaceIds) }
+    })
+  }
+}
+
+export async function getOutletBizplace(outletId: string, tx?: EntityManager) {
+  const bizplaceRepo = tx ? tx.getRepository(Bizplace) : getRepository(Bizplace)
+
+  const bizplace: Bizplace = await bizplaceRepo.findOne({
+    where: { id: outletId }
+  })
+  return bizplace
+}
+
+export async function getCompanyBizplace(
+  domain: Domain,
+  user: User,
+  customerBizplaceId?: string,
+  tx?: EntityManager
+): Promise<Bizplace> {
+  const bizplaceRepo = tx ? tx.getRepository(Bizplace) : getRepository(Bizplace)
+
+  let companyDomain: Domain
+
+  if (user) {
+    let myBizplace: Bizplace = await getMyBizplace(domain, user, tx)
+    if (!myBizplace.company?.id) {
+      myBizplace = await bizplaceRepo.findOne({
+        where: { id: myBizplace.id },
+        relations: ['company', 'company.domain']
+      })
+      companyDomain = myBizplace.company.domain
+    }
+  }
+
+  if (customerBizplaceId) {
+    const customerBizplace: Bizplace = await bizplaceRepo.findOne({
+      where: { id: customerBizplaceId },
+      relations: ['company', 'company.domain']
+    })
+
+    companyDomain = customerBizplace.company?.domain
+  }
+  return await bizplaceRepo.findOne({ where: { domain: { id: companyDomain.id } }, relations: ['domain'] })
+}
+
+export async function getCompaniesBizplaces(
+  domains: Domain[],
+  warehouseDomain: Domain,
+  tx?: EntityManager
+): Promise<Bizplace[]> {
+  const bizplaceRepo = tx ? tx.getRepository(Bizplace) : getRepository(Bizplace)
+
+  const partnersBizplaces = await bizplaceRepo
+    .createQueryBuilder('b')
+    .select('b.id', 'id')
+    .addSelect('b.name', 'name')
+    .addSelect('b.description', 'description')
+    .innerJoin('companies', 'c', 'c.domain_id = b.domain_id')
+    .innerJoin('bizplaces', 'b2', 'b2.company_id = c.id')
+    .innerJoin('domains', 'd', 'd.id = b2.domain_id')
+    .innerJoin('partners', 'p', 'p.partner_domain_id = d.id')
+    .where('p.domain_id = :domainId', { domainId: warehouseDomain.id })
+    .andWhere('b2.domain_id IN (:...domainIds)', { domainIds: domains.map(domain => domain.id) })
+    .groupBy('b.id')
+    .addGroupBy('b.name')
+    .addGroupBy('b.description')
+    .getRawMany()
+
+  return partnersBizplaces
+}
+
+export async function getPartnerBizplaceIds(domain: Domain, user: User, tx?: EntityManager): Promise<string[] | any[]> {
+  const bizplaceRepo = tx ? tx.getRepository(Bizplace) : getRepository(Bizplace)
+  const partnerRepo = tx ? tx.getRepository(Partner) : getRepository(Partner)
+
+  let partnerBizplaces: Bizplace[] = []
+
+  const domainBizplace: Bizplace = await bizplaceRepo.findOne({ where: { domain: { id: domain.id } } })
+  if (!domainBizplace) {
+  } else {
+    const partners: Partner[] = await partnerRepo.find({
+      where: { domain: { id: domainBizplace.id } } /* CONFIRMME regarding TYPEORM - compare original logic */,
+      relations: ['partnerBizplace', 'partnerBizplace.company', 'partnerBizplace.company.domain']
+    })
+
+    for (let partner of partners) {
+      partnerBizplaces.push((partner as any).partnerBizplace)
+    }
+  }
+  return partnerBizplaces.map((bizplace: Bizplace) => bizplace.id || null)
+}
+
+export async function getPartnersBizplaces(domain: Domain, user: User, tx?: EntityManager): Promise<Bizplace[]> {
+  const userRepo = tx ? tx.getRepository(User) : getRepository(User)
+  const bizplaceRepo = tx ? tx.getRepository(Bizplace) : getRepository(Bizplace)
+  const partnerRepo = tx ? tx.getRepository(Partner) : getRepository(Partner)
+
+  let partnersBizplaces: Bizplace[] = []
+
+  const qb: SelectQueryBuilder<User> = userRepo
+    .createQueryBuilder('user')
+    .select('user.id', 'userId')
+    .addSelect('role.id', 'roleId')
+    .addSelect('role.name', 'roleName')
+    .addSelect('domain.id', 'domainId')
+    .addSelect('domain.name', 'domainName')
+    .innerJoin('users_roles', 'ur', 'user.id = ur.users_id')
+    .innerJoin('roles', 'role', 'ur.roles_id = role.id')
+    .innerJoin('domains', 'domain', 'role.domain_id = domain.id')
+    .where('user.id = :userId', { userId: user.id })
+    .andWhere('domain.id = :domainId', { domainId: domain.id })
+
+  let userRoles = await qb.getRawMany()
+
+  // detect if user is Customer
+  let foundCustomerRole = userRoles.find(role => role.roleName === 'Customer')
+
+  // get all partners
+  let partnersDomains: Partner[] = await partnerRepo.find({
+    where: { domain: { id: domain.id } },
+    relations: ['partnerDomain']
+  })
+
+  if (foundCustomerRole) {
+    let userDomains = user.domains
+    for (let partDomain of partnersDomains) {
+      for (let userDomain of userDomains) {
+        if (userDomain.id === partDomain.partnerDomain.id) {
+          let partnerBizplace: Bizplace = await bizplaceRepo.findOne({
+            where: { domain: { id: partDomain.partnerDomain.id } },
+            relations: ['company', 'company.domain']
+          })
+
+          partnersBizplaces.push(partnerBizplace)
+        }
+      }
+    }
+  } else {
+    for (let partDomain of partnersDomains) {
+      let partnerBizplace: Bizplace = await bizplaceRepo.findOne({
+        where: { domain: { id: partDomain.partnerDomain.id } },
+        relations: ['company', 'company.domain']
+      })
+
+      partnersBizplaces.push(partnerBizplace)
+    }
+  }
+
+  return partnersBizplaces
+}
+
+export async function getPartnersCompanyBizplaces(
+  domain: Domain,
+  user: User,
+  strictAccess: Boolean = false,
+  tx?: EntityManager
+): Promise<Bizplace[]> {
+  const userRepo = tx ? tx.getRepository(User) : getRepository(User)
+  const bizplaceRepo = tx ? tx.getRepository(Bizplace) : getRepository(Bizplace)
+
+  let partnersBizplaces: Bizplace[] = []
+
+  let userRoles: any = await userRepo
+    .createQueryBuilder('user')
+    .select('user.id', 'userId')
+    .addSelect('role.id', 'roleId')
+    .addSelect('role.name', 'roleName')
+    .addSelect('domain.id', 'domainId')
+    .addSelect('domain.name', 'domainName')
+    .innerJoin('users_roles', 'ur', 'user.id = ur.users_id')
+    .innerJoin('roles', 'role', 'ur.roles_id = role.id')
+    .innerJoin('domains', 'domain', 'role.domain_id = domain.id')
+    .where('user.id = :userId', { userId: user.id })
+    .andWhere('domain.id = :domainId', { domainId: domain.id })
+    .getRawMany()
+
+  if (userRoles.find(role => role.roleName !== 'Customer')) {
+    let qbPartnersBizplaces = bizplaceRepo
+      .createQueryBuilder('b')
+      .select('b.id', 'id')
+      .addSelect('b.name', 'name')
+      .addSelect('b.description', 'description')
+      .innerJoin('companies', 'c', 'c.domain_id = b.domain_id')
+      .innerJoin('bizplaces', 'b2', 'b2.company_id = c.id')
+      .innerJoin('domains', 'd', 'd.id = b2.domain_id')
+      .innerJoin('partners', 'p', 'p.partner_domain_id = d.id')
+      .where('p.domain_id = :domainId', { domainId: domain.id })
+      .groupBy('b.id')
+      .addGroupBy('b.name')
+      .addGroupBy('b.description')
+
+    if (strictAccess) {
+      const userRepo = tx ? tx.getRepository(User) : getRepository(User)
+      qbPartnersBizplaces.andWhere(
+        `exists (
+          ${userRepo
+            .createQueryBuilder('u2')
+            .innerJoin('users_roles', 'ur', 'ur.users_id = u2.id')
+            .innerJoin('roles', 'r', 'r.id = ur.roles_id')
+            .where('r.domain_id = c.domain_id')
+            .andWhere(`r.name IN ('BUSINESS-OWNER','BUSINESS-MANAGER')`)
+            .andWhere(`u2.id = '${user.id}'`)
+            .getQuery()})`
+      )
+    }
+
+    partnersBizplaces = await qbPartnersBizplaces.getRawMany()
+  }
+
+  return partnersBizplaces
+}
+
+export async function getCustomerBizplaces(domain: Domain, tx?: EntityManager): Promise<Bizplace[]> {
+  const partnerRepo = tx ? tx.getRepository(Partner) : getRepository(Partner)
+  const bizplaceRepo = tx ? tx.getRepository(Bizplace) : getRepository(Bizplace)
+
+  const customers: Partner[] = await partnerRepo.find({
+    where: { domain: { id: domain.id } },
+    relations: ['partnerDomain']
+  })
+  const customerDomains: Domain[] = customers.map((customer: Partner) => customer.partnerDomain)
+  return await bizplaceRepo.find({
+    where: { domain: In(customerDomains.map((d: Domain) => d.id)) },
+    relations: ['company', 'company.domain', 'domain']
+  })
+}
+
+export async function getSubdomainBizplace(subdomain: string, tx?: EntityManager): Promise<Bizplace> {
+  const domainRepo = tx ? tx.getRepository(Domain) : getRepository(Domain)
+
+  const domain: Domain = await domainRepo.findOne({
+    where: { subdomain }
+  })
+
+  return await getRepository(Bizplace).findOne({ where: { domain: { id: domain.id } } })
+}
+
+export async function getUserBizplaces(user: User, tx?: EntityManager): Promise<Bizplace[]> {
+  const userRepo = tx ? tx.getRepository(User) : getRepository(User)
+  let userBizplaces: Bizplace[] = []
+
+  if (!user.domains?.length) {
+    user = await userRepo.findOne({
+      where: { id: user.id },
+      relations: ['domains']
+    })
+  }
+
+  const userDomains: Domain[] = user.domains
+  if (userDomains.every((userDomain: Domain) => userDomain.extType !== 'company')) {
+    userBizplaces.push(await getCompanyBizplace(userDomains[0], user, null, tx))
+  }
+
+  return userBizplaces.concat(
+    await getRepository(Bizplace).find({ where: { domain: In(userDomains.map((d: Domain) => d.id)) } })
+  )
+}
+
+export async function getDomainUsers(bizplace: Bizplace, tx?: EntityManager): Promise<any[]> {
+  const userDomainRepo = tx ? tx.getRepository('users_domains') : getRepository('users_domains')
+
+  const users: any[] = await userDomainRepo
+    .createQueryBuilder('ud')
+    .select('ud.users_id', 'id')
+    .distinct(true)
+    .where(qb => {
+      const subquery = qb
+        .subQuery()
+        .select('bizplace.domain_id')
+        .from(Bizplace, 'bizplace')
+        .where('bizplace.id = :customerBizplaceId', { customerBizplaceId: bizplace?.id })
+        .getQuery()
+      return 'ud.domains_id = ' + subquery
+    })
+    .getRawMany()
+
+  return users
+}

package/server/utils/index.ts

@@ -0,0 +1 @@
+export * from './get-permitted-bizplaces'