@things-factory/worksheet-base 5.0.0-alpha.38 → 5.0.0-alpha.40

package/server/controllers/render-grn.ts

@@ -52,25 +52,25 @@ export async function renderGRN({ grnNo, timezoneOffSet }, context: any) {
   })
 
   const qbReducedInventory = getRepository(ReducedInventoryHistory)
-    .createQueryBuilder(`ivh`)
-    .select(`product_id`, `productId`)
-    .addSelect(`batch_id`, `batchId`)
-    .addSelect(`reusable_pallet_id`, `reusablePalletId`)
-    .addSelect(`packing_type`, `packingType`)
-    .addSelect(`sum(qty)`, `qty`)
-    .addSelect(`sum(uom_value)`, `uomValue`)
-    .addSelect(`uom`, `uom`)
-    .addSelect(`count(distinct pallet_id)`, `pallet`)
-    .addSelect(`string_agg(distinct expiration_date::varchar,', ' order by expiration_date::varchar)`, `expiryDate`)
-    .addSelect(`string_agg(distinct pallet_id::varchar,', ' order by pallet_id::varchar)`, `palletId`)
-    .where(`ivh.domain_id = :domainId`, { domainId: domain.id })
-    .andWhere(`ivh.ref_order_id = :refOrderId`, { refOrderId: foundGAN.id })
+    .createQueryBuilder('ivh')
+    .select('product_id', 'productId')
+    .addSelect('batch_id', 'batchId')
+    .addSelect('reusable_pallet_id', 'reusablePalletId')
+    .addSelect('packing_type', 'packingType')
+    .addSelect('sum(qty)', 'qty')
+    .addSelect('sum(uom_value)', 'uomValue')
+    .addSelect('uom', 'uom')
+    .addSelect('count(distinct pallet_id)', 'pallet')
+    .addSelect(`string_agg(distinct expiration_date::varchar,', ' order by expiration_date::varchar)`, 'expiryDate')
+    .addSelect(`string_agg(distinct pallet_id::varchar,', ' order by pallet_id::varchar)`, 'palletId')
+    .where('ivh.domain_id = :domainId', { domainId: domain.id })
+    .andWhere('ivh.ref_order_id = :refOrderId', { refOrderId: foundGAN.id })
     .andWhere(`ivh.transaction_type = 'UNLOADING'`)
-    .groupBy(`reusable_pallet_id`)
-    .addGroupBy(`product_id`)
-    .addGroupBy(`batch_id`)
-    .addGroupBy(`packing_type`)
-    .addGroupBy(`uom`)
+    .groupBy('reusable_pallet_id')
+    .addGroupBy('product_id')
+    .addGroupBy('batch_id')
+    .addGroupBy('packing_type')
+    .addGroupBy('uom')
     .getRawMany()
 
   // 5. find domain contact point

package/server/controllers/render-po.ts

