@things-factory/integration-accounting 4.3.113-alpha.0 → 4.3.122

package/server/controllers/xilnex/apis/sales-order/post-sales-order-to-sales-invoice.ts

@@ -0,0 +1,22 @@
+import { AccountingAPI } from '../../../accounting-api'
+
+export function postSalesOrderToSalesInvoice() {
+  return {
+    method: 'post',
+    path: '/salesorder/{orderId}/invoice/{outlet}',
+    denormalize(req, { accounting }) {
+      let accountInfo: any = accounting?.accountInfo ? JSON.parse(accounting.accountInfo) : {}
+      return {
+        resource: { orderId: req.orderId, outlet: accountInfo?.outlet || 'MAIN BRANCH' }
+      }
+    },
+    async normalize(res, { accounting }) {
+      let data = res.data
+
+      const sale = await AccountingAPI.getSale(accounting, { orderId: data.salesId })
+      data.sale = { ...sale.sale }
+
+      return data
+    }
+  }
+}

package/server/controllers/xilnex/apis/sales-return/create-sales-return.ts

@@ -0,0 +1,40 @@
+export function createSalesReturn() {
+  return {
+    method: 'post',
+    path: '/sales/salesreturn',
+    denormalize(req, { accounting }) {
+      const { releaseGood, orderProducts } = req
+      let accountInfo: any = accounting?.accountInfo ? JSON.parse(accounting.accountInfo) : {}
+      let sale: any = {
+        id: releaseGood?.refNo3,
+        dateTime: releaseGood.updatedAt,
+        term: 0,
+        status: 'CONFIRMED',
+        outlet: accountInfo?.outlet || 'MAIN BRANCH',
+        salesPerson: accountInfo?.clientName,
+        recipientContact: releaseGood?.phone1,
+        recipientName: releaseGood?.attentionTo,
+        items: orderProducts.map(op => {
+          return {
+            id: op?.refItemId,
+            unitPrice: op?.sellingPrice,
+            quantity: -op?.pickedQty,
+            deliveryQuantity: 0,
+            discountAmount: 0,
+            remark: op?.remark,
+            enterPrice: op?.sellingPrice,
+            discountRemark: '',
+            totalDiscountAmount: 0
+          }
+        })
+      }
+
+      return {
+        payload: { sale }
+      }
+    },
+    normalize(res) {
+      return res.data
+    }
+  }
+}

package/server/controllers/xilnex/apis/sales-return/index.ts

@@ -0,0 +1 @@
+export * from './create-sales-return'

package/server/controllers/xilnex/apis/shipment/create-shipment.ts

@@ -0,0 +1,28 @@
+export function createShipment() {
+  return {
+    method: 'post',
+    path: '/shipment',
+    denormalize(req, { accounting }) {
+      const { releaseGood, orderProducts } = req
+      let accountInfo: any = accounting?.accountInfo ? JSON.parse(accounting.accountInfo) : {}
+
+      let shipmentItems: any = orderProducts.map(op => {
+        return {
+          documentId: op.refItemId,
+          shippingQuantity: op.releaseQty
+        }
+      })
+
+      let shipment: any = {
+        shippingOutlet: accountInfo?.outlet || 'MAIN BRANCH',
+        documentId: releaseGood.refNo3,
+        shippingDateTime: new Date()
+      }
+
+      return { payload: { shipment: { ...shipment, shipmentItems } } }
+    },
+    normalize(res) {
+      return res
+    }
+  }
+}

package/server/controllers/xilnex/apis/shipment/index.ts

@@ -0,0 +1 @@
+export * from './create-shipment'

package/server/controllers/xilnex/apis/stock-request/get-stock-request.ts

@@ -0,0 +1,15 @@
+export function getStockRequest() {
+  return {
+    method: 'get',
+    path: '/stockrequest/{orderId}',
+    denormalize(req) {
+      const { orderId } = req
+      return { resource: { orderId } }
+    },
+    normalize(res) {
+      const { data } = res
+      let stockRequest: any = data.stockRequest
+      return stockRequest
+    }
+  }
+}

package/server/controllers/xilnex/apis/stock-request/index.ts

@@ -0,0 +1 @@
+export * from './get-stock-request'

package/server/controllers/xilnex/apis/stocks/create-stock-adjust-record.ts

