@things-factory/operato-hub 4.3.229 → 4.3.230

package/server/routers/internal/apis/create-bizplace.ts

@@ -0,0 +1,43 @@
+import { User } from '@things-factory/auth-base'
+import { Bizplace, Company } from '@things-factory/biz-base'
+
+import { generateBizplaceDomain } from '../../../controllers/bizplace-initializer'
+import { ApiError } from '../utils/error-util'
+
+export async function createBizplace(request, context, tx) {
+  const { data: bizplace } = request
+  const company: Company = await tx.getRepository(Company).findOne({ where: { id: bizplace.companyId } })
+
+  const oldBizplace = await tx.getRepository(Bizplace).findOne({
+    where: {
+      refBizplaceId: bizplace.refBizplaceId
+    }
+  })
+  if (oldBizplace) {
+    throw new ApiError('E04', `${bizplace.name} is duplicated`)
+  }
+
+  let foundUser: User = await tx.getRepository(User).findOne({ where: { id: bizplace.userId } })
+
+  let createdBizplace: Bizplace = await tx.getRepository(Bizplace).save({
+    name: bizplace.name,
+    description: bizplace?.description || null,
+    address: bizplace?.address || '',
+    postalCode: bizplace?.postalCode || '',
+    latlng: bizplace?.latlng || '',
+    status: bizplace?.status || null,
+    refBizplaceId: bizplace?.refBizplaceId || null,
+    company,
+    updater: foundUser,
+    creator: foundUser
+  })
+
+  await generateBizplaceDomain(createdBizplace.id, foundUser, tx)
+
+  let data = {
+    id: createdBizplace.id,
+    name: createdBizplace.name
+  }
+
+  return data
+}

package/server/routers/internal/apis/create-company.ts

@@ -0,0 +1,84 @@
+import { Role, User } from '@things-factory/auth-base'
+import { Bizplace, Company } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+import { slugger } from '@things-factory/utils'
+
+import { generateBusinessRoles } from '../../../controllers/company-initializer'
+import { ApiError } from '../utils/error-util'
+
+export async function createCompany(request, context, tx) {
+  const { name, description, brn, address, postalCode, countryCode, type, status, userId, refCompanyId } = request.data
+
+  let foundUser: User = await tx.getRepository(User).findOne({ where: { id: userId }, relations: ['domains', 'roles'] })
+
+  const subdomain = slugger(name)
+
+  //check for existing company
+  const oldCompany = await tx.getRepository(Company).findOne({
+    where: {
+      refCompanyId
+    }
+  })
+
+  if (oldCompany) {
+    throw new ApiError('E04', `${name} is duplicated`)
+  }
+
+  const oldDomain = await tx.getRepository(Domain).findOne({
+    where: {
+      subdomain
+    }
+  })
+
+  if (oldDomain) {
+    throw new ApiError('E04', `${subdomain} is duplicated`)
+  }
+
+  // create company
+  const domain: Domain = await tx.getRepository(Domain).save({
+    subdomain,
+    name,
+    extType: 'company',
+    creator: foundUser,
+    updater: foundUser
+  })
+
+  const company: Company = await tx.getRepository(Company).save({
+    name,
+    description,
+    brn,
+    address,
+    postalCode,
+    countryCode: countryCode || 'my',
+    type,
+    status,
+    domain,
+    refCompanyId: refCompanyId || null,
+    creator: foundUser,
+    updater: foundUser
+  })
+
+  const userHavingRoles: Role[] = foundUser.roles
+  const domainRoles: Role[] = await generateBusinessRoles(domain, tx)
+
+  foundUser.domains = [...foundUser.domains, domain]
+  foundUser.roles = [...userHavingRoles, domainRoles.find(r => r.name === 'BUSINESS-OWNER')]
+
+  await tx.getRepository(User).save(foundUser)
+  await tx.getRepository(Bizplace).save({
+    name: company.name,
+    description: company.description,
+    address: company.address,
+    postalCode: company.postalCode || '',
+    latlng: '',
+    domain,
+    company
+  })
+
+  let data = {
+    id: company.id,
+    name: company.name
+  }
+
+  return data
+}

package/server/routers/internal/apis/create-partner.ts

