@things-factory/sales-base 4.0.11 → 4.0.16

package/server/service/manifest/manifest-query.ts

@@ -0,0 +1,99 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { convertListParams, Domain, ListParam } from '@things-factory/shell'
+
+import { ReleaseGood } from '../release-good/release-good'
+import { Manifest } from './manifest'
+import { ManifestList } from './manifest-type'
+
+@Resolver(Manifest)
+export class ManifestQuery {
+  @Query(returns => Manifest, { description: 'To fetch a Manifest' })
+  async manifest(@Arg('name') name: string, @Ctx() context: any): Promise<Manifest> {
+    const { domain, tx } = context.state
+    const manifest: Manifest = await tx.getRepository(Manifest).findOne({ where: { domain, name } })
+
+    const releaseGoods: ReleaseGood[] = await tx.getRepository(ReleaseGood).find({ where: { manifest } })
+
+    const trackingNos: any[] = releaseGoods.map(releaseGood => {
+      return {
+        trackingNo: releaseGood.trackingNo,
+        refNo: releaseGood.refNo,
+        deliveryAddress: releaseGood.deliveryAddress1,
+        attentionTo: releaseGood.attentionTo,
+        postalCode: releaseGood.postalCode,
+        city: releaseGood.city,
+        phone: releaseGood.phone1,
+        dispatchmentStatus: releaseGood.dispatchmentStatus
+      }
+    })
+
+    return {
+      ...manifest,
+      trackingNos
+    }
+  }
+
+  @Query(returns => ManifestList, { description: 'To fetch multiple Manifests' })
+  async manifests(@Args() params: ListParam, @Ctx() context: any): Promise<ManifestList> {
+    const { domain } = context.state
+
+    const fromDateParamIdx = params.filters.findIndex(param => param.name === 'fromDate')
+    if (fromDateParamIdx >= 0) {
+      let fromDateVal = new Date(params.filters[fromDateParamIdx].value)
+      params.filters.splice(fromDateParamIdx, 1)
+
+      params.filters.push({
+        name: 'createdAt',
+        operator: 'gte',
+        value: fromDateVal.toISOString(),
+        relation: false
+      })
+    }
+
+    const toDateParamIdx = params.filters.findIndex(param => param.name === 'toDate')
+    if (toDateParamIdx >= 0) {
+      let toDateVal = new Date(params.filters[toDateParamIdx].value)
+      params.filters.splice(toDateParamIdx, 1)
+
+      params.filters.push({
+        name: 'createdAt',
+        operator: 'lt',
+        value: new Date(toDateVal.setDate(toDateVal.getDate() + 1)).toISOString(),
+        relation: false
+      })
+    }
+
+    params.filters.push({
+      name: 'domain',
+      operator: 'eq',
+      value: domain.id,
+      relation: true
+    })
+
+    const convertedParams = convertListParams(params)
+    const [items, total] = await getRepository(Manifest).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'creator', 'updater']
+    })
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() manifest: Manifest): Promise<Domain> {
+    return await getRepository(Domain).findOne(manifest.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() manifest: Manifest): Promise<User> {
+    return await getRepository(User).findOne(manifest.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() manifest: Manifest): Promise<User> {
+    return await getRepository(User).findOne(manifest.creatorId)
+  }
+}

package/server/service/manifest/manifest-type.ts

@@ -0,0 +1,78 @@
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+
+import { Manifest, ManifestStatus } from './manifest'
+
+@InputType()
+export class NewManifest {
+  @Field(type => [ManifestItem])
+  manifestItems: ManifestItem[]
+}
+
+@InputType()
+export class ManifestPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  shippingProvider?: string
+
+  @Field({ nullable: true })
+  dispatcherName?: string
+
+  @Field({ nullable: true })
+  dispatcherIdentity?: string
+
+  @Field(type => ManifestStatus, { nullable: true })
+  status?: ManifestStatus
+}
+
+@InputType()
+export class ManifestItem {
+  @Field({ nullable: true })
+  trackingNo?: string
+
+  @Field({ nullable: true })
+  refNo?: string
+
+  @Field({ nullable: true })
+  transporter?: string
+}
+
+@ObjectType()
+export class ManifestList {
+  @Field(type => [Manifest])
+  items: Manifest[]
+
+  @Field(type => Int)
+  total: number
+}
+
+@ObjectType()
+export class TrackingNo {
+  @Field({ nullable: true })
+  trackingNo?: string
+
+  @Field({ nullable: true })
+  refNo?: string
+
+  @Field({ nullable: true })
+  dispatchmentStatus?: string
+
+  @Field({ nullable: true })
+  deliveryAddress?: string
+
+  @Field({ nullable: true })
+  attentionTo?: string
+
+  @Field({ nullable: true })
+  postalCode?: string
+
+  @Field({ nullable: true })
+  phone?: string
+
+  @Field({ nullable: true })
+  city?: string
+}

package/server/service/manifest/manifest.ts