@@ -0,0 +1,42 @@
+export function createStockAdjustRecord() {
+  return {
+    method: 'post',
+    path: '/stocks/stockadjustment',
+    denormalize(req) {
+      const { xilnexInv } = req
+
+      let adjustQuantity: number = xilnexInv.changedQty - xilnexInv.originalQty
+      let stocksTakeTitle: any = {
+        recordItems: [],
+        adjustItems: [
+          {
+            adjustQuantity: xilnexInv.adjustQuantity,
+            adjustType: adjustQuantity >= 0 ? 'AdjustUp' : 'AdjustDown',
+            remark: '',
+            itemId: xilnexInv.productDetail.refCode,
+            itemCode: xilnexInv.product.sku,
+            name: xilnexInv.product.name,
+            stockAdjustType: 'Normal',
+            uom: xilnexInv?.uom ? xilnexInv.uom : xilnexInv.productDetail.uom,
+            uomQuantity: xilnexInv?.packingSize ? xilnexInv.packingSize : xilnexInv.productDetail.packingSize,
+            batchNo: xilnexInv?.batchId ? xilnexInv.batchId : null,
+            batchExpiryDate: xilnexInv?.expirationDate ? xilnexInv.expirationDate : null,
+            dateTime: xilnexInv.createdAt
+          }
+        ],
+        description: 'Stock Adjustment',
+        dateTime: xilnexInv.createdAt,
+        remarks: '',
+        stockTakeType: 'StockAdjustment',
+        status: 'COMPLETED'
+      }
+
+      return {
+        payload: { stocksTakeTitle }
+      }
+    },
+    normalize(res) {
+      return res
+    }
+  }
+}

package/server/controllers/xilnex/apis/stocks/index.ts

@@ -0,0 +1 @@
+export * from './create-stock-adjust-record'

package/server/controllers/xilnex/apis/transfer-note/create-transfer-note.ts

@@ -0,0 +1,40 @@
+export function createTransferNote() {
+  return {
+    method: 'post',
+    path: '/TransferNote',
+    denormalize(req) {
+      const { releaseGood, deliveryOrder, orderInventories } = req
+
+      let transferNote: any = {
+        transferTo: deliveryOrder.attentionTo,
+        transferBy: '',
+        transferDate: '',
+        receiveDate: '',
+        transferFrom: '',
+        status: deliveryOrder.status,
+        remarks: deliveryOrder.remark,
+        type: 'Transfer',
+        toCompany: deliveryOrder.attentionCompany,
+        fromCompany: '',
+        transferType: '',
+        lastUpdateDateTime: deliveryOrder.deliveryOrderDateTime,
+        etaDate: deliveryOrder.deliveryDate,
+        totalQuantity: 1,
+        totalPrice: 0,
+        transferItems: orderInventories
+      }
+
+      return {
+        payload: {
+          clientId: '',
+          transferNote,
+          deliveryOrderNumber: deliveryOrder.name,
+          deliveryOrderDate: deliveryOrder.deliveryDate
+        }
+      }
+    },
+    normalize(res) {
+      return res
+    }
+  }
+}

package/server/controllers/xilnex/apis/transfer-note/index.ts

@@ -0,0 +1 @@
+export * from './create-transfer-note'

package/server/controllers/xilnex/index.ts

@@ -0,0 +1,7 @@
+import { AccountingAPI } from '../accounting-api'
+import * as APIS from './apis'
+import { action } from './platform-action'
+
+export * from './xilnex'
+
+AccountingAPI.registerPlatform('xilnex', action, APIS)

package/server/controllers/xilnex/platform-action.ts

@@ -0,0 +1,46 @@
+import { config, logger } from '@things-factory/env'
+
+import { Xilnex } from './xilnex'
+
+const xilnexConfig = config.get('accountingIntegrationXilnex', {})
+const { apiKey, apiSecret } = xilnexConfig
+
+function substitute(path, obj) {
+  var props = []
+  var re = /{([^}]+)}/g
+  var text
+
+  while ((text = re.exec(path))) {
+    props.push(text[1])
+  }
+
+  var result = path
+  props.forEach(prop => {
+    let value = obj[prop.trim()]
+    result = result.replace(`{${prop}}`, value === undefined ? '' : value)
+  })
+
+  return result
+}
+
+async function _action({ accounting, method = 'get', path, request }) {
+  const client = new Xilnex({
+    accessToken: accounting.accessToken,
+    appId: accounting.accountId
+  })
+
+  const { resource = {}, payload = {} } = request
+
+  path = substitute(path, resource)
+
+  return await client[method](path, payload)
+}
+
+export const action = async ({ accounting, method = 'get', path, request }) => {
+  try {
+    return await _action({ accounting, method, path, request })
+  } catch (ex) {
+    logger.error(`Xilnex: action: ${ex}`)
+    throw ex
+  }
+}