@@ -0,0 +1,170 @@
+import FormData from 'form-data'
+import fetch from 'node-fetch'
+import { getRepository, SelectQueryBuilder } from 'typeorm'
+
+import { Attachment, STORAGE } from '@things-factory/attachment-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { config } from '@things-factory/env'
+import { InvoiceProduct, ReleaseGood, PurchaseOrder, PurchaseOrderOtherCharge, OrderProduct } from '@things-factory/sales-base'
+
+import { Domain } from '@things-factory/shell'
+
+import { TEMPLATE_TYPE } from '../constants'
+import { DateTimeConverter } from '../utils/datetime-util'
+
+const REPORT_API_URL = config.get('reportApiUrl', 'http://localhost:8888/rest/report/show_html')
+
+export async function renderPO({ req, timezoneOffSet }, context: any) {
+  try {
+    const domain: Domain = await getRepository(Domain).findOne({
+      where: { id: context.state.domain.id }
+    })
+
+    let result = await Promise.all(
+      req.poIds.map(async poId => {
+        try {
+          const qb: SelectQueryBuilder<PurchaseOrder> = await getRepository(PurchaseOrder)
+            .createQueryBuilder('po')
+            .innerJoinAndSelect('po.domain', 'domain')
+            .innerJoinAndSelect('po.bizplace', 'bizplace')
+            .innerJoinAndSelect('bizplace.domain', 'bizplace_domain')
+            .innerJoinAndSelect('bizplace.company', 'company')
+            .innerJoinAndSelect('company.domain', 'company_domain')
+            .leftJoinAndSelect('contact_points', 'cp', 'po.supplier_id = cp.id')
+            .where('po.id = :poId')
+            .andWhere('po.domain = :domainId')
+            .setParameters({ poId, domainId: domain.id })
+
+          let record: any = await qb.getRawOne()
+
+          if (record) {
+            const partnerBiz: Partial<Bizplace> = {
+              id: record.bizplace_id,
+              name: record.bizplace_name,
+              address: record.bizplace_address,
+              domain: { id: record.bizplace_domain_id }
+            }
+
+            const foundTemplate: Attachment = await getRepository(Attachment).findOne({
+              where: { domain: partnerBiz.domain, category: TEMPLATE_TYPE.PO_TEMPLATE }
+            })
+
+            const foundLogo: Attachment = await getRepository(Attachment).findOne({
+              where: {
+                domain: partnerBiz.domain,
+                category: TEMPLATE_TYPE.LOGO
+              }
+            })
+
+            let logo = null
+            if (foundLogo?.path) {
+              logo = 'data:' + foundLogo.mimetype + ';base64,' + (await STORAGE.readFile(foundLogo.path, 'base64'))
+            }
+
+            const template = await STORAGE.readFile(foundTemplate.path, 'utf-8')
+
+            const poocQb: SelectQueryBuilder<PurchaseOrderOtherCharge> = await getRepository(PurchaseOrderOtherCharge)
+              .createQueryBuilder('pooc')
+              .where('pooc.purchase_order_id = :poId')
+              .andWhere('pooc.apply_in_items = false')
+              .setParameters({ poId })
+
+            let poOtherCharges: any[] = await poocQb.getRawMany()
+
+
+            const qb: SelectQueryBuilder<OrderProduct> = await getRepository(OrderProduct)
+              .createQueryBuilder('op')
+              .innerJoin('domains', 'd', 'op.domain_id = d.id')
+              .leftJoinAndSelect('purchase_orders', 'po', 'po.id = op.purchase_order_id')
+              .leftJoinAndSelect('products', 'p', 'op.product_id = p.id')
+              .where('op.purchase_order_id = :poId')
+              .andWhere('op.domain = :domainId')
+              .setParameters({ poId, domainId: domain.id })
+
+            let items: any[] = await qb.getRawMany()
+
+            const product_list = items.map((item, idx) => {
+              return {
+                list_no: idx + 1,
+                product_sku: item.p_sku,
+                product_name: item.p_name,
+                product_desc: item.p_description,
+                product_qty: item.op_pack_qty,
+                product_uom: item.op_uom,
+                product_other_charges: item.ip_other_charges,
+                product_unit_price: (item.op_unit_price).toFixed(2),
+                product_total_price: ((((item.op_unit_price || 0) * item.op_pack_qty) - (item.op_discount_amt || 0)) * (1 + (item.op_tax_rate / 100))).toFixed(2),
+                product_tax_rate: item.op_tax_rate,
+                product_disc_amt: item.op_discount_amt
+              }
+            })
+
+
+            let date = DateTimeConverter.date(new Date(record.po_created_at - timezoneOffSet))
+            let eta = DateTimeConverter.date(new Date(record.po_eta_date))
+
+            let subtotal = getRoundedValue(
+              product_list.reduce((init, item) => {
+                return (init += parseFloat(item.product_total_price))
+              }, 0) || 0
+            )
+
+            const data = {
+              logo_url: logo,
+              company_name: record.company_description,
+              company_address: record.company_address,
+              company_postal_code: record.company_postal_code,
+              po_number: record.po_name,
+              po_order_date: date,
+              po_delivery_date: eta,
+              ref_no: record.po_ref_no,
+              cp_company_name: record.cp_company_name,
+              cp_address: record.cp_address2 ? [record.cp_address, record.cp_address2].join(', ') : record.cp_address,
+              cp_contact_name: record.cp_name,
+              cp_email: record.cp_email,
+              cp_phone_number: record.cp_phone,
+              product_list,
+              charges_list: [
+                {
+                  field: 'SUBTOTAL', value: subtotal.toFixed(2)
+                },
+                ...poOtherCharges.map(itm => { return { field: itm.pooc_name.toUpperCase(), value: itm.pooc_total_amt.toFixed(2) } }),
+                {
+                  field: 'TOTAL', value: (poOtherCharges.reduce((init, item) => {
+                    return init += (item.pooc_total_amt)
+                  }, subtotal) || 0).toFixed(2),
+                },
+              ]
+            }
+
+            const formData = new FormData()
+            formData.append('template', template)
+            formData.append('jsonString', JSON.stringify(data))
+
+            const response = await fetch(REPORT_API_URL, {
+              method: 'POST',
+              body: formData
+            })
+
+            return await response.text()
+          }
+          return null
+        } catch (ex) {
+          return null
+        }
+      })
+    )
+
+    if (result.filter(x => x != null).length <= 0) {
+      throw Error('No purchase order found!')
+    }
+
+    return result.join()
+  } catch (ex) {
+    throw ex
+  }
+}
+
+function getRoundedValue(value = 0) {
+  return Math.round((value + Number.EPSILON) * 100) / 100
+}