@@ -0,0 +1,103 @@
+import { Field, ID, ObjectType, registerEnumType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { config } from '@things-factory/env'
+import { Domain } from '@things-factory/shell'
+
+import { TrackingNo } from './manifest-type'
+
+const ORMCONFIG = config.get('ormconfig', {})
+const DATABASE_TYPE = ORMCONFIG.type
+
+export enum ManifestStatus {
+  OPEN = 'OPEN',
+  CLOSED = 'CLOSED'
+}
+
+registerEnumType(ManifestStatus, {
+  name: 'ManifestStatus',
+  description: 'state enumeration of a manifest'
+})
+
+@Entity()
+@Index('ix_manifest_0', (manifest: Manifest) => [manifest.domain, manifest.name], { unique: true })
+@ObjectType({ description: 'Entity for Manifest' })
+export class Manifest {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((manifest: Manifest) => manifest.domain)
+  domainId?: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  shippingProvider: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  dispatcherName: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  dispatcherIdentity: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  dispatchedAt: Date
+
+  @Column({
+    type:
+      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
+        ? 'enum'
+        : DATABASE_TYPE == 'oracle'
+        ? 'varchar2'
+        : 'smallint',
+    enum: ManifestStatus,
+    default: ManifestStatus.OPEN
+  })
+  status: ManifestStatus
+
+  @Field(type => [TrackingNo], { nullable: true })
+  trackingNos?: TrackingNo[]
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((manifest: Manifest) => manifest.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((manifest: Manifest) => manifest.creator)
+  updaterId?: string
+}

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

@@ -1,6 +1,9 @@
-import { Domain } from '@things-factory/shell'
+import { OrderInventoryPatch } from './order-inventory-types'
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
 import { EntityManager, In } from 'typeorm'
+
+import { Domain } from '@things-factory/shell'
+
 import { OrderInventory } from './order-inventory'
 
 @Resolver(OrderInventory)
@@ -25,4 +28,26 @@ export class OrderInventoryMutation {
     })
     return true
   }
+
+  @Mutation(returns => OrderInventory)
+  @Directive('@transaction')
+  async updateOrderInventorySerialNumber(
+    @Ctx() context: any,
+    @Arg('orderInventory', type => OrderInventoryPatch, { nullable: true }) orderInventory?: OrderInventoryPatch
+  ): Promise<OrderInventory> {
+    try {
+      const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+
+      let foundOI: OrderInventory = await tx.getRepository(OrderInventory).findOne({
+        where: { domain, id: orderInventory.id }
+      })
+
+      foundOI.serialNumber = orderInventory.serialNumber
+      foundOI = await tx.getRepository(OrderInventory).save(foundOI)
+
+      return foundOI
+    } catch (error) {
+      throw error
+    }
+  }
 }

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

@@ -156,49 +156,47 @@ export class OrderInventoryQuery {
   }
 
   @Query(returns => OrderInventory)