package/server/controllers/xilnex/xilnex.ts

@@ -0,0 +1,86 @@
+import crypto from 'crypto'
+import fetch from 'node-fetch'
+
+const ENDPOINT = `https://api.xilnex.com/logic/v2`
+const debug = require('debug')('things-factory:integration-accounting:xilnex')
+
+export type XilnexConfig = {
+  accessToken?: string
+  appId?: string
+  secretKey?: string
+}
+
+export class Xilnex {
+  private config: XilnexConfig
+
+  constructor(config: XilnexConfig) {
+    this.config = {
+      ...config
+    }
+  }
+
+  isValidSignature(data, secret, signature) {
+    let hmac = crypto.createHmac('sha256', secret).update(JSON.stringify(data)).digest('hex')
+
+    return hmac === signature
+  }
+
+  async get(path: string, data: any) {
+    const { accessToken, appId } = this.config
+
+    const qs = Object.entries(data)
+      .map(([k, v]) => `${k}=${encodeURIComponent(String(v))}`)
+      .join('&')
+
+    const endpoint = `${ENDPOINT}${path}${qs ? '?' + qs : ''}`
+    debug('endpoint', endpoint)
+
+    const response = await fetch(endpoint, {
+      method: 'get',
+      headers: {
+        'Content-Type': 'application/json',
+        token: accessToken,
+        appid: appId,
+        auth: '5'
+      }
+    })
+
+    if (response.ok) {
+      const result = await response.json()
+      return result
+    } else {
+      const result = await response.text()
+      throw new Error(`(${response.status}) ${result}`)
+    }
+  }
+
+  async post(path: string, data: any = {}) {
+    const { accessToken, appId } = this.config
+
+    debug('data', data)
+
+    const jsondata = JSON.stringify(data)
+
+    const endpoint = `${ENDPOINT}${path}`
+    debug('endpoint', endpoint)
+
+    const response = await fetch(endpoint, {
+      method: 'post',
+      headers: {
+        'Content-Type': 'application/json',
+        token: accessToken,
+        appid: appId,
+        auth: '5'
+      },
+      body: jsondata
+    })
+
+    if (response.ok) {
+      const result = await response.json()
+      return result
+    } else {
+      const result = await response.text()
+      throw new Error(`(${response.status}) ${result}`)
+    }
+  }
+}

package/server/entities/account-webhook-order.ts

@@ -0,0 +1,55 @@
+import { Field } 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 { ACCOUNT_PLATFORM, ACCOUNT_SYNC_STATUS } from '../constants/account'
+
+@Entity()
+@Index(
+  'ix_account_webhook_order_0',
+  (accountWebhook: AccountWebhookOrder) => [accountWebhook.domain, accountWebhook.name],
+  { unique: true }
+)
+export class AccountWebhookOrder {
+  @PrimaryGeneratedColumn('uuid')
+  id: string
+
+  @ManyToOne(type => Domain)
+  domain: Domain
+
+  @Column({
+    nullable: true
+  })
+  request: string
+
+  @Column({ default: ACCOUNT_PLATFORM.OTHERS })
+  @Field()
+  platform: string
+
+  @Column({
+    nullable: true,
+    default: ACCOUNT_SYNC_STATUS.FAILED
+  })
+  status: string
+
+  @Column()
+  name: string
+
+  @CreateDateColumn()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  updatedAt: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  creator: User
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  updater: User
+}

package/server/entities/account.ts

