@things-factory/operato-hub 4.3.561 → 4.3.563

package/server/graphql/resolvers/reports/asn-report.ts

@@ -0,0 +1,141 @@
+import { EntityManager } from 'typeorm'
+import { Bizplace } from '@things-factory/biz-base'
+import { ListParam } from '@things-factory/shell'
+
+export const asnReport = {
+  async asnReport(_: any, params: ListParam, context: any) {
+    try {
+      const { tx }: { tx: EntityManager } = context.state
+
+      // Fetch all bizplace filters from params
+      let bizplaceFilters = params.filters.filter(data => data.name === 'bizplace')
+
+      if (!bizplaceFilters || bizplaceFilters.length === 0)
+        throw 'Invalid input: At least one Bizplace filter is required'
+
+      // Extract bizplace IDs from filters
+      const bizplaceIds = bizplaceFilters.map(filter => filter.value)
+
+      if (!bizplaceIds || bizplaceIds.length === 0) throw 'Invalid input: No Bizplace IDs provided'
+
+      // Query the database for matching Bizplaces to ensure they exist
+      const bizplaces: Bizplace[] = await tx.getRepository(Bizplace).findByIds(bizplaceIds)
+
+      if (!bizplaces || bizplaces.length === 0) throw 'Invalid input: None of the provided Bizplaces were found'
+
+      // Create temporary table for report
+      await tx.query(
+        `
+        create temp table temp_inbound_order_report on commit drop as (
+            select 
+            to_char((grn.created_at + interval '8 hours')::date,'dd/mm/yyyy') as "date_received", 
+            an.delivery_order_no as "do_number",
+            p.sku as "sku",
+            p.name as "descr",
+            coalesce(oi.actual_pack_qty, 0) as "qty",
+            i.pallet_id as "pallet_id",
+            to_char(i.manufacture_date, 'DD/MM/YYYY') as "mfg_date",
+            to_char(i.expiration_date, 'DD/MM/YYYY') as "expiry_date",
+            i.batch_id as "remark"
+            from arrival_notices an 
+            inner join order_products op on an.id = op.arrival_notice_id
+            inner join order_inventories oi 
+            on op.arrival_notice_id = oi.arrival_notice_id 
+            and op.product_id = oi.product_id 
+            and op.product_detail_id = oi.product_detail_id 
+            and oi.batch_id = op.batch_id
+            inner join products p on p.id = op.product_id 
+            inner join inventories i on i.id = oi.inventory_id 
+            inner join goods_receival_notes grn on an.id = grn.arrival_notice_id
+            where i.bizplace_id = ANY($1)
+            and grn.created_at::date = (NOW()::date - interval '1 day')
+            order by "date_received", "pallet_id"
+        )
+        `,
+        [bizplaceIds]
+      )
+
+      // Fetch detailed results
+      const result: any = await tx.query(`
+        select *
+        from temp_inbound_order_report
+      `)
+
+      // Fetch aggregated totals grouped by D/O Number
+      const totals = await tx.query(`
+        select
+        do_number,
+        SUM(COALESCE(qty, 0)) as total_qty
+        from temp_inbound_order_report
+        group by do_number
+        order by do_number
+      `)
+
+      // Map detailed results
+      let items = result.map(itm => ({
+        dateReceived: itm.date_received,
+        doNumber: itm.do_number,
+        sku: itm.sku,
+        descr: itm.descr,
+        qty: itm.qty && !isNaN(itm.qty) ? parseInt(itm.qty, 10) : 0,
+        palletId: itm.pallet_id,
+        mfgDate: itm.mfg_date,
+        expiryDate: itm.expiry_date,
+        remark: itm.remark
+      }))
+
+      // Map aggregated totals
+      let totalItems = totals.map(total => ({
+        doNumber: total.do_number,
+        qty: total.total_qty && !isNaN(total.total_qty) ? parseInt(total.total_qty, 10) : 0
+      }))
+
+      // Insert total counts into the items array
+      totalItems.forEach(total => {
+        // Find the last index of items matching the current total description
+        const lastIndex = items.findLastIndex(item => item.doNumber === total.doNumber)
+
+        if (lastIndex !== -1) {
+          items.splice(lastIndex + 1, 0, {
+            dateReceived: null,
+            doNumber: `${total.doNumber} Total`,
+            sku: null,
+            descr: null,
+            qty: total.qty,
+            palletId: null,
+            mfgDate: null,
+            expiryDate: null,
+            remark: null
+          })
+        }
+      })
+
+      // Calculate grand total
+      const grandTotalQty = totalItems.reduce((sum, total) => {
+        const qty = !isNaN(total.qty) ? parseInt(total.qty, 10) : 0
+        return sum + qty
+      }, 0)
+
+      // Append the grand total row at the end
+      items.push({
+        dateReceived: null,
+        doNumber: 'Grand Total',
+        sku: null,
+        descr: null,
+        qty: grandTotalQty,
+        palletId: null,
+        mfgDate: null,
+        expiryDate: null,
+        remark: null
+      })
+
+      // Return the modified items with inserted totals
+      return {
+        items,
+        totals: totalItems
+      }
+    } catch (error) {
+      throw error
+    }
+  }
+}

