@things-factory/operato-hub 6.1.83 → 6.1.85

package/server/controllers/company-initializer/settings.ts

@@ -1,33 +0,0 @@
-const settings = [
-  { name: 'dashboard:CUST', description: 'dashboard for customer', category: 'board' },
-  { name: 'dashboard:OFFICE ADMIN', description: 'dashboard for OFFICE ADMIN', category: 'board' },
-  { name: 'dashboard:SYSTEM ADMIN', description: 'dashboard for SUPER ADMIN', category: 'board' },
-  { name: 'dashboard:W/H MANAGER', description: 'dashboard for W/H MANAGER', category: 'board' },
-  { name: 'location-label', description: 'board id for location label', category: 'board' },
-  { name: 'pallet-label', description: 'board id for pallet label', category: 'board' },
-  { name: 'carton-label', description: 'board id for carton label', category: 'board' },
-  { name: 'rule-for-creating-ro', description: 'location sorting rules', category: 'location' },
-  { name: 'rule-for-inspecting-product', description: 'location sorting rules', category: 'location' },
-  { name: 'rule-for-inventory-assignment', description: 'location sorting rules', category: 'location' },
-  { name: 'rule-for-picking-product', description: 'location sorting rules', category: 'location' },
-  { name: 'rule-for-worksheet-release-goods-item', description: 'worksheet release goods item location sorting rules', category: 'location' },
-  { name: 'pallet-id-rule', description: 'pallet ID rule', category: 'id-rule' },
-  { name: 'enable-custom-clearance-transportation', description: 'custom clearance transport', category: 'id-rule' },
-  { name: 'enable-transportation-service', description: 'warehouse transport', category: 'id-rule' },
-  { name: 'hide-cross-dock', description: 'hide cross docking button', category: 'id-rule' },
-  { name: 'disable-reusable-pallet', description: 'hide and disable reusable pallet text field', category: 'id-rule' }
-]
-
-import { Setting } from '@things-factory/setting-base'
-
-export async function initSettings(tx, domain) {
-  const settingRepo = tx.getRepository(Setting)
-  return await settingRepo.save(
-    settings.map(setting => {
-      return {
-        ...setting,
-        domain
-      }
-    })
-  )
-}

package/server/controllers/company-initializer/transporter.ts

@@ -1,20 +0,0 @@
-import { CourierService } from '@things-factory/integration-lmd'
-
-const transporters = [
-  { name: 'SnT CJ CENTURY LOGISTIC', transporterId: 'TBD000018' },
-  { name: 'NINJAVAN', transporterId: 'TBD000014' },
-  { name: 'POS MALAYSIA', transporterId: 'TBD000015' },
-  { name: 'SKYNET - SNT GLOBAL', transporterId: 'TBD000004' }
-]
-
-export async function initTransporter(tx, domain) {
-  const transporterRepo = tx.getRepository(CourierService)
-  return await transporterRepo.save(
-    transporters.map(transporter => {
-      return {
-        ...transporter,
-        domain
-      }
-    })
-  )
-}

package/server/controllers/invitation.ts