@@ -1,6 +1,10 @@
+import { Field } 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 { Column, CreateDateColumn, Entity, Index, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm'
+
+import { ACCOUNT_PLATFORM } from '../constants/account'
 
 @Entity()
 @Index('ix_account_0', (account: Account) => [account.domain, account.name], { unique: true })
@@ -11,7 +15,8 @@ export class Account {
   @ManyToOne(type => Domain)
   domain: Domain
 
-  @Column()
+  @Column({ default: ACCOUNT_PLATFORM.OTHERS })
+  @Field()
   platform: string
 
   @Column({
@@ -40,6 +45,11 @@ export class Account {
   })
   accessToken: string
 
+  @Column({
+    nullable: true
+  })
+  webhookKey: string
+
   @Column({ default: false, nullable: true })
   trackedInventory: Boolean
 

package/server/entities/index.ts

@@ -1,5 +1,6 @@
 import { Account } from './account'
+import { AccountWebhookOrder } from './account-webhook-order'
 
-export const entities = [Account]
+export const entities = [Account, AccountWebhookOrder]
 
-export { Account }
+export { Account, AccountWebhookOrder }

package/server/graphql/resolvers/account-webhook-order/account-webhook-order.ts

@@ -0,0 +1,14 @@
+import { getRepository } from 'typeorm'
+
+import { AccountWebhookOrder } from '../../../entities'
+
+export const accountWebhookOrderResolver = {
+  async accountWebhookOrder(_: any, { id }, context: any) {
+    const repository = getRepository(AccountWebhookOrder)
+
+    return await getRepository(AccountWebhookOrder).findOne({
+      where: { domain: context.state.domain, id },
+      relations: ['domain', 'creator', 'updater']
+    })
+  }
+}

package/server/graphql/resolvers/account-webhook-order/account-webhook-orders.ts

@@ -0,0 +1,16 @@
+import { getRepository } from 'typeorm'
+
+import { convertListParams, ListParam } from '@things-factory/shell'
+
+import { AccountWebhookOrder } from '../../../entities'
+
+export const accountWebhookOrdersResolver = {
+  async accountWebhookOrders(_: any, params: ListParam, context: any) {
+    const convertedParams = convertListParams(params, context.state.domain.id)
+    const [items, total] = await getRepository(AccountWebhookOrder).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'creator', 'updater']
+    })
+    return { items, total }
+  }
+}

package/server/graphql/resolvers/account-webhook-order/create-account-webhook-order.ts

@@ -0,0 +1,16 @@
+import { getRepository } from 'typeorm'
+
+import { ACCOUNTING_STATUS } from '../../../controllers'
+import { AccountWebhookOrder } from '../../../entities'
+
+export const createAccountWebhookOrder = {
+  async createAccountWebhookOrder(_: any, { account }, context: any) {
+    return await getRepository(AccountWebhookOrder).save({
+      status: ACCOUNTING_STATUS.INACTIVE,
+      ...account,
+      domain: context.state.domain,
+      creator: context.state.user,
+      updater: context.state.user
+    })
+  }
+}

package/server/graphql/resolvers/account-webhook-order/delete-account-webhook-order.ts

@@ -0,0 +1,20 @@
+import { getRepository } from 'typeorm'
+
+import { ACCOUNTING_STATUS } from '../../../controllers'
+import { AccountWebhookOrder } from '../../../entities'
+
+export const deleteAccountWebhookOrder = {
+  async deleteAccountWebhookOrder(_: any, { id }, context: any) {
+    const foundAccountWebhookOrder: AccountWebhookOrder = await getRepository(AccountWebhookOrder).findOne({
+      where: { domain: context.state.domain, id }
+    })
+
+    await getRepository(AccountWebhookOrder).save({
+      ...foundAccountWebhookOrder,
+      status: ACCOUNTING_STATUS.TERMINATED,
+      updater: context.state.user
+    })
+
+    return true
+  }
+}

package/server/graphql/resolvers/account-webhook-order/delete-account-webhook-orders.ts

@@ -0,0 +1,23 @@
+import { getRepository, In } from 'typeorm'
+
+import { ACCOUNTING_STATUS } from '../../../controllers'
+import { AccountWebhookOrder } from '../../../entities'
+
+export const deleteAccountWebhookOrders = {
+  async deleteAccountWebhookOrders(_: any, { ids }, context: any) {
+    let foundAccountWebhookOrders: AccountWebhookOrder[] = await getRepository(AccountWebhookOrder).find({
+      where: { domain: context.state.domain, id: In(ids) }
+    })
+
+    const updatedAccountWebhookOrder = foundAccountWebhookOrders.map((accountWebhookOrder: AccountWebhookOrder) => {
+      return {
+        ...accountWebhookOrder,
+        status: ACCOUNTING_STATUS.TERMINATED,
+        updater: context.state.user
+      }
+    })
+
+    await getRepository(AccountWebhookOrder).save(updatedAccountWebhookOrder)
+    return true
+  }
+}

