@things-factory/operato-hub 4.3.221 → 4.3.227

package/server/routers/internal/powrup-router.ts

@@ -1,13 +1,14 @@
 import Router from 'koa-router'
-import { EntityManager, getConnection, Raw } from 'typeorm'
+import { EntityManager, getConnection } from 'typeorm'
 
-import { NewUser, User } from '@things-factory/auth-base'
+import { NewUser, Partner, Role, terminateGrantedRoles, User } from '@things-factory/auth-base'
 import { Bizplace, Company } from '@things-factory/biz-base'
 import { Integration } from '@things-factory/integration-base'
 import { Domain } from '@things-factory/shell'
 import { slugger } from '@things-factory/utils'
 
-import { generateBizplaceDomain } from '../../controllers/bizplace-initializer/generate-bizplace-domain'
+import { generateBizplaceDomain } from '../../controllers/bizplace-initializer'
+import { generateBusinessRoles } from '../../controllers/company-initializer'
 import { validationMiddleware } from './middlewares/validation-middleware'
 import { ApiError, ApiErrorHandler, throwInternalServerError } from './utils/error-util'
 
@@ -26,7 +27,7 @@ powrupRouter.post('/internal/account/create-user', validationMiddleware, async (
       const { email } = user
       user.email = email.trim()
 
-      const oldUser: User = await tx.getRepository(User).findOne({ where: { email: user.email } })
+      const oldUser: User = await tx.getRepository(User).findOne({ where: { refUserId: user.refUserId } })
       if (oldUser) {
         throw new ApiError(
           'E04',
@@ -38,6 +39,7 @@ powrupRouter.post('/internal/account/create-user', validationMiddleware, async (
 
       let createdUser: User = await tx.getRepository(User).save({
         ...user,
+        refUserId: user?.refUserId,
         userType: user?.userType || 'user',
         status: user?.status || 'inactive',
         salt,
@@ -45,8 +47,71 @@ powrupRouter.post('/internal/account/create-user', validationMiddleware, async (
         password: User.encode(user.password, salt)
       })
 
+      let data = {
+        id: createdUser.id,
+        name: createdUser.name,
+        description: createdUser.description,
+        email: createdUser.email,
+        userType: createdUser.userType,
+        status: createdUser.status,
+        refUserId: createdUser.refUserId
+      }
+
+      context.body = {
+        result: { data }
+      }
+    })
+  } catch (e) {
+    if (e instanceof ApiError) ApiErrorHandler(context, e)
+    else throwInternalServerError(context, e)
+  }
+})
+
+powrupRouter.post('/internal/account/update-user', validationMiddleware, async (context, next) => {
+  try {
+    await getConnection().transaction(async (tx: EntityManager) => {
+      const { body } = context.request
+
+      await getIntegration(context, tx)
+
+      let user: NewUser = body?.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 ? salt : existingUser.salt,
+          password: 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,
+        name: updatedUser.name,
+        description: updatedUser.description,
+        email: updatedUser.email,
+        userType: updatedUser.userType,
+        status: updatedUser.status,
+        refUserId: updatedUser.refUserId
+      }
+
       context.body = {
-        data: createdUser
+        result: { data }
       }
     })
   } catch (e) {
@@ -62,14 +127,18 @@ powrupRouter.post('/internal/account/create-company', validationMiddleware, asyn
 
       await getIntegration(context, tx)
 
-      const { name, description, brn, address, postalCode, type, status } = body.data
+      const { name, description, brn, address, postalCode, countryCode, type, status, userId, refCompanyId } = body.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: {
-          name
+          refCompanyId
         }
       })
 
@@ -91,7 +160,9 @@ powrupRouter.post('/internal/account/create-company', validationMiddleware, asyn
       const domain: Domain = await tx.getRepository(Domain).save({
         subdomain,
         name,
-        extType: 'company'
+        extType: 'company',
+        creator: foundUser,
+        updater: foundUser
       })
 
       const company: Company = await tx.getRepository(Company).save({
@@ -100,13 +171,140 @@ powrupRouter.post('/internal/account/create-company', validationMiddleware, asyn
         brn,
         address,
         postalCode,
+        countryCode: countryCode || 'my',
         type,
         status,
-        domain
+        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,
+        description: company.description,
+        address: company.address,
+        brn: company.brn,
+        postalCode: company.postalCode,
+        countryCode: company.countryCode,
+        type: company.type,
+        status: company.status,
+        refCompanyId: company.refCompanyId
+      }
+
       context.body = {
-        data: company
+        result: { data }
+      }
+    })
+  } catch (e) {
+    if (e instanceof ApiError) ApiErrorHandler(context, e)
+    else throwInternalServerError(context, e)
+  }
+})
+
+powrupRouter.post('/internal/account/update-company', validationMiddleware, async (context, next) => {
+  try {
+    await getConnection().transaction(async (tx: EntityManager) => {
+      const { body } = context.request
+      const { id, name, description, brn, address, postalCode, countryCode, type, status, userId } = body.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,
+        description: updatedCompany.description,
+        address: updatedCompany.address,
+        brn: updatedCompany.brn,
+        postalCode: updatedCompany.postalCode,
+        countryCode: updatedCompany.countryCode,
+        type: updatedCompany.type,
+        status: updatedCompany.status,
+        refCompanyId: updatedCompany.refCompanyId
+      }
+
+      context.body = {
+        result: { data }
       }
     })
   } catch (e) {
@@ -123,33 +321,127 @@ powrupRouter.post('/internal/account/create-bizplace', validationMiddleware, asy
       await getIntegration(context, tx)
 
       const { data: bizplace } = body
-      const company: Company = await tx.getRepository(Company).findOne({ where: { id: bizplace.companyOriginId } })
+      const company: Company = await tx.getRepository(Company).findOne({ where: { id: bizplace.companyId } })
 
       const oldBizplace = await tx.getRepository(Bizplace).findOne({
         where: {
-          name: Raw(alias => `LOWER(${alias}) LIKE '${bizplace.name.toLowerCase()}'`)
+          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,
-        address: bizplace.address,
-        postalCode: bizplace.postalCode,
-        latlng: bizplace.latlng,
-        status: bizplace.status,
+        description: bizplace?.description || null,
+        address: bizplace?.address || '',
+        postalCode: bizplace?.postalCode || '',
+        latlng: bizplace?.latlng || '',
+        status: bizplace?.status || null,
+        refBizplaceId: bizplace?.refBizplaceId || null,
         company,
-        updater: context.state.user,
-        creator: context.state.user
+        updater: foundUser,
+        creator: foundUser
       })
 
-      await generateBizplaceDomain(bizplace.id, null, tx)
+      await generateBizplaceDomain(createdBizplace.id, foundUser, tx)
+
+      let data = {
+        id: createdBizplace.id,
+        name: createdBizplace.name,
+        description: createdBizplace.description,
+        address: createdBizplace.address,
+        postalCode: createdBizplace.postalCode,
+        latlng: createdBizplace.latlng,
+        status: createdBizplace.status,
+        company: createdBizplace.company
+      }
 
       context.body = {
-        data: createdBizplace
+        result: { data }
+      }
+    })
+  } catch (e) {
+    if (e instanceof ApiError) ApiErrorHandler(context, e)
+    else throwInternalServerError(context, e)
+  }
+})
+
+powrupRouter.post('/internal/account/update-bizplace', validationMiddleware, async (context, next) => {
+  try {
+    await getConnection().transaction(async (tx: EntityManager) => {
+      const { body } = context.request
+
+      await getIntegration(context, tx)
+
+      const { data: bizplace } = body
+
+      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,
+        description: updatedBizplace.description,
+        address: updatedBizplace.address,
+        postalCode: updatedBizplace.postalCode,
+        latlng: updatedBizplace.latlng,
+        status: updatedBizplace.status,
+        company: updatedBizplace.company
+      }
+
+      context.body = {
+        result: { data }
       }
     })
   } catch (e) {
@@ -159,40 +451,216 @@ powrupRouter.post('/internal/account/create-bizplace', validationMiddleware, asy
 })
 
 powrupRouter.post('/internal/account/create-partner', validationMiddleware, async (context, next) => {
-  // try {
-  //   await getConnection().transaction(async (tx: EntityManager) => {
-  //     const { body } = context.request
-  //     await getIntegration(context, tx)
-  //     const { data: partner } = body
-  //     const company: Company = await tx.getRepository(Company).findOne({ where: { id: bizplace.companyOriginId } })
-  //     const oldBizplace = await tx.getRepository(Bizplace).findOne({
-  //       where: {
-  //         name: Raw(alias => `LOWER(${alias}) LIKE '${bizplace.name.toLowerCase()}'`)
-  //       }
-  //     })
-  //     if (oldBizplace) {
-  //       throw new ApiError('E04', `${bizplace.name} is duplicated`)
-  //     }
-  //     let createdBizplace: Bizplace = await tx.getRepository(Bizplace).save({
-  //       name: bizplace.name,
-  //       description: bizplace.description,
-  //       address: bizplace.address,
-  //       postalCode: bizplace.postalCode,
-  //       latlng: bizplace.latlng,
-  //       status: bizplace.status,
-  //       company,
-  //       updater: context.state.user,
-  //       creator: context.state.user
-  //     })
-  //     await generateBizplaceDomain(bizplace.id, null, tx)
-  //     context.body = {
-  //       data: createdBizplace
-  //     }
-  //   })
-  // } catch (e) {
-  //   if (e instanceof ApiError) ApiErrorHandler(context, e)
-  //   else throwInternalServerError(context, e)
-  // }
+  try {
+    await getConnection().transaction(async (tx: EntityManager) => {
+      const { body } = context.request
+      await getIntegration(context, tx)
+
+      const { bizplaceId, partnerBizplaceId, requesterId } = body.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
+      })
+
+      context.body = {
+        result: {
+          data: {
+            bizplace,
+            partnerBizplaceId
+          }
+        }
+      }
+    })
+  } catch (e) {
+    if (e instanceof ApiError) ApiErrorHandler(context, e)
+    else throwInternalServerError(context, e)
+  }
+})
+
+powrupRouter.post('/internal/account/terminate-partner', validationMiddleware, async (context, next) => {
+  try {
+    await getConnection().transaction(async (tx: EntityManager) => {
+      const { body } = context.request
+      await getIntegration(context, tx)
+
+      const { bizplaceId, partnerBizplaceId } = body.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)
+
+      context.body = {
+        result: {
+          data: {
+            bizplace,
+            partnerBizplaceId
+          }
+        }
+      }
+    })
+  } catch (e) {
+    if (e instanceof ApiError) ApiErrorHandler(context, e)
+    else throwInternalServerError(context, e)
+  }
+})
+
+powrupRouter.post('/internal/account/invite-user', validationMiddleware, async (context, next) => {
+  try {
+    await getConnection().transaction(async (tx: EntityManager) => {
+      const { body } = context.request
+      await getIntegration(context, tx)
+
+      const { userId, bizplaceId } = body.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]
+      let updatedUser: User = await tx.getRepository(User).save(user)
+
+      context.body = {
+        result: {
+          data: {
+            id: updatedUser.id,
+            name: updatedUser.name,
+            email: updatedUser.email,
+            domains: updatedUser.domains
+          }
+        }
+      }
+    })
+  } catch (e) {
+    if (e instanceof ApiError) ApiErrorHandler(context, e)
+    else throwInternalServerError(context, e)
+  }
+})
+
+powrupRouter.post('/internal/account/terminate-user', validationMiddleware, async (context, next) => {
+  try {
+    await getConnection().transaction(async (tx: EntityManager) => {
+      const { body } = context.request
+      await getIntegration(context, tx)
+
+      const { userId, bizplaceId } = body.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)
+
+      let updatedUser: User = await tx.getRepository(User).save(user)
+
+      context.body = {
+        result: {
+          data: {
+            id: updatedUser.id,
+            name: updatedUser.name,
+            email: updatedUser.email
+          }
+        }
+      }
+    })
+  } catch (e) {
+    if (e instanceof ApiError) ApiErrorHandler(context, e)
+    else throwInternalServerError(context, e)
+  }
 })
 
 async function getIntegration(context, tx) {