@things-factory/sales-base 4.0.0-alpha.8 → 4.0.0-beta.2

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

@@ -0,0 +1,216 @@
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { Product } from '@things-factory/product-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+import {
+  ArrivalNotice,
+  ReleaseGood,
+  RetailReplenishmentOrder,
+  ReturnOrder,
+  ShippingOrder,
+  TransferOrder,
+  Vas,
+  VasOrder
+} from '../'
+
+@Entity('order_vass')
+@Index('ix_order-vas_0', (orderVas: OrderVas) => [orderVas.domain, orderVas.name], { unique: true })
+@ObjectType()
+export class OrderVas {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain, { nullable: false })
+  @Field(type => Domain)
+  domain: Domain
+
+  @RelationId((orderVas: OrderVas) => orderVas.domain)
+  domainId: string
+
+  @ManyToOne(type => Bizplace, { nullable: false })
+  @Field(type => Bizplace)
+  bizplace: Bizplace
+
+  @RelationId((orderVas: OrderVas) => orderVas.bizplace)
+  bizplaceId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  batchId: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  set: number
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  targetType: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  targetBatchId: string
+
+  @ManyToOne(type => Product)
+  @Field(type => Product, { nullable: true })
+  targetProduct: Product
+
+  @RelationId((orderVas: OrderVas) => orderVas.targetProduct)
+  targetProductId: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  otherTarget: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  qty: number
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  actualQty: number
+
+  @Column('float', { nullable: true })
+  @Field({ nullable: true })
+  uomValue: number
+
+  @Column('float', { nullable: true })
+  @Field({ nullable: true })
+  actualUomValue: number
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  productName: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  packingType: string
+
+  @ManyToOne(type => ArrivalNotice)
+  @Field(type => ArrivalNotice, { nullable: true })
+  arrivalNotice: ArrivalNotice
+
+  @RelationId((orderVas: OrderVas) => orderVas.arrivalNotice)
+  arrivalNoticeId: string
+
+  @ManyToOne(type => ReleaseGood)
+  @Field(type => ReleaseGood, { nullable: true })
+  releaseGood: ReleaseGood
+
+  @RelationId((orderVas: OrderVas) => orderVas.releaseGood)
+  releaseGoodId: string
+
+  @ManyToOne(type => ShippingOrder)
+  @Field(type => ShippingOrder, { nullable: true })
+  shippingOrder: ShippingOrder
+
+  @RelationId((orderVas: OrderVas) => orderVas.shippingOrder)
+  shippingOrderId: string
+
+  @ManyToOne(type => TransferOrder)
+  @Field(type => TransferOrder, { nullable: true })
+  transferOrder: TransferOrder
+
+  @RelationId((orderVas: OrderVas) => orderVas.transferOrder)
+  transferOrderId: string
+
+  @ManyToOne(type => ReturnOrder)
+  @Field(type => ReturnOrder, { nullable: true })
+  returnOrder: ReturnOrder
+
+  @RelationId((orderVas: OrderVas) => orderVas.returnOrder)
+  returnOrderId: string
+
+  @ManyToOne(type => RetailReplenishmentOrder)
+  @Field(type => RetailReplenishmentOrder, { nullable: true })
+  retailReplenishmentOrder: RetailReplenishmentOrder
+
+  @RelationId((orderVas: OrderVas) => orderVas.retailReplenishmentOrder)
+  retailReplenishmentOrderId: string
+
+  @ManyToOne(type => OrderVas)
+  @Field(type => OrderVas, { nullable: true })
+  orderVas: OrderVas
+
+  @RelationId((orderVas: OrderVas) => orderVas.orderVas)
+  orderVasId: string
+
+  @ManyToOne(type => VasOrder)
+  @Field(type => VasOrder, { nullable: true })
+  vasOrder: VasOrder
+
+  @RelationId((orderVas: OrderVas) => orderVas.vasOrder)
+  vasOrderId: string
+
+  @ManyToOne(type => Vas)
+  @Field(type => Vas, { nullable: true })
+  vas: Vas
+
+  @RelationId((orderVas: OrderVas) => orderVas.vas)
+  vasId: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  operationGuide: string
+
+  @ManyToOne(type => Inventory)
+  @Field(type => Inventory, { nullable: true })
+  inventory: Inventory
+
+  @RelationId((orderVas: OrderVas) => orderVas.inventory)
+  inventoryId: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  type: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  remark: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description: string
+
+  @Column()
+  @Field()
+  status: string
+
+  @CreateDateColumn()
+  @Field()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field()
+  updatedAt: Date
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  creator: User
+
+  @RelationId((orderVas: OrderVas) => orderVas.creator)
+  creatorId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  updater: User
+
+  @RelationId((orderVas: OrderVas) => orderVas.updater)
+  updaterId: string
+}