package/server/graphql/resolvers/account-webhook-order/index.ts

@@ -0,0 +1,20 @@
+import { accountWebhookOrderResolver } from './account-webhook-order'
+import { accountWebhookOrdersResolver } from './account-webhook-orders'
+import { createAccountWebhookOrder } from './create-account-webhook-order'
+import { deleteAccountWebhookOrder } from './delete-account-webhook-order'
+import { deleteAccountWebhookOrders } from './delete-account-webhook-orders'
+import { updateAccountWebhookOrder } from './update-account-webhook-order'
+import { updateMultipleAccountWebhookOrders } from './update-multiple-account-webhook-orders'
+
+export const Query = {
+  ...accountWebhookOrdersResolver,
+  ...accountWebhookOrderResolver
+}
+
+export const Mutation = {
+  ...updateAccountWebhookOrder,
+  ...updateMultipleAccountWebhookOrders,
+  ...createAccountWebhookOrder,
+  ...deleteAccountWebhookOrder,
+  ...deleteAccountWebhookOrders
+}

package/server/graphql/resolvers/account-webhook-order/update-account-webhook-order.ts

@@ -0,0 +1,18 @@
+import { getRepository } from 'typeorm'
+
+import { AccountWebhookOrder } from '../../../entities'
+
+export const updateAccountWebhookOrder = {
+  async updateAccountWebhookOrder(_: any, { name, patch }, context: any) {
+    const repository = getRepository(AccountWebhookOrder)
+    const accountWebhookOrder: any = await repository.findOne({
+      where: { domain: context.state.domain, name }
+    })
+
+    return await repository.save({
+      ...accountWebhookOrder,
+      ...patch,
+      updater: context.state.user
+    })
+  }
+}

package/server/graphql/resolvers/account-webhook-order/update-multiple-account-webhook-orders.ts

@@ -0,0 +1,44 @@
+import { getRepository } from 'typeorm'
+
+import { AccountWebhookOrder } from '../../../entities'
+
+export const updateMultipleAccountWebhookOrders = {
+  async updateMultipleAccountWebhookOrders(_: any, { patches }, context: any) {
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const accountWebhookOrderRepo = getRepository(AccountWebhookOrder)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await accountWebhookOrderRepo.save({
+          ...newRecord,
+          domain: context.state.domain,
+          creator: context.state.user,
+          updater: context.state.user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const accountWebhookOrder: AccountWebhookOrder = await accountWebhookOrderRepo.findOne(newRecord.id)
+
+        const result = await accountWebhookOrderRepo.save({
+          ...accountWebhookOrder,
+          ...newRecord,
+          updater: context.state.user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+}

package/server/graphql/resolvers/index.ts

@@ -1,5 +1,6 @@
+import * as AccountWebhookOrder from './account-webhook-order'
 import * as Accounting from './accounting'
 
-export const queries = [Accounting.Query]
+export const queries = [Accounting.Query, AccountWebhookOrder.Query]
 
-export const mutations = [Accounting.Mutation]
+export const mutations = [Accounting.Mutation, AccountWebhookOrder.Mutation]

package/server/graphql/types/account-webhook-order/account-webhook-order-list.ts

@@ -0,0 +1,8 @@
+import gql from 'graphql-tag'
+
+export const AccountWebhookOrderList = gql`
+  type AccountWebhookOrderList {
+    items: [AccountWebhookOrder]
+    total: Int
+  }
+`

package/server/graphql/types/account-webhook-order/account-webhook-order-patch.ts

@@ -0,0 +1,12 @@
+import gql from 'graphql-tag'
+
+export const AccountWebhookOrderPatch = gql`
+  input AccountWebhookOrderPatch {
+    id: String
+    name: String
+    platform: String
+    request: String
+    status: String
+    cuFlag: String
+  }
+`