@@ -1,132 +0,0 @@
-import { URL } from 'url'
-import { ILike } from 'typeorm'
-
-import { Invitation, User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { sendEmail } from '@things-factory/email-base'
-import { getRepository } from '@things-factory/shell'
-
-import { getInvitationEmailForm } from '../templates/invitation-email'
-import { makeInvitationToken } from './utils/make-invitation-token'
-import { saveInvitationToken } from './utils/save-invitation-token'
-
-export async function invite(attrs, withEmailInvitation?: Boolean) {
-  const { email, reference, type, context } = attrs
-
-  // 기존 사용자가 있는 경우.
-  // - type이 company: reference 필드가 비어있는 지 확인, 비어있다면, 초대장 전송
-  // - type이 bizplace: 사용자의 bizplace를 확인해서 없다면, 초대장 전송
-  // - 그 외에는 이미 초대되어있다는 메시지로 종료
-
-  // 기존 사용자가 없는 경우.
-  // - 초대장 전송
-
-  const repository = getRepository(User)
-  var user = (await repository.findOne({ where: { email: ILike(email) }, relations: ['bizplaces'] })) as User & {
-    bizplaces: Bizplace[]
-  }
-
-  if (user) {
-    if (type == 'company') {
-      if (reference == user.reference) {
-        throw new Error('user already a member of the company.')
-      }
-    } else if (type == 'bizplace') {
-      var bizplace: Bizplace = await getRepository(Bizplace).findOneBy({ id: reference })
-
-      if (!bizplace) {
-        throw new Error('invalid bizplace.')
-      }
-
-      const userBizplaces: Bizplace[] = user.bizplaces
-      if (userBizplaces.find((userBizplace: Bizplace) => userBizplace.id === bizplace.id)) {
-        throw new Error('user already a member of the bizplace.')
-      }
-    }
-  }
-
-  // invitation 레코드에 동일한 invitation이 있는 지 확인
-  var invitation = await getRepository(Invitation).findOneBy({
-    email,
-    reference,
-    type
-  })
-
-  if (!invitation) {
-    invitation = await getRepository(Invitation).save({
-      email,
-      reference,
-      type
-    })
-  }
-
-  var succeed = false
-  if (withEmailInvitation) {
-    succeed = await sendInvitationEmail({
-      invitation,
-      context
-    })
-  }
-
-  try {
-    return {
-      // token: await signin({
-      //   email,
-      //   password
-      // })
-    }
-  } catch (e) {
-    return { token: null }
-  }
-}
-
-export async function acceptInvitation(token) {
-  var invitation = await getRepository(Invitation).findOneBy({
-    token
-  })
-
-  if (invitation) {
-    return false
-  }
-
-  return true
-}
-
-export async function sendInvitationEmail({ invitation, context }) {
-  try {
-    var token = makeInvitationToken()
-    await saveInvitationToken(invitation.id, token)
-
-    if (invitation) {
-      var serviceUrl = new URL(`/auth/accept/${token}`, context.header.referer)
-
-      await sendEmail({
-        receiver: invitation.email,
-        subject: 'Invitation',
-        content: getInvitationEmailForm({
-          email: invitation.email,
-          acceptUrl: serviceUrl
-        })
-      })
-
-      return true
-    }
-  } catch (e) {
-    return false
-  }
-}
-
-export async function resendInvitationEmail({ email, reference, type }, context) {
-  var invitation = await getRepository(Invitation).findOneBy({
-    email,
-    reference,
-    type
-  })
-
-  if (!invitation) return false
-
-  return await sendInvitationEmail({
-    invitation,
-    context
-  })
-}

package/server/controllers/utils/make-invitation-token.ts

@@ -1,5 +0,0 @@
-import crypto from 'crypto'
-
-export function makeInvitationToken() {
-  return crypto.randomBytes(16).toString('hex')
-}

package/server/controllers/utils/save-invitation-token.ts

@@ -1,9 +0,0 @@
-import { Invitation } from '@things-factory/auth-base'
-import { getRepository } from '@things-factory/shell'
-
-export async function saveInvitationToken(id, token) {
-  return await getRepository(Invitation).save({
-    id,
-    token
-  })
-}

package/server/errors/index.ts

@@ -1 +0,0 @@
-export * from './validation-error'

package/server/errors/validation-error.ts

@@ -1,17 +0,0 @@
-type ValidationErrorArgument = {
-  errorCode: string
-  message: string
-  detail?: Object
-}
-
-export class ValidationError extends Error {
-  errorCode: any
-  detail: Object
-  constructor({ errorCode, message, detail }: ValidationErrorArgument) {
-    super(errorCode)
-    this.name = 'validation-error'
-    this.errorCode = errorCode,
-      this.message = message
-    this.detail = detail
-  }
-}

package/server/graphql/index.ts

@@ -1,7 +0,0 @@
-import * as typeDefs from './types'
-import * as resolvers from './resolvers'
-
-export const schema = {
-  typeDefs,
-  resolvers
-}

package/server/graphql/resolvers/generators/generate-bizplace.ts

@@ -1,40 +0,0 @@
-import { Raw } from 'typeorm'
-
-import { Bizplace } from '@things-factory/biz-base'
-
-import { generateBizplaceDomain } from '../../../controllers/bizplace-initializer/generate-bizplace-domain'
-
-export const generateBizplace = {
-  async generateBizplace(_: any, { bizplaceInput }, context: ResolverContext) {
-    const { tx, business: company, user } = context.state
-    const { name, description, address, postalCode, latlng } = bizplaceInput
-
-    if (/^[a-zA-Z ]+$/.test(name)) {
-      const oldBizplace = await tx.getRepository(Bizplace).findOne({
-        where: {
-          name: Raw(alias => `LOWER(${alias}) LIKE '${name.toLowerCase()}'`)
-        }
-      })
-      if (oldBizplace) {
-        throw new Error('bizplace name is duplicated')
-      }
-    } else {
-      throw new Error('bizplace name should consist only of letters or dashes')
-    }
-
-    const bizplace = await tx.getRepository(Bizplace).save({
-      name,
-      description,
-      address,
-      postalCode,
-      latlng,
-      company,
-      updater: user,
-      creator: user
-    })
-
-    await generateBizplaceDomain(bizplace.id, user, tx)
-
-    return bizplace
-  }
-}

package/server/graphql/resolvers/generators/generate-company.ts

@@ -1,76 +0,0 @@
-import { ILike } from 'typeorm'
-import { User } from '@things-factory/auth-base'
-import { Company } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-import { slugger } from '@things-factory/utils'
-
-import { initGroups } from '../../../controllers/bizplace-initializer'
-import { generateBusinessRoles } from '../../../controllers/company-initializer/generate-company-roles'
-
-export const generateCompany = {
-  async generateCompany(_: any, { companyInput }, context: ResolverContext) {
-    const { tx, user } = context.state
-    const { name, description, address, postalCode, latlng } = companyInput
-
-    const subdomain = slugger(name)
-
-    /* check */
-    const oldCompany = await tx.getRepository(Company).findOne({
-      where: {
-        name
-      }
-    })
-
-    if (oldCompany) {
-      throw new Error('company name is duplicated')
-    }
-
-    const oldDomain = await tx.getRepository(Domain).findOne({
-      where: {
-        name
-      }
-    })
-
-    if (oldDomain) {
-      throw new Error('subdomain is duplicated')
-    }
-
-    /* create company */
-    const domain: Domain = await tx.getRepository(Domain).save({
-      subdomain,
-      name,
-      extType: 'company'
-    })
-
-    /* create roles */
-    const domainRoles = await generateBusinessRoles(domain, tx)
-
-    const company: Company = await tx.getRepository(Company).save({
-      ...companyInput,
-      owner: user,
-      domain
-    })
-
-    const userHavingRoles: User = await tx.getRepository(User).findOne({
-      where: { email: ILike(user.email) },
-      relations: ['domains', 'roles']
-    })
-
-    user.domains = [...user.domains, domain]
-    user.roles = [...userHavingRoles.roles, domainRoles.find(r => r.name === 'BUSINESS-OWNER')]
-
-    await tx.getRepository(User).save(user)
-
-    await initGroups(tx, domain)
-
-    return await tx.getRepository(Company).save({
-      name,
-      description,
-      address,
-      postalCode,
-      latlng,
-      updater: user,
-      creator: user
-    })
-  }
-}

package/server/graphql/resolvers/generators/index.ts

@@ -1,9 +0,0 @@
-import { generateCompany } from './generate-company'
-import { generateBizplace } from './generate-bizplace'
-import { updateDomainExtType } from './update-domain-extType'
-
-export const Mutation = {
-  ...generateCompany,
-  ...generateBizplace,
-  ...updateDomainExtType
-}

package/server/graphql/resolvers/generators/update-domain-extType.ts

@@ -1,55 +0,0 @@
-import { EntityManager, ILike, Repository } from 'typeorm'
-
-import { Privilege, Role, User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-
-import { initCodes, initGroups, initMenus, initSettings } from '../../../controllers/bizplace-initializer'
-import { generateBizplaceDomainRoles } from '../../../controllers/bizplace-initializer/generate-bizplace-domain-roles'
-
-export const updateDomainExtType = {
-  async updateDomainType(_: any, { domainTypeInput }, context: ResolverContext) {
-    const { tx, user } = context.state
-    const { id, extType }: { id: string; extType: string } = domainTypeInput
-
-    let domain: Domain = await tx.getRepository(Domain).findOne({ where: { id } })
-    domain.extType = extType
-
-    domain = await tx.getRepository(Domain).save(domain)
-
-    await generateBizplaceDomainRoles(domain, tx)
-    await initMenus(tx, domain)
-    await initCodes(tx, domain)
-    await initSettings(tx, domain)
-    await initGroups(tx, domain)
-
-    /* Creating relations
-     *    1) users_domains table
-     *    2) users_roles table
-     */
-    await createRelations(tx, domain, user.email)
-
-    return domain
-  }
-}
-
-async function createRelations(tx: EntityManager, domain: Domain, email: string) {
-  const userRepo: Repository<User> = tx.getRepository(User)
-  const user: User = await userRepo.findOne({ where: { email: ILike(email) }, relations: ['domains', 'roles'] })
-  const roleRepo: Repository<Role> = tx.getRepository(Role)
-  const role: Role = await roleRepo.findOne({ where: { domain: { id: domain.id } }, relations: ['domain'] })
-  const privilegeRepo: Repository<Privilege> = tx.getRepository(Privilege)
-  const privileges: Privilege[] = await privilegeRepo.find()
-
-  const domains: Domain[] = user.domains
-  domains.push(domain)
-  user.domains = domains
-
-  const roles: Role[] = await user.roles
-  roles.push(role)
-  user.roles = roles
-
-  role.privileges = privileges
-
-  await userRepo.save(user)
-  await roleRepo.save(role)
-}

package/server/graphql/resolvers/index.ts

@@ -1,8 +0,0 @@
-import * as Generators from './generators'
-import * as Oauth2 from './oauth2'
-import * as Invitations from './invitations'
-import * as Synchronization from './synchronization'
-
-export const queries = [Synchronization.Query, Oauth2.Query]
-
-export const mutations = [Generators.Mutation, Invitations.Mutation, Synchronization.Mutation]

package/server/graphql/resolvers/invitations/index.ts

@@ -1,5 +0,0 @@
-import { partnerInvitationResolver } from './partner-invitation'
-
-export const Mutation = {
-  ...partnerInvitationResolver
-}

package/server/graphql/resolvers/invitations/partner-invitation.ts

@@ -1,62 +0,0 @@
-import { Raw } from 'typeorm'
-
-import { Bizplace, Partner } from '@things-factory/biz-base'
-import { Domain, getRepository } from '@things-factory/shell'
-
-export const partnerInvitationResolver = {
-  async partnerInvitation(_: any, { bizplaceName }: { bizplaceName: string }, context: ResolverContext): Promise<void> {
-    const { domain, user } = context.state
-
-    // Check whether bizplace exists or not
-    const partnerBizplace: Bizplace = await getRepository(Bizplace).findOne({
-      where: {
-        name: Raw(alias => `LOWER(${alias}) LIKE '${bizplaceName.toLowerCase()}'`)
-      }
-    })
-
-    const partnerDomain: Domain = await getRepository(Domain).findOne({
-      where: {
-        name: partnerBizplace.name
-      }
-    })
-
-    if (partnerDomain && partnerDomain.extType === 'company') {
-      throw new Error(context.t('error.business cannot be invited.'))
-    }
-
-    if (!partnerBizplace) {
-      throw new Error(context.t('error.failed to find x', { x: context.t('field.bizplace') }))
-    }
-
-    if (domain.name === partnerBizplace.name) {
-      throw new Error(context.t('error.failed to find x', { x: context.t('field.bizplace') }))
-    }
-
-    const domainBizplace: Bizplace = await getRepository(Bizplace).findOne({
-      where: { domain: { id: domain.id } }
-    })
-
-    if (!domainBizplace) {
-      throw new Error(context.t('error.failed to find x', { x: 'domain bizplace' }))
-    }
-
-    // Check whether the bizplace is partner already or not
-    const partner: Partner = await getRepository(Partner).findOne({
-      where: { domainBizplace: { id: domainBizplace.id }, partnerBizplace: { id: partnerBizplace.id } }
-    })
-
-    if (partner) {
-      throw new Error(
-        context.t('error.x already exists in y', { x: partnerBizplace.name, y: context.t('field.partner') })
-      )
-    }
-
-    let newPartner: Partner = new Partner()
-    newPartner.type = 'CUSTOMER'
-    newPartner.domainBizplace = domainBizplace
-    newPartner.partnerBizplace = partnerBizplace
-    newPartner.requester = user
-    newPartner.approver = user
-    await getRepository(Partner).save(newPartner)
-  }
-}

package/server/graphql/resolvers/oauth2/company-roles-by-scope.ts

@@ -1,38 +0,0 @@
-import { getUserDomains, Role, User } from '@things-factory/auth-base'
-import { Domain, getRepository } from '@things-factory/shell'
-
-type CompanyRole = {
-  domain: Domain
-  roles: Role[]
-}
-
-export const companyRolesByScopeResolver = {
-  async companyRolesByScope(_: void, { scope }: { scope: string[] }, context: ResolverContext): Promise<CompanyRole[]> {
-    let { user } = context.state
-    const userDomains: Domain[] = await getUserDomains(user)
-    const availableDomains: Domain[] = userDomains.filter((domain: Domain) => scope.indexOf(domain.extType) >= 0)
-    const availableDomainIDs: string[] = availableDomains.map((domain: Domain) => domain.id)
-    user = await getRepository(User).findOne({
-      where: { id: user.id },
-      relations: ['roles', 'roles.domain']
-    })
-
-    const availableRoles: Role[] = user.roles.filter((role: Role) => availableDomainIDs.indexOf(role.domain.id) >= 0)
-
-    const companyRoleMap: Map<string, Role[]> = new Map<string, Role[]>()
-    availableRoles.forEach((role: Role) => {
-      if (companyRoleMap.has(role.domain.id)) {
-        companyRoleMap.get(role.domain.id).push(role)
-      } else {
-        companyRoleMap.set(role.domain.id, [role])
-      }
-    })
-
-    let companyRoles: CompanyRole[] = []
-    companyRoleMap.forEach((roles: Role[]) => {
-      companyRoles.push({ domain: roles[0].domain, roles })
-    })
-
-    return companyRoles
-  }
-}

package/server/graphql/resolvers/oauth2/index.ts

@@ -1,5 +0,0 @@
-import { companyRolesByScopeResolver } from './company-roles-by-scope'
-
-export const Query = {
-  ...companyRolesByScopeResolver
-}