package/server/graphql/resolvers/worksheet/cycle-count-adjustment.ts

@@ -56,7 +56,9 @@ export async function cycleCountAdjustment(
       'targetInventory.inventory.product.productDetails',
       'targetInventory.inventory.product.productDetails.childProductDetail',
       'targetInventory.inventory.bizplace',
+      'targetInventory.inventory.domain',
       'targetInventory.inventory.bizplace.domain',
+      'targetInventory.inventory.warehouse',
       'targetInventory.inventory.location',
       'targetInventory.inspectedLocation',
       'targetInventory.inspectedLocation.warehouse'
@@ -67,8 +69,8 @@ export async function cycleCountAdjustment(
     const targetInventory: OrderInventory = worksheetDetail.targetInventory
     let inventory: Inventory = targetInventory.inventory
 
-    const transactQty: number = targetInventory.inspectedQty - inventory.qty
-    const transactUomValue: number = targetInventory.inspectedUomValue - inventory.uomValue
+    let transactQty: number = targetInventory.inspectedQty - inventory.qty
+    let transactUomValue: number = targetInventory.inspectedUomValue - inventory.uomValue
 
     const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOne({
       where: { domain: inventory.bizplace.domain, status: SellercraftStatus.ACTIVE }
@@ -137,16 +139,23 @@ export async function cycleCountAdjustment(
 
       if (targetInventory.inspectedBatchNo !== inventory.batchId) {
         // generate TERMINATED, ADJUSTMENT history
+        const { qty, uomValue }: { qty: number; uomValue: number } = inventory
         inventory.status = INVENTORY_STATUS.TERMINATED
+        inventory.qty = 0
+        inventory.uomValue = 0
+
         await generateInventoryHistory(
           inventory,
           cycleCount,
           INVENTORY_TRANSACTION_TYPE.CC_ADJUSTMENT,
-          -transactQty,
-          -transactUomValue,
+          -qty,
+          -uomValue,
           user,
           tx
         )
+
+        transactQty = targetInventory.inspectedQty
+        transactUomValue = targetInventory.inspectedUomValue
       }
 
       inventory.batchId = targetInventory.inspectedBatchNo

package/server/graphql/resolvers/worksheet/loading/complete-loading.ts

@@ -1,11 +1,14 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
-import { OrderInventory, ORDER_INVENTORY_STATUS, ORDER_STATUS, ReleaseGood } from '@things-factory/sales-base'
+import { Sftp, SftpAPI } from '@things-factory/integration-sftp'
+import { ORDER_INVENTORY_STATUS, ORDER_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+import { InventoryItem } from '@things-factory/warehouse-base'
+
 import { WORKSHEET_TYPE } from '../../../../constants'
 import { LoadingWorksheetController, ReturningWorksheetController } from '../../../../controllers'
 import { Worksheet, WorksheetDetail } from '../../../../entities'
-import { Sftp, SftpAPI } from '@things-factory/integration-sftp'
 
 export const completeLoadingResolver = {
   async completeLoading(_: any, { releaseGoodNo }, context: any) {
@@ -46,12 +49,23 @@ export async function completeLoading(
     where: { domain: customerDomain }
   })
   if (customerAvailableSftp) {
-    let result: Sftp = await SftpAPI.createShipment(customerAvailableSftp, {
+    let inventoryItems: InventoryItem[] = await tx.getRepository(InventoryItem).find({
+      where: { domain, outboundOrderId: releaseGood.id }
+    })
+
+    let shipmentResult: Sftp = await SftpAPI.createShipment(customerAvailableSftp, {
       releaseGood,
       orderInventories: targetInventories,
       sftp: customerAvailableSftp
     })
-    customerAvailableSftp = await tx.getRepository(Sftp).save(result)
+    customerAvailableSftp = await tx.getRepository(Sftp).save(shipmentResult)
+
+    let snResult: Sftp = await SftpAPI.createSerialNumber(customerAvailableSftp, {
+      releaseGood,
+      inventoryItems,
+      sftp: customerAvailableSftp
+    })
+    customerAvailableSftp = await tx.getRepository(Sftp).save(snResult)
   }
 
   await worksheetController.completeLoading(releaseGoodNo)

package/server/graphql/resolvers/worksheet/picking/complete-picking.ts

@@ -205,8 +205,11 @@ export async function completePicking(
             }
           }
         } else {
-          throw resp
-          //Failed
+          if (resp?.AWBurl && resp?.TrackingNo)
+            await tx
+              .getRepository(MarketplaceOrderShipping)
+              .update({ id: marketplaceOrderShipping.id }, { airwayBill: resp.AWBurl, trackingNo: resp.TrackingNo })
+          else throw resp
         }
       }
     }

package/server/graphql/resolvers/worksheet/picking/picking-assignment-status-by-user.ts

@@ -1,79 +1,82 @@
-import { getDomainUsers, User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { FindManyOptions, getRepository, ILike, In } from 'typeorm'
+import { getDomainUsers, User, Role } from '@things-factory/auth-base'
+import { Domain, ListParam, buildQuery, Sorting} from '@things-factory/shell'
+import { FindManyOptions, getRepository, ILike, In, EntityManager, getManager, SelectQueryBuilder } from 'typeorm'
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../constants'
 import { Worksheet } from '../../../../entities'
 
-type AssignmentStatusByUserType = { user: User; pending?: Worksheet[]; picking?: Worksheet[] }
+type AssignmentStatusByUserType = { user: User; pending?: String; picking?: String }
 
 export const pickingAssignmentStatusByUsersResolver = {
   async pickingAssignmentStatusByUsers(
     _: void,
-    { name, email }: { name?: string; email?: string },
+    params: ListParam,
     context: any
   ): Promise<AssignmentStatusByUserType[]> {
+    
     const { domain }: { domain: Domain } = context.state
-    const domainUsers: User[] = await getDomainUsers(domain)
 
-    const domainUserIds: string[] = domainUsers
-      .filter((user: User) => user.userType === 'user')
-      .map((user: User) => user.id)
+    const nameFilter = params.filters.find(p=>{return p.name == "name"});
+    const emailFilter = params.filters.find(p=>{return p.name == "email"});
+    const roleFilter = params.filters.find(p=>{return p.name == 'roles'});
 
-    const findOneOption: FindManyOptions<User> = { where: { id: In(domainUserIds) } }
-    if (name) findOneOption.where.name = ILike(`%${name}%`)
-    if (email) findOneOption.where.email = ILike(`%${email}%`)
+    const pendingSorter = params.sortings.find(p=>{return p.name == 'pending'});
+    const pickingSorter = params.sortings.find(p=>{return p.name == 'picking'});
 
-    const users: User[] = await getRepository(User).find(findOneOption)
 
-    const assignedPickingWorksheets: Worksheet[] = await getRepository(Worksheet).find({
-      where: {
-        type: In([WORKSHEET_TYPE.PICKING, WORKSHEET_TYPE.BATCH_PICKING]),
-        status: In([WORKSHEET_STATUS.DEACTIVATED, WORKSHEET_STATUS.EXECUTING]),
-        assignee: In(users.map((u: User) => u.id)),
-        domain
-      },
-      relations: ['assignee']
-    })
 
-    const assignmentMap: Map<string, AssignmentStatusByUserType> = assignedPickingWorksheets.reduce(
-      (assignmentMap: Map<string, AssignmentStatusByUserType>, worksheet: Worksheet) => {
-        const assignee: User = worksheet.assignee
-        const status: string = worksheet.status
+    const getUserInfoQb:SelectQueryBuilder<User> = await getRepository(User).createQueryBuilder('u')
 
-        if (assignmentMap.has(assignee.id)) {
-          const assignment: AssignmentStatusByUserType = assignmentMap.get(assignee.id)
-          if (status === WORKSHEET_STATUS.DEACTIVATED) {
-            assignment.pending.push(worksheet)
-          } else if (status === WORKSHEET_STATUS.EXECUTING) {
-            assignment.picking.push(worksheet)
-          }
-        } else {
-          if (status === WORKSHEET_STATUS.DEACTIVATED) {
-            assignmentMap.set(assignee.id, {
-              user: assignee,
-              pending: [worksheet],
-              picking: []
-            })
-          } else if (status === WORKSHEET_STATUS.EXECUTING) {
-            assignmentMap.set(assignee.id, {
-              user: assignee,
-              pending: [],
-              picking: [worksheet]
-            })
-          }
-        }
+    getUserInfoQb.select('u.id')
+    getUserInfoQb.addSelect('u.name')
+    getUserInfoQb.addSelect('u.email')
+    getUserInfoQb.addSelect("string_agg(r.name,', ') as roles")
+    getUserInfoQb.innerJoin('u.roles','r')
+    getUserInfoQb.where('r.domain_id = :domainId',{domainId:domain.id})
+    roleFilter? getUserInfoQb.andWhere('r.name ilike :userRole', { userRole: `%${roleFilter.value}%` }) :""
+    nameFilter? getUserInfoQb.andWhere('u.name ilike :userName', { userName: `%${nameFilter.value}%` }) :""
+    emailFilter? getUserInfoQb.andWhere('u.email ilike :userEmail', { userEmail: `%${emailFilter.value}%` }) :""
+    getUserInfoQb.andWhere('r.name not ilike :userR',{userR:`%CLIENT%`})
+    getUserInfoQb.andWhere('u.user_type = :userType',{userType:"user"})
+    getUserInfoQb.groupBy('u.id')
+    getUserInfoQb.addGroupBy('u.name')
+    getUserInfoQb.addGroupBy('u.email')
 
-        return assignmentMap
-      },
-      new Map()
-    )
+    const getAssignedWSQb = await getRepository(Worksheet).createQueryBuilder('ws')
 
-    users.forEach((user: User) => {
-      if (!assignmentMap.has(user.id)) {
-        assignmentMap.set(user.id, { user, pending: [], picking: [] })
-      }
-    })
+    getAssignedWSQb.select('ws.assignee_id')
+    getAssignedWSQb.addSelect('u.name')
+    getAssignedWSQb.addSelect("sum(case when ws.status='EXECUTING' then 1 else 0 end) as picking")
+    getAssignedWSQb.addSelect("sum(case when ws.status='DEACTIVATED' then 1 else 0 end) as pending")
+    getAssignedWSQb.innerJoin('ws.assignee','u')
+    getAssignedWSQb.where('ws.domain_id = :id',{id:domain.id})
+    getAssignedWSQb.andWhere('ws.type IN (:...type)', {type: [WORKSHEET_TYPE.PICKING, WORKSHEET_TYPE.BATCH_PICKING]})
+    getAssignedWSQb.andWhere('ws.status IN (:...status)', {status: [WORKSHEET_STATUS.DEACTIVATED, WORKSHEET_STATUS.EXECUTING]})
+    getAssignedWSQb.groupBy('ws.assignee_id')
+    getAssignedWSQb.addGroupBy('u.name')
+    pendingSorter?.desc ? getAssignedWSQb.orderBy('pending','DESC') : ''
+    pickingSorter?.desc ? getAssignedWSQb.orderBy('picking','DESC') : ''
+    pickingSorter && Object.keys(pickingSorter).length == 1 ?getAssignedWSQb.orderBy('picking','ASC') : ''
+    pendingSorter && Object.keys(pendingSorter).length == 1 ? getAssignedWSQb.orderBy('pending','ASC') : ''
+
+
+    const parameter1= getUserInfoQb.getParameters()
+    const parameter2 = getAssignedWSQb.getParameters()
 
-    return Array.from(assignmentMap.values())
+    const combineParams = Object.assign(parameter1, parameter2)
+  
+    const combineQb = getManager().createQueryBuilder()
+
+    combineQb.select('u.*')
+    combineQb.addSelect('coalesce(ws.picking, 0) as picking')
+    combineQb.addSelect('coalesce(ws.pending, 0) as pending')
+    combineQb.from("(" + getUserInfoQb.getQuery() + ")","u")
+    combineQb.leftJoin("(" + getAssignedWSQb.getQuery() + ")","ws",' ws.assignee_id = u.u_id')
+    combineQb.setParameters(combineParams)
+    
+    const combineInfo = await combineQb.getRawMany()
+
+    return combineInfo.map(itm => {
+      return { user: { id:itm.u_id,email:itm.u_email,name:itm.u_name, description: itm.roles },pending:itm.pending,picking:itm.picking }
+    })
   }
 }

package/server/graphql/resolvers/worksheet/worksheets.ts

@@ -99,6 +99,7 @@ export const worksheetsResolver = {
       const releaseGoodCrossDockingParam = params.filters.find(param => param.name === 'crossDocking')
       const releaseGoodCourierOptionParam = params.filters.find(param => param.name === 'courierOption')
       const releaseGoodPackingOptionParam = params.filters.find(param => param.name === 'packingOption')
+      const releaseGoodPickerOptionParam = params.filters.find(param => param.name === 'assignee')
       if (
         releaseGoodParam ||
         releaseGoodRefNoParam ||
@@ -252,6 +253,31 @@ export const worksheetsResolver = {
         }
       }
 
+      //find assignee
+
+      const assigneeParam = params.filters.find(param => param.name === 'assignee')
+      let assigneeFilter = []
+      if (assigneeParam) {
+        params.filters.splice(
+          params.filters.findIndex(item => item.name == 'assignee'),
+          1
+        )
+        assigneeFilter.push({ ...assigneeParam, name: 'name' })
+
+        const foundAssignee: User[] = await getRepository(User).find({
+          ...convertListParams({ filters: assigneeFilter })
+        })
+
+        if (foundAssignee) {
+          params.filters.push({
+            name: 'assigneeId',
+            operator: 'in',
+            value: foundAssignee.map((foundIC: User) => foundIC.id),
+            relation: false
+          })
+        }
+      }
+
       ////Set default bizplace filter
       const bizplaceFilter = params.filters.find(param => param.name === 'bizplaceId')
       if (!bizplaceFilter && typeParam.value[0] !== WORKSHEET_TYPE.BATCH_PICKING) {

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

@@ -681,8 +681,9 @@ export const Query = /* GraphQL */ `
   ): [Inventory] @privilege(category: "worksheet", privilege: "query")
 
   pickingAssignmentStatusByUsers(
-    name: String
-    email: String
+    filters: [Filter],
+    pagination: Pagination,
+    sortings: [Sorting]
   ): [PickingAssignmentStatus] @privilege(category: "worksheet", privilege: "query")
 
   myPickingAssignmentStatus: MyPickingAssignmentStatus @privilege(category: "worksheet", privilege: "query")

package/server/graphql/types/worksheet/picking-assignment-status.ts

@@ -3,7 +3,7 @@ import { gql } from 'apollo-server-koa'
 export const PickingAssignmentStatus = gql`
   type PickingAssignmentStatus {
     user: User
-    pending: [Worksheet]
-    picking: [Worksheet]
+    pending: String
+    picking: String
   }
 `

package/server/graphql/types/worksheet/worksheet-patch.ts

@@ -11,6 +11,7 @@ export const WorksheetPatch = gql`
     initialBatchId: String
     status: String
     truckNo: String
+    transportDriver: ObjectRef
     palletQty: String
     ownCollection: Boolean
     cuFlag: String

package/server/index.ts

@@ -10,3 +10,4 @@ export * from './graphql/resolvers/worksheet-detail/generate-release-good-worksh
 export * from './graphql/resolvers/worksheet/unloading/activate-unloading'
 export * from './graphql/resolvers/worksheet/picking/activate-picking'
 export * from './migrations'
+export * from './controllers'

package/server/routes.ts

@@ -8,7 +8,10 @@ import { renderOrientageDO } from './controllers/render-orientage-do'
 import { renderOrientageGRN } from './controllers/render-orientage-grn'
 import { renderRODO } from './controllers/render-ro-do'
 import { renderSeebuuGRN } from './controllers/render-seebuu-grn'
+import { renderFmGRN } from './controllers/render-fm-grn'
 import { renderInvoices } from './controllers/render-invoices'
+import { renderPO } from './controllers/render-po'
+
 
 process.on('bootstrap-module-domain-private-route' as any, (app, routes) => {
   routes.get('/view_document_ro_do/:doNo', async (context, next) => {
@@ -43,6 +46,10 @@ process.on('bootstrap-module-domain-private-route' as any, (app, routes) => {
     context.body = await renderSeebuuGRN(context.params, context)
   })
 
+  routes.get('/view_fm_grn/:grnNo/:timezoneOffSet', async (context, next) => {
+    context.body = await renderFmGRN(context.params, context)
+  })
+
   routes.get('/view_job_sheet/:ganNo/:timezoneOffSet', async (context, next) => {
     context.body = await renderJobSheet(context.params, context)
   })
@@ -60,4 +67,14 @@ process.on('bootstrap-module-domain-private-route' as any, (app, routes) => {
     context.type = 'application/json'
     context.body = data
   })
+
+  routes.post('/view_purchase_orders/:timezoneOffSet', async (context, next) => {
+    let req = context.request.body || {}
+    let timezoneOffSet = context.params.timezoneOffSet || 0
+
+    let data = await renderPO({ req, timezoneOffSet }, context)
+
+    context.type = 'application/json'
+    context.body = data
+  })
 })