@things-factory/sales-base 4.0.24 → 4.0.25

package/server/service/arrival-notice/arrival-notice-query.ts

@@ -1,13 +1,13 @@
 import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository, In, SelectQueryBuilder } from 'typeorm'
+import { EntityManager, getRepository, In, SelectQueryBuilder } from 'typeorm'
 
 import { Attachment } from '@things-factory/attachment-base'
-import { User } from '@things-factory/auth-base'
-import { Bizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { checkUserBelongsDomain, User } from '@things-factory/auth-base'
+import { Bizplace, getCompanyBizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
 import { ProductDetail } from '@things-factory/product-base'
 import { buildQuery, Domain, ListParam } from '@things-factory/shell'
 
-import { ArrivalNoticeList } from '../'
+import { ArrivalNoticeList, NewArrivalNotice, RawArrivalNotice } from '../'
 import { ATTACHMENT_TYPE, ORDER_STATUS } from '../../constants'
 import { OrderInventory, OrderProduct } from '../../service'
 import { ArrivalNotice } from './arrival-notice'
@@ -34,6 +34,7 @@ export class ArrivalNoticeQuery {
       relations: [
         'domain',
         'bizplace',
+        'bizplace.domain',
         'releaseGood',
         'purchaseOrder',
         'purchaseOrder.bufferLocation',
@@ -117,6 +118,17 @@ export class ArrivalNoticeQuery {
   async arrivalNotices(@Ctx() context: any, @Args() params: ListParam): Promise<ArrivalNoticeList> {
     const { domain, user }: { domain: Domain; user: User } = context.state
 
+    if (await checkUserBelongsDomain(domain, user)) {
+      if (!params.filters.some(e => e.name === 'status') && !params.filters.some(e => e.name === 'name')) {
+        params.filters.push({
+          name: 'status',
+          operator: 'notin',
+          value: [ORDER_STATUS.PENDING, ORDER_STATUS.EDITING],
+          relation: false
+        })
+      }
+    }
+
     if (!params.filters.find((filter: any) => filter.name === 'bizplace')) {
       params.filters.push({
         name: 'bizplaceId',
@@ -287,6 +299,17 @@ export class ArrivalNoticeQuery {
     }
   }
 
+  @Directive('@transaction')
+  @Query(returns => [RawArrivalNotice])
+  async validateBulkArrivalNotices(
+    @Ctx() context: any,
+    @Arg('rawArrivalNotices', type => [NewArrivalNotice], { nullable: true }) rawArrivalNotices: NewArrivalNotice[],
+    @Arg('bizplaceId', type => String) bizplaceId: string
+  ): Promise<RawArrivalNotice[]> {
+    const tx: EntityManager = context.state.tx
+    return await validateBulkArrivalNoticesFunction(rawArrivalNotices, bizplaceId, tx)
+  }
+
   @FieldResolver(type => Domain)
   async domain(@Root() arrivalNotice: ArrivalNotice): Promise<Domain> {
     return await getRepository(Domain).findOne(arrivalNotice.domainId)
@@ -302,3 +325,190 @@ export class ArrivalNoticeQuery {
     return await getRepository(User).findOne(arrivalNotice.updaterId)
   }
 }
+
+export async function validateBulkArrivalNoticesFunction(
+  rawArrivalNotices: NewArrivalNotice[],
+  bizplaceId: string,
+  trxMgr: EntityManager
+): Promise<RawArrivalNotice[]> {
+  const companyBizplace: Bizplace = await getCompanyBizplace(null, null, bizplaceId)
+
+  const json_oi = JSON.stringify(
+    rawArrivalNotices.map(raw => {
+      return {
+        ref_no: raw.refNo || null,
+        ref_no_2: raw.refNo2 || null,
+        ref_no_3: raw.refNo3 || null,
+        eta_date: raw.etaDate || null,
+        truck_no: raw.truckNo || null,
+        own_transport: !!raw.truckNo || false,
+        loose_item: raw.looseItem || false,
+        import_cargo: raw.importCargo || false,
+        container: (!!raw.containerNo && !!raw.containerSize) || false,
+        container_no: raw.containerNo || null,
+        container_size: raw.containerSize || null,
+        sku: raw.sku || null,
+        batch_id: raw.batchId || null,
+        packing_type: raw.packingType || null,
+        packing_size: raw.packingSize || null,
+        uom: raw.uom || null,
+        pack_qty: raw.packQty || null,
+        pallet_qty: raw.palletQty || null,
+        unit_price: raw.unitPrice || null,
+        manufacture_year: raw.manufactureYear || null
+      }
+    })
+  )
+
+  await trxMgr.query(
+    `
+      CREATE TEMP TABLE temp_order_products(
+        ref_no VARCHAR(150),
+        ref_no_2 VARCHAR(150),
+        ref_no_3 VARCHAR(150),
+        eta_date VARCHAR(24),
+        truck_no VARCHAR(10),
+        own_transport BOOLEAN,
+        container BOOLEAN,
+        container_no VARCHAR(50),
+        container_size VARCHAR(24),
+        import_cargo BOOLEAN,
+        loose_item BOOLEAN,
+        sku VARCHAR(150),
+        batch_id VARCHAR(100),
+        packing_type VARCHAR(50),
+        packing_size INT,
+        uom VARCHAR(10),
+        pack_qty INT,
+        pallet_qty INT,
+        unit_price FLOAT8,
+        manufacture_year INT4
+      );
+    `
+  )
+
+  await trxMgr.query(
+    `
+      INSERT INTO temp_order_products 
+      SELECT 
+        js.ref_no, 
+        js.ref_no_2, 
+        js.ref_no_3, 
+        js.eta_date, 
+        js.truck_no, 
+        js.own_transport, 
+        js.container, 
+        js.container_no, 
+        js.container_size, 
+        js.import_cargo, 
+        js.loose_item, 
+        js.sku, 
+        js.batch_id, 
+        js.packing_type, 
+        js.packing_size, 
+        js.uom, 
+        js.pack_qty, 
+        js.pallet_qty, 
+        js.unit_price, 
+        js.manufacture_year 
+      FROM 
+        JSON_POPULATE_RECORDSET(NULL :: temp_order_products, $1) js;
+    `,
+    [json_oi]
+  )
+
+  let validatedItems = await trxMgr.query(
+    `
+      SELECT 
+        tp.ref_no, 
+        tp.ref_no_2, 
+        tp.ref_no_3, 
+        tp.eta_date, 
+        tp.truck_no, 
+        tp.own_transport, 
+        tp.container, 
+        tp.container_no, 
+        tp.container_size, 
+        tp.import_cargo, 
+        tp.loose_item, 
+        pr.id AS product_id, 
+        pd.id AS product_detail_id, 
+        pr.sku AS sku, 
+        CASE WHEN pr.description NOT IN (NULL, '', '-') THEN CONCAT(pr.name, '(', pr.description, ')') ELSE pr.name END AS product_info, 
+        tp.batch_id, 
+        pd.packing_type, 
+        pd.packing_size, 
+        tp.pack_qty, 
+        pd.uom_value, 
+        pd.uom, 
+        CONCAT(COALESCE(ROUND(pd.uom_value :: numeric, 2), 0) * tp.pack_qty, ' ', pd.uom) AS total_uom_value, 
+        tp.pallet_qty, 
+        tp.unit_price, 
+        tp.manufacture_year, 
+        CASE WHEN an.id NOTNULL THEN CONCAT('duplicated with ', an.name) ELSE CASE WHEN pr.id ISNULL OR pd.id ISNULL OR tp.sku ISNULL THEN 'product not found'
+        ELSE CASE WHEN tp.pack_qty <= 0  THEN 'pack qty must be integer'
+        ELSE CASE WHEN tp.batch_id ISNULL THEN 'batch no. is required'
+        ELSE CASE WHEN tp.ref_no ISNULL OR tp.ref_no = '' THEN 'ref no. is required'
+        ELSE CASE WHEN tp.eta_date ISNULL OR tp.eta_date = '' THEN 'eta date is required'
+        ELSE CASE WHEN tp.eta_date:: date < timeofday():: date THEN 'backdate is not allowed'
+        ELSE CASE WHEN tp.container_no NOTNULL AND tp.container_size ISNULL OR tp.container_no ISNULL AND tp.container_size NOTNULL THEN 'incomplete container information'
+        ELSE '' END END END END END END END END AS remark 
+      FROM 
+        temp_order_products tp 
+        LEFT JOIN arrival_notices an ON tp.ref_no = an.ref_no 
+        AND CASE WHEN tp.ref_no_2 NOTNULL THEN tp.ref_no_2 = an.ref_no_2 ELSE 1 = 1 END 
+        AND CASE WHEN tp.ref_no_3 NOTNULL THEN tp.ref_no_3 = an.ref_no_3 ELSE 1 = 1 END 
+        AND CASE WHEN tp.truck_no NOTNULL THEN tp.truck_no = an.truck_no ELSE 1 = 1 END 
+        AND CASE WHEN tp.own_transport NOTNULL THEN tp.own_transport = an.own_transport ELSE 1 = 1 END 
+        AND CASE WHEN tp.container NOTNULL THEN tp.container = an.container ELSE 1 = 1 END 
+        AND CASE WHEN tp.container_no NOTNULL THEN tp.container_no = an.container_no ELSE 1 = 1 END 
+        AND CASE WHEN tp.container_size NOTNULL THEN tp.container_size = an.container_size ELSE 1 = 1 END 
+        AND CASE WHEN tp.loose_item NOTNULL THEN tp.loose_item = an.loose_item ELSE 1 = 1 END 
+        AND CASE WHEN tp.import_cargo NOTNULL THEN tp.import_cargo = an.import_cargo ELSE 1 = 1 END 
+        LEFT JOIN products pr ON pr.sku = tp.sku 
+        LEFT JOIN product_details pd ON pr.id = pd.product_id 
+        AND CASE WHEN tp.packing_type NOTNULL 
+        AND tp.packing_size NOTNULL 
+        AND tp.uom NOTNULL THEN pd.packing_type = tp.packing_type 
+        AND pd.packing_size = tp.packing_size 
+        AND pd.uom = tp.uom ELSE pd.is_default = TRUE END 
+      WHERE 
+        pr.bizplace_id = $1
+
+    `,
+    [companyBizplace.id]
+  )
+
+  await trxMgr.query('DROP TABLE temp_order_products')
+
+  return validatedItems.map(item => {
+    return {
+      refNo: item.ref_no,
+      refNo2: item.ref_no_2,
+      refNo3: item.ref_no_3,
+      etaDate: item.eta_date,
+      truckNo: item.truck_no,
+      ownTransport: !!item.own_transport,
+      container: item.container,
+      containerNo: item.container_no,
+      containerSize: item.container_size,
+      importCargo: !!item.import_cargo,
+      looseItem: !!item.loose_item,
+      productId: item.product_id,
+      productDetailId: item.product_detail_id,
+      sku: item.sku,
+      productInfo: item.product_info,
+      batchId: item.batch_id,
+      packingType: item.packing_type,
+      packingSize: item.packing_size,
+      uom: item.uom,
+      packQty: item.pack_qty,
+      uomValue: item.uom_value,
+      totalUomValue: item.total_uom_value,
+      palletQty: item.pallet_qty,
+      unitPrice: item.unit_price,
+      manufactureYear: item.manufacture_year,
+      remark: item.remark
+    }
+  })
+}

package/server/service/arrival-notice/arrival-notice-types.ts

@@ -1,5 +1,7 @@
+import { Field, Float, InputType, Int, ObjectType } from 'type-graphql'
+
 import { ObjectRef } from '@things-factory/shell'
-import { Field, InputType, Int, ObjectType } from 'type-graphql'
+
 import { NewOrderProduct } from '../order-product/order-product-types'
 import { NewOrderVas } from '../order-vas/order-vas-types'
 import { ArrivalNotice } from './arrival-notice'
@@ -89,6 +91,36 @@ export class NewArrivalNotice {
 
   @Field({ nullable: true })
   partnerBizplaceId: string
+
+  @Field({ nullable: true })
+  sku: string
+
+  @Field({ nullable: true })
+  batchId?: string
+
+  @Field({ nullable: true })
+  packingType?: string
+
+  @Field(type => Float, { nullable: true })
+  packingSize?: number
+
+  @Field(type => Int, { nullable: true })
+  packQty?: number
+
+  @Field(type => Float, { nullable: true })
+  uomValue?: number
+
+  @Field({ nullable: true })
+  uom?: string
+
+  @Field(type => Int, { nullable: true })
+  palletQty?: number
+
+  @Field(type => Float, { nullable: true })
+  unitPrice?: number
+
+  @Field(type => Int, { nullable: true })
+  manufactureYear?: number
 }
 
 @InputType()
@@ -171,3 +203,90 @@ export class ArrivalNoticePatch {
   @Field({ nullable: true })
   deliveryOrderNo: string
 }
+
+@ObjectType()
+export class RawArrivalNotice {
+  @Field({ nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  refNo?: string
+
+  @Field({ nullable: true })
+  refNo2?: string
+
+  @Field({ nullable: true })
+  refNo3?: string
+
+  @Field({ nullable: true })
+  etaDate?: string
+
+  @Field({ nullable: true })
+  truckNo?: string
+
+  @Field()
+  ownTransport: boolean
+
+  @Field({ nullable: true })
+  productId?: string
+
+  @Field({ nullable: true })
+  container?: boolean
+
+  @Field({ nullable: true })
+  containerNo?: string
+
+  @Field({ nullable: true })
+  containerSize?: string
+
+  @Field({ nullable: true })
+  looseItem?: boolean
+
+  @Field({ nullable: true })
+  importCargo?: boolean
+
+  @Field({ nullable: true })
+  productDetailId?: string
+
+  @Field({ nullable: true })
+  sku?: string
+
+  @Field({ nullable: true })
+  productInfo?: string
+
+  @Field({ nullable: true })
+  batchId?: string
+
+  @Field({ nullable: true })
+  packingType?: string
+
+  @Field(type => Float, { nullable: true })
+  packingSize?: number
+
+  @Field(type => Int, { nullable: true })
+  packQty?: number
+
+  @Field(type => Float, { nullable: true })
+  uomValue?: number
+
+  @Field({ nullable: true })
+  totalUomValue?: string
+
+  @Field({ nullable: true })
+  uom?: string
+
+  @Field(type => Int, { nullable: true })
+  palletQty?: number
+
+  @Field(type => Float, { nullable: true })
+  unitPrice?: number
+
+  @Field(type => Int, { nullable: true })
+  manufactureYear?: number
+
+  @Field({ nullable: true })
+  remark?: string
+}

package/server/service/delivery-order/delivery-order-types.ts

@@ -42,7 +42,7 @@ export class NewDeliveryOrder {
   @Field({ nullable: true })
   from: string
 
-  @Field(type => Float, { nullable: false })
+  @Field(type => Float, { nullable: true })
   loadWeight: number
 
   @Field({ nullable: true })

package/server/service/goods-receival-note/goods-receival-note.ts

@@ -1,5 +1,6 @@
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
+import { Attachment } from '@things-factory/attachment-base'
 import { Domain } from '@things-factory/shell'
 import { Field, ID, ObjectType } from 'type-graphql'
 import {
@@ -88,4 +89,7 @@ export class GoodsReceivalNote {
 
   @RelationId((grn: GoodsReceivalNote) => grn.updater)
   updaterId: string
+
+  @Field(type => [Attachment], { nullable: true })
+  attachments: Attachment[]
 }

package/server/service/order-inventory/order-inventory.ts

@@ -106,6 +106,7 @@ export class OrderInventory {
   product: Product
 
   @RelationId((orderInventory: OrderInventory) => orderInventory.product)
+  @Field({ nullable: true })
   productId: string
 
   @Column({ nullable: true })
@@ -138,6 +139,9 @@ export class OrderInventory {
   @RelationId((orderInventory: OrderInventory) => orderInventory.releaseGood)
   releaseGoodId: string
 
+  @Field({ nullable: true })
+  releaseGoodName: string
+
   @ManyToOne(type => InventoryCheck)
   @Field(type => InventoryCheck, { nullable: true })
   inventoryCheck: InventoryCheck
@@ -242,6 +246,9 @@ export class OrderInventory {
   @Field({ nullable: true })
   releaseUomValue: number
 
+  @Field({ nullable: true })
+  releaseUomValueWithUom: string
+
   @Column({ nullable: true })
   @Field({ nullable: true })
   uom: string
@@ -249,9 +256,15 @@ export class OrderInventory {
   @Field({ nullable: true })
   productName: string
 
+  @Field({ nullable: true })
+  productBrand: string
+
   @Field({ nullable: true })
   pallet: string
 
+  @Field({ nullable: true })
+  palletId: string
+
   @Field({ nullable: true })
   extraJsonData: string
 
@@ -275,6 +288,9 @@ export class OrderInventory {
   @Field({ nullable: true })
   actualPalletQty: number
 
+  @Field({ nullable: true })
+  systemRemark: string
+
   @Column({ nullable: true })
   @Field({ nullable: true })
   crossDocking: boolean
@@ -284,7 +300,7 @@ export class OrderInventory {
   serialNumber: string
 
   @Column()
-  @Field()
+  @Field({ nullable: true })
   status: string
 
   @CreateDateColumn()