-  async orderInventory(@Arg('name') name: string, @Ctx() context: any): Promise<OrderInventory> {
+  async orderInventory(@Arg('id') id: string, @Ctx() context: any): Promise<OrderInventory> {
     const { domain }: { domain: Domain } = context.state
 
     return await getRepository(OrderInventory).findOne({
-      where: { domain, name },
-      relations: ['domain', 'releaseGood', 'vasOrder', 'shippingOrder', 'inventory', 'creator', 'updater']
+      where: {
+        domain,
+        id
+      },
+      relations: ['domain', 'releaseGood', 'inventory', 'creator', 'updater']
     })
   }
 
   @Query(returns => OrderInventoryList)
-  async inventoriesByOrder(
-    @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[]
-  ): Promise<OrderInventoryList> {
+  async inventoriesByOrder(@Ctx() context: any, @Args() params: ListParam): Promise<OrderInventoryList> {
     const { domain, user }: { domain: Domain; user: User } = context.state
 
     let permittedBizplaceIds: string[] = await getPermittedBizplaceIds(domain, user)
 
-    if (!filters.find((filter: any) => filter.name === 'bizplaceId')) {
-      filters.push({
+    if (!params.filters.find((filter: any) => filter.name === 'bizplaceId')) {
+      params.filters.push({
         name: 'bizplaceId',
         operator: 'in',
         value: permittedBizplaceIds,
         relation: true
       })
     } else {
-      permittedBizplaceIds = filters.find(filter => filter.name === 'bizplaceId').value
-      filters.find(filter => filter.name === 'bizplaceId').relation = true
+      permittedBizplaceIds = params.filters.find(filter => filter.name === 'bizplaceId').value
+      params.filters.find(filter => filter.name === 'bizplaceId').relation = true
     }
 
-    if (filters.find((filter: any) => filter.name === 'releaseGoodName')?.value) {
+    if (params.filters.find((filter: any) => filter.name === 'releaseGoodName')?.value) {
       let releaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
         where: {
-          name: Like(filters.find(filter => filter.name === 'releaseGoodName').value)
+          name: Like(params.filters.find(filter => filter.name === 'releaseGoodName').value)
         }
       })
 
       if (releaseGood) {
-        filters = filters.filter(filter => filter.name != 'releaseGoodName')
+        params.filters = params.filters.filter(filter => filter.name != 'releaseGoodName')
 
-        filters.push({
+        params.filters.push({
           name: 'releaseGoodId',
           operator: 'eq',
           value: releaseGood.id,
@@ -207,7 +205,7 @@ export class OrderInventoryQuery {
       }
     }
     const qb: SelectQueryBuilder<OrderInventory> = getRepository(OrderInventory).createQueryBuilder('oi')
-    buildQuery(qb, { filters, pagination, sortings }, context)
+    buildQuery(qb, params, context)
 
     qb.innerJoinAndSelect('oi.releaseGood', 'releaseGood')
       .leftJoinAndSelect('oi.domain', 'domain')
@@ -229,6 +227,7 @@ export class OrderInventoryQuery {
         productId: item.inventory.product.id,
         productName: item.inventory.product.name,
         productSKU: item.inventory.product.sku,
+        productBrand: item.inventory.product.brand,
         packingSize: item.inventory.packingSize
       }
     })

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

@@ -1,7 +1,9 @@
+import { Field, Float, InputType, Int, ObjectType } from 'type-graphql'
+
 import { NewProduct } from '@things-factory/product-base'
 import { ObjectRef } from '@things-factory/shell'
 import { InventoryPatch } from '@things-factory/warehouse-base'
-import { Field, Float, InputType, Int, ObjectType } from 'type-graphql'
+
 import { OrderInventory } from './order-inventory'
 
 @ObjectType()
@@ -162,9 +164,21 @@ export class OrderInventoryPatch {
   @Field(type => Float, { nullable: true })
   packingSize: number
 
+  @Field({ nullable: true })
+  productName: string
+
+  @Field({ nullable: true })
+  pallet: string
+
+  @Field({ nullable: true })
+  extraJsonData: string
+
   @Field(type => Float, { nullable: true })
   releaseQty: number
 
+  @Field({ nullable: true })
+  serialNumber: string
+
   @Field(type => Float, { nullable: true })
   sortedQty: number
 
@@ -177,9 +191,6 @@ export class OrderInventoryPatch {
   @Field({ nullable: true })
   productId: string
 
-  @Field({ nullable: true })
-  productName: string
-
   @Field(type => Float, { nullable: true })
   releaseUomValue: number
 
@@ -203,10 +214,4 @@ export class OrderInventoryPatch {
 
   @Field({ nullable: true })
   status: string
-
-  @Field({ nullable: true })
-  pallet: string
-
-  @Field({ nullable: true })
-  extraJsonData: string
 }

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

@@ -1,8 +1,3 @@
-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, Location } from '@things-factory/warehouse-base'
 import { Field, ID, ObjectType } from 'type-graphql'
 import {
   Column,
@@ -14,6 +9,13 @@ import {
   RelationId,
   UpdateDateColumn
 } from 'typeorm'
+
+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, Location } from '@things-factory/warehouse-base'
+
 import {
   ArrivalNotice,
   DeliveryOrder,
@@ -240,6 +242,19 @@ export class OrderInventory {
   @Field({ nullable: true })
   releaseUomValue: number
 
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  uom: string
+
+  @Field({ nullable: true })
+  productName: string
+
+  @Field({ nullable: true })
+  pallet: string
+
+  @Field({ nullable: true })
+  extraJsonData: string
+
   @Column({ nullable: true, type: 'float' })
   @Field({ nullable: true })
   returnQty: number
@@ -264,6 +279,10 @@ export class OrderInventory {
   @Field({ nullable: true })
   crossDocking: boolean
 
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  serialNumber: string
+
   @Column()
   @Field()
   status: string

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

@@ -69,12 +69,7 @@ export class OtherQuery {
     @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
+    const { domain, user, tx, bizplace } = context.state
 
     let permittedBizplaces: Bizplace[] = await getPermittedBizplaces(domain, user)
     let foundPermittedBizplace: Bizplace
@@ -148,6 +143,7 @@ export class OtherQuery {
         productId: total > 0 ? items[0].productId : null,
         productSKU: total > 0 ? items[0].productSKU : orderInventory.productSKU,
         productName: total > 0 ? items[0].productName : null,
+        uom: total > 0 ? items[0].uom : null,
         remainQty: total > 0 ? items[0].remainQty : null,
         remainUomValue: total > 0 ? items[0].remainUomValue : null,
         remainUomValueWithUom: total > 0 ? items[0].remainUomValueWithUom : '',

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

@@ -26,6 +26,9 @@ export class InventoryProductGroup {
   @Field({ nullable: true })
   productName: string
 
+  @Field({ nullable: true })
+  productBrand: string
+
   @Field({ nullable: true })
   packingType: string