@@ -0,0 +1,50 @@
+import { Partner, User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+
+import { ApiError } from '../utils/error-util'
+
+export async function createPartner(request, context, tx) {
+  const { bizplaceId, partnerBizplaceId, requesterId } = request.data
+
+  const bizplace: Bizplace = await tx
+    .getRepository(Bizplace)
+    .findOne({ where: { id: bizplaceId }, relations: ['domain'] })
+
+  if (!bizplace) {
+    throw new ApiError('E04', `${bizplaceId} does not exist`)
+  }
+
+  const partnerBizplace: Bizplace = await tx
+    .getRepository(Bizplace)
+    .findOne({ where: { id: partnerBizplaceId }, relations: ['domain'] })
+
+  if (!partnerBizplace) {
+    throw new ApiError('E04', `${partnerBizplaceId} does not exist`)
+  }
+
+  const isExistingCustomer: boolean = Boolean(
+    await tx.getRepository(Partner).count({
+      where: { domain: bizplace.domain, partnerDomain: partnerBizplace.domain }
+    })
+  )
+
+  if (isExistingCustomer) {
+    throw new ApiError('E04', `${partnerBizplaceId} already registered as partner`)
+  }
+
+  let user: User = await tx.getRepository(User).findOne({ where: { id: requesterId } })
+
+  await tx.getRepository(Partner).save({
+    domain: bizplace.domain,
+    partnerDomain: partnerBizplace.domain,
+    requester: user || null,
+    approver: user || null
+  })
+
+  let data = {
+    bizplaceId,
+    partnerBizplaceId
+  }
+
+  return data
+}

package/server/routers/internal/apis/create-user.ts

@@ -0,0 +1,33 @@
+import { NewUser, User } from '@things-factory/auth-base'
+
+import { ApiError } from '../utils/error-util'
+
+export async function createUser(request, context, tx) {
+  let user: NewUser = request?.data || {}
+  const { email } = user
+  user.email = email.trim()
+
+  const oldUser: User = await tx.getRepository(User).findOne({ where: { refUserId: user.refUserId } })
+  if (oldUser) {
+    throw new ApiError('E04', context.t('error.x already exists in y', { x: context.t('field.user'), y: 'operato' }))
+  }
+
+  const salt = User.generateSalt()
+
+  let createdUser: User = await tx.getRepository(User).save({
+    ...user,
+    refUserId: user?.refUserId,
+    userType: user?.userType || 'user',
+    status: user?.status || 'inactive',
+    salt: user?.salt || salt,
+    passwordUpdatedAt: new Date(),
+    password: user?.password || User.encode(user.password, salt)
+  })
+
+  let data = {
+    id: createdUser.id,
+    email: createdUser.email
+  }
+
+  return data
+}

package/server/routers/internal/apis/index.ts

@@ -0,0 +1,21 @@
+import './create-user'
+import './update-user'
+import './create-company'
+import './update-company'
+import './create-bizplace'
+import './update-bizplace'
+import './create-partner'
+import './terminate-partner'
+import './invite-user'
+import './terminate-user'
+
+export * from './create-user'
+export * from './update-user'
+export * from './create-company'
+export * from './update-company'
+export * from './create-bizplace'
+export * from './update-bizplace'
+export * from './create-partner'
+export * from './terminate-partner'
+export * from './invite-user'
+export * from './terminate-user'

package/server/routers/internal/apis/invite-user.ts

@@ -0,0 +1,38 @@
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+
+import { ApiError } from '../utils/error-util'
+
+export async function inviteUser(request, context, tx) {
+  const { userId, bizplaceId } = request.data
+
+  const user: User = await tx.getRepository(User).findOne({ where: { id: userId }, relations: ['domains'] })
+
+  if (!user) {
+    throw new ApiError('E04', `${userId} does not exist`)
+  }
+
+  const bizplace: Bizplace = await tx
+    .getRepository(Bizplace)
+    .findOne({ where: { id: bizplaceId }, relations: ['domain'] })
+
+  if (!bizplace) {
+    throw new ApiError('E04', `${bizplaceId} does not exist`)
+  }
+
+  const existingDomains: Domain[] = user.domains
+  if (existingDomains.find((d: Domain) => d.id === bizplace.domain.id)) {
+    throw new ApiError('E04', `user already exists in ${bizplace.name}`)
+  }
+
+  user.domains = [...existingDomains, bizplace.domain]
+  await tx.getRepository(User).save(user)
+
+  let data = {
+    bizplaceId,
+    userId
+  }
+
+  return data
+}

package/server/routers/internal/apis/terminate-partner.ts

@@ -0,0 +1,45 @@
+import { Partner, terminateGrantedRoles } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+
+import { ApiError } from '../utils/error-util'
+
+export async function terminatePartner(request, context, tx) {
+  const { bizplaceId, partnerBizplaceId } = request.data
+
+  const bizplace: Bizplace = await tx
+    .getRepository(Bizplace)
+    .findOne({ where: { id: bizplaceId }, relations: ['domain'] })
+
+  if (!bizplace) {
+    throw new ApiError('E04', `${bizplaceId} does not exist`)
+  }
+
+  const partnerBizplace: Bizplace = await tx
+    .getRepository(Bizplace)
+    .findOne({ where: { id: partnerBizplaceId }, relations: ['domain'] })
+
+  if (!partnerBizplace) {
+    throw new ApiError('E04', `${partnerBizplaceId} does not exist`)
+  }
+
+  const partner: Partner = await tx.getRepository(Partner).findOne({
+    where: { domain: bizplace.domain, partnerDomain: partnerBizplace.domain }
+  })
+
+  if (!partner) {
+    throw new ApiError('E04', `partner does not exist`)
+  }
+
+  // Remove partner
+  await tx.getRepository(Partner).delete(partner.id)
+
+  // Remove granted roles
+  await terminateGrantedRoles(bizplace.domain, partnerBizplace.domain, tx)
+
+  let data = {
+    bizplaceId,
+    partnerBizplaceId
+  }
+
+  return data
+}

package/server/routers/internal/apis/terminate-user.ts

@@ -0,0 +1,45 @@
+import { Role, User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+
+import { ApiError } from '../utils/error-util'
+
+export async function terminateUser(request, context, tx) {
+  const { userId, bizplaceId } = request.data
+
+  const user: User = await tx
+    .getRepository(User)
+    .findOne({ where: { id: userId }, relations: ['domains', 'roles', 'roles.domain'] })
+
+  if (!user) {
+    throw new ApiError('E04', `${userId} does not exist`)
+  }
+
+  const bizplace: Bizplace = await tx
+    .getRepository(Bizplace)
+    .findOne({ where: { id: bizplaceId }, relations: ['domain'] })
+
+  if (!bizplace) {
+    throw new ApiError('E04', `${bizplaceId} does not exist`)
+  }
+
+  const targetDomainIdx: number = user.domains.findIndex((userDomain: Domain) => userDomain.id === bizplace.domain.id)
+  if (targetDomainIdx < 0) {
+    throw new ApiError('E04', `${user.name} is not a member of ${bizplace.name}`)
+  }
+
+  // Remove domain relation with user
+  user.domains.splice(targetDomainIdx, 1)
+
+  // Remove domain's roles that user has
+  user.roles = user.roles.filter((role: Role) => role.domain.id !== bizplace.domain.id)
+
+  await tx.getRepository(User).save(user)
+
+  let data = {
+    bizplaceId,
+    userId
+  }
+
+  return data
+}

package/server/routers/internal/apis/update-bizplace.ts

@@ -0,0 +1,66 @@
+import { Bizplace, Company } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+import { slugger } from '@things-factory/utils'
+
+import { ApiError } from '../utils/error-util'
+
+export async function updateBizplace(request, context, tx) {
+  const { data: bizplace } = request
+
+  const existingBizplace: Bizplace = await tx.getRepository(Bizplace).findOne({
+    where: {
+      id: bizplace.id
+    },
+    relations: ['company', 'domain']
+  })
+  if (!existingBizplace) {
+    throw new ApiError('E04', `${bizplace.id} does not exist`)
+  }
+
+  const company: Company = existingBizplace.company
+  const domain: Domain = existingBizplace.domain
+
+  await tx.getRepository(Bizplace).update(
+    { id: existingBizplace.id },
+    {
+      name: bizplace?.name || existingBizplace.name,
+      description: bizplace?.description || existingBizplace.description,
+      address: bizplace?.address || existingBizplace.address,
+      postalCode: bizplace?.postalCode || existingBizplace.postalCode,
+      latlng: bizplace?.latlng || existingBizplace.latlng,
+      status: bizplace?.status || existingBizplace.status,
+      updatedAt: new Date()
+    }
+  )
+
+  if (existingBizplace.domain.extType == 'company') {
+    await tx.getRepository(Company).update(
+      { id: company.id },
+      {
+        name: bizplace?.name || company.name,
+        description: bizplace?.description || company.description,
+        address: bizplace?.address || company.address,
+        postalCode: bizplace?.postalCode || company.postalCode || '',
+        updatedAt: new Date()
+      }
+    )
+  }
+
+  await tx.getRepository(Domain).update(
+    { id: domain.id },
+    {
+      name: bizplace?.name ? bizplace.name : domain.name,
+      subdomain: bizplace?.name ? slugger(bizplace.name) : domain.subdomain,
+      updatedAt: new Date()
+    }
+  )
+
+  let updatedBizplace: Bizplace = await tx.getRepository(Bizplace).findOne({ where: { id: existingBizplace.id } })
+
+  let data = {
+    id: updatedBizplace.id,
+    name: updatedBizplace.name
+  }
+
+  return data
+}

package/server/routers/internal/apis/update-company.ts

@@ -0,0 +1,79 @@
+import { User } from '@things-factory/auth-base'
+import { Bizplace, Company } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+import { slugger } from '@things-factory/utils'
+
+import { ApiError } from '../utils/error-util'
+
+export async function updateCompany(request, context, tx) {
+  const { id, name, description, brn, address, postalCode, countryCode, type, status, userId } = request.data
+
+  let foundUser: User = await tx.getRepository(User).findOne({ where: { id: userId }, relations: ['domains', 'roles'] })
+
+  const subdomain = slugger(name)
+
+  //check for existing company
+  const existingCompany: Company = await tx.getRepository(Company).findOne({
+    where: { id }
+  })
+
+  if (!existingCompany) {
+    throw new ApiError('E04', `${name} does not exist`)
+  }
+
+  const existingDomain: Domain = await tx.getRepository(Domain).findOne({
+    where: {
+      subdomain
+    },
+    relations: ['bizplace']
+  })
+
+  if (!existingDomain) {
+    throw new ApiError('E04', `${subdomain} does not exist`)
+  }
+
+  // update company
+  await tx.getRepository(Domain).update(
+    { id: existingDomain.id },
+    {
+      subdomain: name ? subdomain : existingDomain.subdomain,
+      name: name ? name : existingDomain.name,
+      updater: foundUser
+    }
+  )
+
+  await tx.getRepository(Company).update(
+    { id: existingCompany.id },
+    {
+      name: name || existingCompany.name,
+      description: description || existingCompany.description,
+      brn: brn || existingCompany.brn,
+      address: address || existingCompany.address,
+      countryCode: countryCode || existingCompany.countryCode,
+      postalCode: postalCode || existingCompany.postalCode || '',
+      updater: foundUser
+    }
+  )
+  await tx.getRepository(Bizplace).update(
+    { id: existingDomain.bizplace.id },
+    {
+      name: name || existingDomain.bizplace.name,
+      description: description || existingDomain.bizplace.description,
+      address: address || existingDomain.bizplace.address,
+      postalCode: postalCode || existingDomain.bizplace.postalCode || '',
+      latlng: '',
+      updater: foundUser
+    }
+  )
+
+  const updatedCompany: Company = await tx.getRepository(Company).findOne({
+    where: { id }
+  })
+
+  let data = {
+    id: updatedCompany.id,
+    name: updatedCompany.name
+  }
+
+  return data
+}

package/server/routers/internal/apis/update-user.ts

@@ -0,0 +1,39 @@
+import { NewUser, User } from '@things-factory/auth-base'
+
+import { ApiError } from '../utils/error-util'
+
+export async function updateUser(request, context, tx) {
+  let user: NewUser = request?.data || {}
+
+  const existingUser: User = await tx.getRepository(User).findOne({ where: { id: user.id } })
+  if (!existingUser) {
+    throw new ApiError('E04', context.t('error.x does not exists in y', { x: context.t('field.user'), y: 'operato' }))
+  }
+
+  const salt = User.generateSalt()
+
+  await tx.getRepository(User).update(
+    { id: existingUser.id },
+    {
+      name: user?.name || existingUser.name,
+      status: user?.status || existingUser.status,
+      userType: user?.userType || existingUser.userType,
+      salt: user?.password ? (user?.salt ? user.salt : salt) : existingUser.salt,
+      password: user?.password
+        ? user?.salt
+          ? user.password
+          : User.encode(user.password, salt)
+        : existingUser.password,
+      passwordUpdatedAt: user?.password ? new Date() : existingUser.passwordUpdatedAt
+    }
+  )
+
+  let updatedUser: User = await tx.getRepository(User).findOne(existingUser.id)
+
+  let data = {
+    id: updatedUser.id,
+    email: updatedUser.email
+  }
+
+  return data
+}

package/server/routers/internal/index.ts

@@ -1,3 +1,4 @@
 import './powrup-router'
 import './middlewares'
 import './utils'
+import './apis'