package/server/graphql/resolvers/reports/custom-elccl-fn-dispatch-report.ts

@@ -31,7 +31,7 @@ export const customElcclDispatchReport = {
           inner join products p on p.id = oi.product_id
           inner join delivery_orders do2 on rg.id = do2.release_good_id and do2.id = oi.delivery_order_id 
           left join contact_points cp on cp.phone = do2.phone_1 and cp.address = do2.delivery_address_1
-          where rg.bizplace_id in('f0848540-9d8f-4835-b744-2407db36a14e','157a9653-9f2b-4568-b245-ab8791db98ce') 
+          where rg.bizplace_id in('f0848540-9d8f-4835-b744-2407db36a14e','226c9c9d-9685-403d-8f05-89b7d3b8691e','157a9653-9f2b-4568-b245-ab8791db98ce')
           and do2.status in('DELIVERING','DONE')
           and do2.delivery_date::date = (NOW()::date - interval '1 day')
           order by "creation_date" asc    

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

@@ -2,10 +2,16 @@ import { inboundOrderDetailsReport } from './inbound-order-details-report'
 import { outboundOrderDetailsReport } from './outbound-order-details-report'
 import { shortageReport } from './shortage-report'
 import { customElcclDispatchReport } from './custom-elccl-fn-dispatch-report'
+import { agingReport } from './aging-report'
+import { asnReport } from './asn-report'
+import { admiralAsnReport } from './admiral-asn-report'
 
 export const Query = {
   ...inboundOrderDetailsReport,
   ...outboundOrderDetailsReport,
   ...shortageReport,
-  ...customElcclDispatchReport
+  ...customElcclDispatchReport,
+  ...agingReport,
+  ...asnReport,
+  ...admiralAsnReport
 }

package/server/graphql/types/reports/admiral-asn-report-list.ts

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

package/server/graphql/types/reports/admiral-asn-report.ts

@@ -0,0 +1,15 @@
+import gql from 'graphql-tag'
+
+export const AdmiralAsnReport = gql`
+  type AdmiralAsnReport {
+    dateReceived: String
+    doNumber: String
+    sku: String
+    descr: String
+    qty: Int
+    palletId: String
+    mfgDate: String
+    expiryDate: String
+    remark: String
+  }
+`

package/server/graphql/types/reports/aging-report-list.ts

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

package/server/graphql/types/reports/aging-report.ts

@@ -0,0 +1,23 @@
+import gql from 'graphql-tag'
+
+export const AgingReport = gql`
+  type AgingReport {
+    productSku: Int
+    productName: String
+    pallet: Int
+    qtyAvailable: Int
+    lotId: String
+    batchId: String
+    receiptDate: String
+    expDate: String
+    mfgDate: String
+    stockStatus: String
+    defaultUom: String
+    daysInWarehouse: Int
+    daysToExpire: Int
+    monthsInWarehouse: Int
+    monthsToExpire: Int
+    totalPallet: String
+    totalQtyAvailable: String
+  }
+`

package/server/graphql/types/reports/asn-report-list.ts

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

package/server/graphql/types/reports/asn-report.ts

@@ -0,0 +1,15 @@
+import gql from 'graphql-tag'
+
+export const AsnReport = gql`
+  type AsnReport {
+    dateReceived: String
+    doNumber: String
+    sku: String
+    descr: String
+    qty: Int
+    palletId: String
+    mfgDate: String
+    expiryDate: String
+    remark: String
+  }
+`

package/server/graphql/types/reports/index.ts

@@ -6,12 +6,21 @@ import { ShortageReportList } from './shortage-report-list'
 import { ShortageReport } from './shortage-report-type'
 import { CustomElcclDispatchReport } from './custom-elccl-fn-dispatch-report'
 import { CustomElcclDispatchReportList } from './custom-elccl-fn-dispatch-report-list'
+import { AgingReport } from './aging-report'
+import { AgingReportList } from './aging-report-list'
+import { AsnReport } from './asn-report'
+import { AsnReportList } from './asn-report-list'
+import { AdmiralAsnReport } from './admiral-asn-report'
+import { AdmiralAsnReportList } from './admiral-asn-report-list'
 
 export const Query = `
   inboundOrderDetailsReport(filters: [Filter!], pagination: Pagination, sortings: [Sorting!]): InboundOrderDetailsReportList @transaction
   outboundOrderDetailsReport(filters: [Filter!], pagination: Pagination, sortings: [Sorting!]): OutboundOrderDetailsReportList @transaction
   shortageReport(filters: [Filter!], pagination: Pagination, sortings: [Sorting!]):ShortageReportList @transaction
   customElcclDispatchReport(filters: [Filter!], pagination: Pagination, sortings: [Sorting!]): CustomElcclDispatchReportList @transaction
+  agingReport(filters: [Filter!], pagination: Pagination, sortings: [Sorting!]): AgingReportList @transaction
+  asnReport(filters: [Filter!], pagination: Pagination, sortings: [Sorting!]): AsnReportList @transaction
+  admiralAsnReport(filters: [Filter!], pagination: Pagination, sortings: [Sorting!]): AdmiralAsnReportList @transaction
 `
 
 export const Types = [
@@ -22,5 +31,11 @@ export const Types = [
   ShortageReport,
   ShortageReportList,
   CustomElcclDispatchReport,
-  CustomElcclDispatchReportList
+  CustomElcclDispatchReportList,
+  AgingReport,
+  AgingReportList,
+  AsnReport,
+  AsnReportList,
+  AdmiralAsnReport,
+  AdmiralAsnReportList
 ]

package/server/routers/support-router.ts

@@ -1,16 +1,17 @@
 import Router from 'koa-router'
-import { EntityManager, getConnection, getRepository, In, Not, SelectQueryBuilder } from 'typeorm'
-import { OrderPackage, ReleaseGood } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
-import { processAwbAndTrackingNo } from '@things-factory/worksheet-base'
+import { EntityManager, getConnection, getRepository, SelectQueryBuilder } from 'typeorm'
+
+import { Account, AccountingAPI } from '@things-factory/integration-accounting'
+import { MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
 import {
   MarketplaceOrder,
   MarketplaceOrderItem,
-  MarketplaceOrderShippingItem,
-  MarketplaceOrderShipping
+  MarketplaceOrderShipping,
+  MarketplaceOrderShippingItem
 } from '@things-factory/marketplace-base'
-
-import { MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
+import { OrderPackage, OrderProduct, ReleaseGood } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+import { processAwbAndTrackingNo } from '@things-factory/worksheet-base'
 
 const debug = require('debug')('things-factory:integration-accounting:xilnex-router')
 
@@ -131,6 +132,140 @@ supportRouter.post('/update-magento-tracking-no', async (context, next) => {
   }
 })
 
+supportRouter.post('/create-xilnex-sales-orders', async (context, next) => {
+  try {
+    let successRecords: { releaseGoodId: string; salesOrder: any }[] = []
+    let failRecords: { releaseGoodId: string; error: string }[] = []
+
+    const { id } = context.query
+    const { releaseGoodIds } = context.request.body
+
+    const account: Account = await getRepository(Account).findOne({ where: { id: id } })
+
+    const qb: SelectQueryBuilder<ReleaseGood> = getRepository(ReleaseGood)
+      .createQueryBuilder('rg')
+      .innerJoinAndSelect('rg.orderProducts', 'op')
+      .innerJoinAndSelect('op.product', 'p')
+      .where('rg.id IN (:...releaseGoodIds)', {
+        releaseGoodIds: releaseGoodIds
+      })
+
+    let releaseGoods = await qb.getMany()
+
+    for (let i = 0; i < releaseGoods.length; i++) {
+      let releaseGood = releaseGoods[i]
+      let orderProducts = releaseGood.orderProducts
+
+      delete releaseGood.orderProducts
+      try {
+        const salesOrder = await AccountingAPI.createSalesOrder(account, { releaseGood, orderProducts })
+
+        successRecords.push({ releaseGoodId: releaseGood.id, salesOrder: salesOrder })
+      } catch (e) {
+        failRecords.push({
+          releaseGoodId: releaseGood.id,
+          error: e
+        })
+      }
+    }
+
+    context.response.body = {
+      success: successRecords,
+      fail: failRecords
+    }
+  } catch (e) {
+    console.log(e)
+  }
+})
+
+supportRouter.post('/post-xilnex-so-to-si', async (context, next) => {
+  try {
+    let successRecords: { releaseGoodId: string; salesOrderId: string; salesInvoice: any }[] = []
+    let failRecords: { releaseGoodId: string; salesOrderId: string; error: string }[] = []
+
+    const { id } = context.query
+    const { data } = context.request.body
+
+    const account: Account = await getRepository(Account).findOne({ where: { id: id } })
+
+    if (data.length > 0) {
+      for (let i = 0; i < data.length; i++) {
+        let item = data[i]
+        try {
+          const { releaseGoodId, salesOrderId } = item
+
+          const salesInvoice = await AccountingAPI.postSalesOrderToSalesInvoice(account, { orderId: salesOrderId })
+
+          let releaseGood
+          let updatedOrderProducts
+          await getConnection().transaction(async (tx: EntityManager) => {
+            const qb: SelectQueryBuilder<ReleaseGood> = tx
+              .getRepository(ReleaseGood)
+              .createQueryBuilder('rg')
+              .innerJoinAndSelect('rg.orderProducts', 'op')
+              .innerJoinAndSelect('op.product', 'p')
+              .where('rg.id = :releaseGoodId', {
+                releaseGoodId: releaseGoodId
+              })
+
+            releaseGood = await qb.getOne()
+
+            await tx.getRepository(ReleaseGood).update({ id: releaseGood.id }, { refNo3: salesInvoice.sale.id })
+
+            releaseGood.refNo3 = salesInvoice.sale.id
+            let orderProducts = releaseGood.orderProducts
+            updatedOrderProducts = await Promise.all(
+              orderProducts.map(async op => {
+                let foundSalesItem = salesInvoice.sale.items.find(item => item.itemCode == op.product.sku)
+
+                await tx.getRepository(OrderProduct).update({ id: op.id }, { refItemId: foundSalesItem.id.toString() })
+
+                return {
+                  id: op.id,
+                  refItemId: foundSalesItem.id.toString(),
+                  releaseQty: op.releaseQty
+                }
+              })
+            )
+          })
+
+          await AccountingAPI.createShipment(account, { releaseGood, orderProducts: updatedOrderProducts })
+
+          successRecords.push({
+            releaseGoodId: releaseGoodId,
+            salesOrderId: salesOrderId,
+            salesInvoice: {
+              salesId: salesInvoice.salesId,
+              shippingStatus: salesInvoice.sale.shippingStatus,
+              status: salesInvoice.sale.status,
+              paymentStatus: salesInvoice.sale.paymentStatus,
+              saleItems: salesInvoice.sale.items.map(item => {
+                return {
+                  id: item.id,
+                  quantity: item.quantity
+                }
+              })
+            }
+          })
+        } catch (e) {
+          failRecords.push({
+            releaseGoodId: item.releaseGoodId,
+            salesOrderId: item.salesOrderId,
+            error: JSON.stringify(e)
+          })
+        }
+      }
+    }
+
+    context.response.body = {
+      success: successRecords,
+      fail: failRecords
+    }
+  } catch (e) {
+    console.log(e)
+  }
+})
+
 async function updateTrackingNo(tx, marketplaceOrder, marketplaceStore, orderPackage) {
   try {
     const companyDomain: Domain = marketplaceStore.domain