package/server/service/others/index.ts

@@ -0,0 +1,3 @@
+import { OtherQuery } from './other-query'
+
+export const resolvers = [OtherQuery]

package/server/service/others/other-query.ts

@@ -0,0 +1,319 @@
+import orderBy from 'lodash/orderBy'
+import { Arg, Ctx, Directive, Query, Resolver } from 'type-graphql'
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace, getPermittedBizplaces } from '@things-factory/biz-base'
+import { Product, ProductDetail } from '@things-factory/product-base'
+import { Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
+
+import { InventoryProductGroupList, NewOrderInventory, NewOrderProduct, OrderInventory, OrderProduct } from '../'
+import { InventoryUtil } from '../../utils'
+
+@Resolver()
+export class OtherQuery {
+  @Directive('@privilege(category: "inventory", privilege: "query")')
+  @Query(returns => InventoryProductGroupList)
+  async inventoryProductGroup(
+    @Ctx() context: any,
+    @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[],
+    @Arg('pagination', type => Pagination, { nullable: true }) pagination?: Pagination,
+    @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[],
+    @Arg('locationSortingRules', type => [Sorting], { nullable: true }) locationSortingRules?: Sorting[]
+  ): Promise<InventoryProductGroupList> {
+    const {
+      domain,
+      user,
+      tx,
+      bizplace
+    }: { domain: Domain; user: User; tx: EntityManager; bizplace: Bizplace } = context.state
+
+    let permittedBizplaces: Bizplace[] = await getPermittedBizplaces(domain, user)
+
+    let bizplaceId: any = filters.find(filter => filter.name === 'bizplace_id').value
+    let foundPermittedBizplace: Bizplace
+    let companyBizplace: Bizplace
+
+    if (bizplaceId) {
+      foundPermittedBizplace = permittedBizplaces.find(biz => biz.id == bizplaceId)
+
+      if (foundPermittedBizplace) {
+        if (!foundPermittedBizplace.company?.id) {
+          foundPermittedBizplace = await tx.getRepository(Bizplace).findOne(foundPermittedBizplace.id, {
+            relations: ['company', 'company.domain']
+          })
+        }
+        const companyDomain: Domain = foundPermittedBizplace.company.domain
+        companyBizplace = await tx.getRepository(Bizplace).findOne({ where: { domain: companyDomain } })
+      }
+    }
+
+    const bizplaces: Bizplace[] = [foundPermittedBizplace, companyBizplace]
+    if (bizplace) bizplaces.push(bizplace)
+
+    const { items, total } = await InventoryUtil.bizplaceInventoryProductGroup(
+      bizplaces,
+      { filters, pagination, sortings },
+      context,
+      tx
+    )
+
+    return { items, total }
+  }
+
+  @Directive('@privilege(category: "order_customer", privilege: "query")')
+  @Query(returns => OrderInventory)
+  async bulkUploadValidateWarehousePartnersProductsQuantity(
+    @Ctx() context: any,
+    @Arg('partnerBizplaceId') partnerBizplaceId: string,
+    @Arg('orderInventories', type => [NewOrderInventory], { nullable: true }) orderInventories?: NewOrderInventory[]
+  ): Promise<OrderInventory[]> {
+    const {
+      domain,
+      user,
+      tx,
+      bizplace
+    }: { domain: Domain; user: User; tx: EntityManager; bizplace: Bizplace } = context.state
+
+    let permittedBizplaces: Bizplace[] = await getPermittedBizplaces(domain, user)
+    let foundPermittedBizplace: Bizplace
+    let companyBizplace: Bizplace
+
+    const partnerBizplace: Bizplace = await tx.getRepository(Bizplace).findOne({
+      where: {
+        id: partnerBizplaceId
+      },
+      relations: ['company', 'company.domain']
+    })
+
+    if (partnerBizplaceId) {
+      foundPermittedBizplace = permittedBizplaces.find(biz => biz.id == partnerBizplaceId)
+
+      if (foundPermittedBizplace) {
+        if (!foundPermittedBizplace.company?.id) {
+          foundPermittedBizplace = await tx.getRepository(Bizplace).findOne(foundPermittedBizplace.id, {
+            relations: ['company', 'company.domain']
+          })
+        }
+        const companyDomain: Domain = foundPermittedBizplace.company.domain
+        companyBizplace = await tx.getRepository(Bizplace).findOne({ where: { domain: companyDomain } })
+      }
+    }
+
+    const bizplaces: Bizplace[] = [foundPermittedBizplace, companyBizplace]
+    if (bizplace) bizplaces.push(bizplace)
+
+    let newOrderInventories: any[] = []
+
+    for (var i = 0; i < orderInventories.length; i++) {
+      const orderInventory: any = orderInventories[i]
+
+      let filters: any[] = [
+        {
+          name: 'productName',
+          operator: 'eq',
+          value: orderInventory.productSKU
+        }
+      ]
+
+      if (orderInventory?.packingType != null) {
+        filters.push({
+          name: 'packingType',
+          operator: 'eq',
+          value: orderInventory.packingType
+        })
+      }
+
+      const params: any = {
+        filters: [...filters]
+      }
+
+      const { items, total } = await InventoryUtil.bizplaceInventoryProductGroup(bizplaces, params, context, tx)
+
+      let packageUomValue = total > 0 ? items[0].remainUomValue / items[0].remainQty : null
+
+      const newOrderInventory: any = {
+        product:
+          total > 0 ? { id: items[0].productId, sku: items[0].productSKU, name: items[0].productName } : { id: null },
+        inventory:
+          total > 0
+            ? {
+                ...items[0],
+                remainQty: total > 0 ? items[0].remainQty : null,
+                remainUomValue: total > 0 ? items[0].remainUomValue : null,
+                remainUomValueWithUom: total > 0 ? items[0].remainUomValueWithUom : ''
+              }
+            : null,
+        productId: total > 0 ? items[0].productId : null,
+        productSKU: total > 0 ? items[0].productSKU : orderInventory.productSKU,
+        productName: total > 0 ? items[0].productName : null,
+        remainQty: total > 0 ? items[0].remainQty : null,
+        remainUomValue: total > 0 ? items[0].remainUomValue : null,
+        remainUomValueWithUom: total > 0 ? items[0].remainUomValueWithUom : '',
+        batchId: total > 0 ? items[0].batchId : null,
+        batchIdRef: total > 0 ? items[0].batchIdRef : null,
+        packingType: total > 0 ? items[0].packingType : orderInventory.packingType,
+        packingSize: total > 0 ? items[0].packingSize : 1,
+        releaseQty: orderInventory.releaseQty
+          ? Number.isInteger(orderInventory.releaseQty)
+            ? orderInventory.releaseQty
+            : null
+          : null,
+        releaseUomValue:
+          total > 0
+            ? Number.isInteger(orderInventory.releaseQty)
+              ? parseFloat((orderInventory.releaseQty * packageUomValue).toFixed(2))
+              : null
+            : null,
+        groupType: total > 0 ? items[0].groupType : null,
+        isError: total <= 0 ? true : false
+      }
+
+      newOrderInventories.push(newOrderInventory)
+    }
+
+    try {
+      await InventoryUtil.validateWarehousePartnersProductsQuantity(
+        domain,
+        partnerBizplace,
+        newOrderInventories,
+        context,
+        tx
+      )
+    } catch (e) {
+      const errorData = JSON.parse(e.detail.data)
+
+      errorData.forEach(dt => {
+        let idx = newOrderInventories.findIndex(
+          x =>
+            x.product?.id && x.product.id == dt.productId && x.batchId == dt.batchId && x.packingType == dt.packingType
+        )
+
+        if (idx >= 0) {
+          newOrderInventories[idx].remainQty = dt.availableQty
+          newOrderInventories[idx].remainUomValue = dt.availableUomValue
+          newOrderInventories[idx].isError =
+            dt.availableQty == null
+              ? newOrderInventories[idx].releaseQty > 0
+              : newOrderInventories[idx].releaseQty > dt.availableQty
+          newOrderInventories[idx].remainUomValueWithUom =
+            dt.availableUomValue == null ? '' : `${dt.availableUomValue} ${dt.uom}`
+          if (newOrderInventories[idx].inventory != null) {
+            newOrderInventories[idx].inventory.remainQty = dt.availableQty
+            newOrderInventories[idx].inventory.remainUomValue = dt.availableUomValue
+            newOrderInventories[idx].inventory.remainUomValueWithUom = `${dt.availableUomValue} ${dt.uom}` || ''
+          }
+        }
+      })
+    }
+
+    return orderBy(newOrderInventories, ['isError'], ['desc'])
+  }
+
+  @Directive('@privilege(category: "order_customer", privilege: "query")')
+  @Query(returns => InventoryProductGroupList)
+  async bulkUploadValidateOrderProducts(
+    @Ctx() context: any,
+    @Arg('partnerBizplaceId') partnerBizplaceId: string,
+    @Arg('orderProducts', type => [NewOrderProduct], { nullable: true }) orderProducts: NewOrderProduct[]
+  ): Promise<OrderProduct[]> {
+    const {
+      domain,
+      user,
+      tx,
+      bizplace
+    }: { domain: Domain; user: User; tx: EntityManager; bizplace: Bizplace } = context.state
+
+    const productDetailRepo = tx.getRepository(ProductDetail)
+
+    let permittedBizplaces: Bizplace[] = await getPermittedBizplaces(domain, user)
+    let foundPermittedBizplace: Bizplace
+    let companyBizplace: Bizplace
+
+    if (partnerBizplaceId) {
+      foundPermittedBizplace = permittedBizplaces.find(biz => biz.id == partnerBizplaceId)
+
+      if (foundPermittedBizplace) {
+        if (!foundPermittedBizplace.company?.id) {
+          foundPermittedBizplace = await tx.getRepository(Bizplace).findOne(foundPermittedBizplace.id, {
+            relations: ['company', 'company.domain']
+          })
+        }
+        const companyDomain: Domain = foundPermittedBizplace.company.domain
+        companyBizplace = await tx.getRepository(Bizplace).findOne({ where: { domain: companyDomain } })
+      }
+    }
+
+    const bizplaces: Bizplace[] = [foundPermittedBizplace, companyBizplace]
+    if (bizplace) bizplaces.push(bizplace)
+
+    let newOrderProducts: any[] = []
+
+    for (var i = 0; i < orderProducts.length; i++) {
+      const orderProduct = orderProducts[i]
+      const productSKU: string = orderProduct.productSKU
+      const foundProduct: Product = await tx.getRepository(Product).findOne({
+        where: {
+          sku: productSKU,
+          bizplace: companyBizplace
+        }
+      })
+
+      let newOrderProduct: any
+
+      if (foundProduct) {
+        let productDetail: ProductDetail
+
+        if (orderProduct?.packingType && orderProduct.packingType.trim() != '') {
+          productDetail = await productDetailRepo.findOne({
+            where: {
+              product: foundProduct,
+              packingType: orderProduct.packingType.trim()
+            }
+          })
+        } else {
+          productDetail = await productDetailRepo.findOne({
+            where: {
+              product: foundProduct,
+              isDefault: true
+            }
+          })
+        }
+
+        newOrderProduct = {
+          ...orderProduct,
+          packingType: orderProduct?.packingType ? orderProduct.packingType : productDetail.packingType,
+          packingSize: productDetail?.packingSize ? productDetail.packingSize : null,
+          uom: productDetail?.uom ? productDetail.uom : null,
+          uomValue: productDetail?.uomValue ? productDetail.uomValue : null,
+          productName: `${foundProduct.name}(${foundProduct.description}(${foundProduct.sku}))`,
+          isError: productDetail ? false : true,
+          product: {
+            id: foundProduct.id,
+            name: foundProduct.name,
+            sku: foundProduct.sku,
+            type: foundProduct.type,
+            primaryUnit: productDetail?.uom ? productDetail.uom : null,
+            primaryValue: productDetail?.uomValue ? productDetail.uomValue : null
+          },
+          totalUomValue:
+            orderProduct.packQty > 0
+              ? productDetail?.uomValue
+                ? `${(orderProduct.packQty * productDetail.uomValue).toFixed(2)} ${productDetail.uom}`
+                : null
+              : null
+        }
+      } else {
+        newOrderProduct = {
+          ...orderProduct,
+          productName: orderProduct.productSKU,
+          isError: true
+        }
+      }
+
+      newOrderProducts.push(newOrderProduct)
+    }
+
+    return newOrderProducts
+  }
+}

package/server/service/others/other-types.ts

@@ -0,0 +1,52 @@
+import { Field, Float, Int, ObjectType } from 'type-graphql'
+
+@ObjectType()
+export class InventoryProductGroupList {
+  @Field(type => InventoryProductGroup, { nullable: true })
+  items: InventoryProductGroup[]
+
+  @Field(type => Int, { nullable: true })
+  total: number
+}
+
+@ObjectType()
+export class InventoryProductGroup {
+  @Field({ nullable: true })
+  productId: string
+
+  @Field({ nullable: true })
+  batchId: string
+
+  @Field({ nullable: true })
+  batchIdRef: string
+
+  @Field({ nullable: true })
+  productSKU: string
+
+  @Field({ nullable: true })
+  productName: string
+
+  @Field({ nullable: true })
+  packingType: string
+
+  @Field(type => Float, { nullable: true })
+  packingSize: number
+
+  @Field(type => Float, { nullable: true })
+  remainQty: number
+
+  @Field(type => Float, { nullable: true })
+  remainWeight: number
+
+  @Field(type => Float, { nullable: true })
+  remainUomValue: number
+
+  @Field({ nullable: true })
+  remainUomValueWithUom: string
+
+  @Field({ nullable: true })
+  uom: string
+
+  @Field({ nullable: true })
+  groupType: string
+}

package/server/service/purchase-order/index.ts

@@ -0,0 +1,6 @@
+import { PurchaseOrder } from './purchase-order'
+import { PurchaseOrderMutation } from './purchase-order-mutation'
+import { PurchaseOrderQuery } from './purchase-order-query'
+
+export const entities = [PurchaseOrder]
+export const resolvers = [PurchaseOrderQuery, PurchaseOrderMutation]