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

package/server/service/pallet-history/pallet-history-query.ts

@@ -0,0 +1,46 @@
+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 { PalletHistory } from './pallet-history'
+import { PalletHistoryList } from './pallet-history-types'
+
+@Resolver(PalletHistory)
+export class PalletHistoryQuery {
+  @Query(returns => PalletHistoryList)
+  async palletHistories(@Args() params: ListParam, @Ctx() context: any): Promise<PalletHistoryList> {
+    const convertedParams = convertListParams(params)
+    const [items, total] = await getRepository(PalletHistory).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'creator', 'updater']
+    })
+    return { items, total }
+  }
+
+  @Query(returns => PalletHistory)
+  async palletHistory(@Arg('name') name: string, @Ctx() context: any): Promise<PalletHistory> {
+    const { domain }: { domain: Domain } = context.state
+
+    return await getRepository(PalletHistory).findOne({
+      where: { domain: domain, name },
+      relations: ['domain', 'creator', 'updater']
+    })
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() palletHistory: PalletHistory) {
+    return await getRepository(Domain).findOne(palletHistory.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() palletHistory: PalletHistory) {
+    return await getRepository(User).findOne(palletHistory.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() palletHistory: PalletHistory) {
+    return await getRepository(User).findOne(palletHistory.creatorId)
+  }
+}

package/server/service/pallet-history/pallet-history-types.ts

@@ -0,0 +1,36 @@
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+
+import { PalletHistory } from './pallet-history'
+
+@InputType()
+export class NewPalletHistory {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+}
+
+@ObjectType()
+export class PalletHistoryList {
+  @Field(type => [PalletHistory], { nullable: true })
+  items?: PalletHistory[]
+
+  @Field(type => Int, { nullable: true })
+  total?: number
+}
+
+@InputType()
+export class PalletHistoryPatch {
+  @Field({ nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}

package/server/{entities → service/pallet-history}/pallet-history.ts

@@ -1,63 +1,85 @@
+import { Field, ID, ObjectType } from 'type-graphql'
 import {
+  Column,
   CreateDateColumn,
-  UpdateDateColumn,
   Entity,
   Index,
-  Column,
-  OneToMany,
   ManyToOne,
-  PrimaryGeneratedColumn
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
 } from 'typeorm'
-import { Domain } from '@things-factory/shell'
+
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
-import { Pallet } from '.'
+import { Domain } from '@things-factory/shell'
+
+import { Pallet } from '../pallet/pallet'
 
 @Entity()
 @Index('ix_pallet-history_0', (palletHistory: PalletHistory) => [palletHistory.domain, palletHistory.id], {
   unique: true
 })
+@ObjectType()
 export class PalletHistory {
   @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
   id: string
 
   @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true })
   domain: Domain
 
+  @RelationId((palletHistory: PalletHistory) => palletHistory.domain)
+  domainId: string
+
   @Column()
+  @Field()
   name: string
 
   @Column({ default: 0 })
+  @Field()
   seq: number
 
   @ManyToOne(type => Bizplace)
+  @Field()
   owner: Bizplace
 
   @ManyToOne(type => Bizplace)
+  @Field()
   holder: Bizplace
 
   @ManyToOne(type => Pallet)
+  @Field()
   pallet: Pallet
 
   @Column()
+  @Field()
   status: string
 
   @Column()
+  @Field()
   transactionType: string
 
   @CreateDateColumn()
+  @Field({ nullable: true })
   createdAt: Date
 
   @UpdateDateColumn()
+  @Field({ nullable: true })
   updatedAt: Date
 
-  @ManyToOne(type => User, {
-    nullable: true
-  })
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
   creator: User
 
-  @ManyToOne(type => User, {
-    nullable: true
-  })
+  @RelationId((palletHistory: PalletHistory) => palletHistory.creator)
+  creatorId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
   updater: User
+
+  @RelationId((palletHistory: PalletHistory) => palletHistory.updater)
+  updaterId: string
 }

package/server/service/reduced-inventory-history/index.ts

@@ -0,0 +1,3 @@
+import { ReducedInventoryHistory } from './reduced-inventory-history'
+
+export const entities = [ReducedInventoryHistory]

package/server/{entities → service/reduced-inventory-history}/reduced-inventory-history.ts

@@ -1,6 +1,4 @@
-import { ViewEntity, ViewColumn, Index } from 'typeorm'
-import { Bizplace } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
+import { ViewColumn, ViewEntity } from 'typeorm'
 
 @ViewEntity({
   expression: `
@@ -24,10 +22,13 @@ export class ReducedInventoryHistory {
   seq: number
 
   @ViewColumn()
-  domain: Domain
+  domainId: string
 
   @ViewColumn()
-  bizplace: Bizplace
+  bizplaceId: string
+
+  @ViewColumn()
+  inventoryId: string
 
   @ViewColumn()
   refOrderId: string
@@ -83,15 +84,9 @@ export class ReducedInventoryHistory {
   @ViewColumn()
   openingQty: number
 
-  @ViewColumn()
-  weight: number
-
-  @ViewColumn()
-  openingWeight: number
-
   @ViewColumn()
   status: string
 
   @ViewColumn()
-  transactionType: String
+  transactionType: string
 }

package/server/service/warehouse/index.ts

@@ -0,0 +1,6 @@
+import { Warehouse } from './warehouse'
+import { WarehouseMutation } from './warehouse-mutation'
+import { WarehouseQuery } from './warehouse-query'
+
+export const entities = [Warehouse]
+export const resolvers = [WarehouseQuery, WarehouseMutation]

package/server/service/warehouse/warehouse-mutation.ts

@@ -0,0 +1,114 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, Repository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { Warehouse } from './warehouse'
+import { NewWarehouse, WarehousePatch } from './warehouse-types'
+
+@Resolver(Warehouse)
+export class WarehouseMutation {
+  @Directive('@privilege(category: "warehouse", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Warehouse)
+  async createWarehouse(@Arg('warehouse') warehouse: NewWarehouse, @Ctx() context: any): Promise<Warehouse> {
+    return await createWarehouse(warehouse, context)
+  }
+
+  @Directive('@privilege(category: "warehouse", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Warehouse)
+  async updateWarehouse(
+    @Arg('id') id: string,
+    @Arg('patch') patch: WarehousePatch,
+    @Ctx() context: any
+  ): Promise<Warehouse> {
+    return await updateWarehouse(id, patch, context)
+  }
+
+  @Directive('@privilege(category: "warehouse", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => [Warehouse])
+  async updateMultipleWarehouse(
+    @Arg('patches', type => [WarehousePatch]) patches: WarehousePatch[],
+    @Ctx() context: any
+  ): Promise<Warehouse[]> {
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const patch = _createRecords[i]
+        const result = await createWarehouse(patch as NewWarehouse, context)
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const patch: WarehousePatch = _updateRecords[i]
+        const result = await updateWarehouse(patch.id, patch, context)
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@privilege(category: "warehouse", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteWarehouse(@Arg('id') id: string, @Ctx() context: any): Promise<Boolean> {
+    return await deleteWarehouse(id, context)
+  }
+
+  @Directive('@privilege(category: "warehouse", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteWarehouses(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<Boolean> {
+    return await deleteWarehouses(ids, context)
+  }
+}
+
+export async function createWarehouse(warehouse: NewWarehouse, context: any) {
+  const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+  const repository: Repository<Warehouse> = tx.getRepository(Warehouse)
+  return await repository.save({
+    ...warehouse,
+    domain,
+    creator: user,
+    updater: user
+  })
+}
+
+export async function updateWarehouse(id: string, patch: WarehousePatch, context: any) {
+  const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+  const repository: Repository<Warehouse> = tx.getRepository(Warehouse)
+  const warehouse = await repository.findOne(id)
+
+  return await repository.save({
+    ...warehouse,
+    ...patch,
+    updater: user
+  })
+}
+
+export async function deleteWarehouse(id: string, context) {
+  const { tx }: { tx: EntityManager } = context.state
+
+  const repository: Repository<Warehouse> = tx.getRepository(Warehouse)
+  await repository.delete(id)
+  return true
+}
+
+export async function deleteWarehouses(ids: string[], context: any) {
+  const { tx }: { tx: EntityManager } = context.state
+
+  const repository: Repository<Warehouse> = tx.getRepository(Warehouse)
+  await repository.delete(ids)
+  return true
+}

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

@@ -0,0 +1,51 @@
+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 { Warehouse } from './warehouse'
+import { WarehouseList } from './warehouse-types'
+
+@Resolver(Warehouse)
+export class WarehouseQuery {
+  @Query(returns => Warehouse)
+  async warehouse(@Arg('id') id: string, @Ctx() context: any): Promise<Warehouse> {
+    const { domain }: { domain: Domain } = context.state
+
+    return await getRepository(Warehouse).findOne({
+      where: {
+        domain: domain,
+        name
+      },
+      relations: ['domain', 'locations', 'creator', 'updater']
+    })
+  }
+
+  @Query(returns => WarehouseList)
+  async warehouses(@Args() params: ListParam, @Ctx() context: any): Promise<WarehouseList> {
+    const { domain }: { domain: Domain } = context.state
+
+    const convertedParams = convertListParams(params, domain.id)
+    const [items, total] = await getRepository(Warehouse).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'creator', 'updater']
+    })
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() warehouse: Warehouse) {
+    return await getRepository(Domain).findOne(warehouse.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() warehouse: Warehouse) {
+    return await getRepository(User).findOne(warehouse.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() warehouse: Warehouse) {
+    return await getRepository(User).findOne(warehouse.creatorId)
+  }
+}

package/server/service/warehouse/warehouse-types.ts

@@ -0,0 +1,50 @@
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef } from '@things-factory/shell'
+
+import { Warehouse } from './warehouse'
+
+@InputType()
+export class NewWarehouse {
+  @Field({ nullable: true })
+  id?: string
+
+  @Field()
+  name: string
+
+  @Field(type => [ObjectRef], { nullable: true })
+  locations?: ObjectRef[]
+
+  @Field({ nullable: true })
+  description?: string
+}
+
+@ObjectType()
+export class WarehouseList {
+  @Field(type => [Warehouse], { nullable: true })
+  items?: Warehouse[]
+
+  @Field(type => Int, { nullable: true })
+  total?: number
+}
+
+@InputType()
+export class WarehousePatch {
+  @Field({ nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  type?: string
+
+  @Field(type => [ObjectRef], { nullable: true })
+  locations?: ObjectRef[]
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}

package/server/{entities → service/warehouse}/warehouse.ts

@@ -1,6 +1,4 @@
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
+import { Field, ID, ObjectType } from 'type-graphql'
 import {
   Column,
   CreateDateColumn,
@@ -9,50 +7,77 @@ import {
   ManyToOne,
   OneToMany,
   PrimaryGeneratedColumn,
+  RelationId,
   UpdateDateColumn
 } from 'typeorm'
-import { Location } from './location'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+
+import { Location } from '../location/location'
 
 @Entity()
 @Index('ix_warehouse_0', (warehouse: Warehouse) => [warehouse.domain, warehouse.name], { unique: true })
 @Index('ix_warehouse_1', (warehouse: Warehouse) => [warehouse.domain, warehouse.id], { unique: true })
+@ObjectType()
 export class Warehouse {
   @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
   id: string
 
   @ManyToOne(type => Domain)
+  @Field()
   domain: Domain
 
+  @RelationId((warehouse: Warehouse) => warehouse.domain)
+  domainId: string
+
   @ManyToOne(type => Bizplace)
+  @Field()
   bizplace: Bizplace
 
   @Column()
+  @Field()
   name: string
 
   @OneToMany(type => Location, location => location.warehouse)
+  @Field(type => [Location])
   locations: Location[]
 
   @Column()
+  @Field()
   type: string
 
   @Column({
     nullable: true
   })
+  @Field({ nullable: true })
   description: string
 
   @ManyToOne(type => User, {
     nullable: true
   })
+  @Field({ nullable: true })
   creator: User
 
+  @RelationId((warehouse: Warehouse) => warehouse.creator)
+  creatorId: string
+
   @ManyToOne(type => User, {
     nullable: true
   })
+  @Field({ nullable: true })
   updater: User
 
+  @RelationId((warehouse: Warehouse) => warehouse.updater)
+  updaterId: string
+
   @CreateDateColumn()
+  @Field({ nullable: true })
   createdAt: Date
 
   @UpdateDateColumn()
+  @Field({ nullable: true })
   updatedAt: Date
 }

package/server/utils/inventory-util.ts

@@ -1,11 +1,13 @@
+import { EntityManager, getRepository, Repository } 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_STATUS, LOCATION_STATUS } from '../constants'
-import { Location, Inventory, InventoryHistory } from '../entities'
+import { Inventory, InventoryHistory, Location } from '../service'
 import { InventoryNoGenerator } from '../utils'
-import { EntityManager, getRepository, Repository } from 'typeorm'
 
 /**
  * @description It will insert new record into inventory histories table.
@@ -79,8 +81,6 @@ export async function generateInventoryHistory(
   inventoryHistory.uom = inventory.uom
   inventoryHistory.qty = qty
   inventoryHistory.openingQty = openingQty
-  inventoryHistory.weight = 0
-  inventoryHistory.openingWeight = 0
   inventoryHistory.uomValue = uomValue
   inventoryHistory.openingUomValue = openingUomValue
   inventoryHistory.unitCost = inventory.unitCost
@@ -200,3 +200,57 @@ export async function checkPalletIdenticallity(
 
   return { identicallity: true }
 }
+
+/**
+ * @description Check whether inventory is same with passed conditions
+ * @param {Domain} domain
+ * @param {Domain} productOwnerDomain
+ * @param {OrderProduct} bizplace *
+ * @param {EntityManager} trxMgr
+ */
+export async function getProductBundleInventory(
+  domain: Domain,
+  productOwnerDomain: Domain,
+  orderProducts: any[],
+  trxMgr: EntityManager
+): Promise<any> {
+  let orderProductsJson = JSON.stringify(
+    orderProducts.map(itm => {
+      return {
+        ...itm,
+        product_id: itm.product.id,
+        packing_type: itm.packingType,
+        packing_size: itm.packingSize,
+        uom: itm.uom
+      }
+    }) || []
+  )
+
+  const result: any[] = await trxMgr.query(
+    `
+      select product_bundle_id, sku, name, min(available_qty) as qty from (
+        select
+        pb.sku, pb.name, pbs.product_bundle_id, pbs.bundle_qty, pd.product_id, pd.packing_type, pd.packing_size, pd.uom,
+        floor(coalesce(sum(inv.qty - coalesce(inv.locked_qty,0)),0)/pbs.bundle_qty) as available_qty, 
+        floor(coalesce(sum(inv.uom_value - coalesce(inv.locked_uom_value,0)),0)/pbs.bundle_qty) as available_uom_value      
+        from (
+          select pb.id, pb.sku, pb.name
+          from json_populate_recordset(NULL::order_products,'${orderProductsJson}') src 
+          inner join product_details pd ON src.product_id = pd.product_id and src.packing_type = pd.packing_type and src.packing_size = pd.packing_size and src.uom = pd.uom
+          inner join product_bundle_settings pbs on pbs.product_detail_id = pd.id
+          inner join product_bundles pb on pb.id = pbs.product_bundle_id
+          where pb.domain_id = $1
+          group by pb.id, pb.sku, pb.name
+        ) pb
+        inner join product_bundle_settings pbs on pbs.product_bundle_id = pb.id
+        inner join product_details pd on pd.id = pbs.product_detail_id 
+        left join inventories inv on inv.status <> 'TERMINATED' and (inv.qty - coalesce(inv.locked_qty,0)) > 0 and inv.product_id = pd.product_id and inv.packing_type = pd.packing_type and inv.packing_size = pd.packing_size and inv.uom = pd.uom
+        where inv.domain_id = $2
+        group by pb.sku, pb.name, pbs.product_bundle_id, pbs.bundle_qty, pd.product_id, pd.packing_type, pd.packing_size, pd.uom
+      ) foo group by product_bundle_id, sku, name
+    `,
+    [productOwnerDomain.id, domain.id]
+  )
+
+  return result
+}

package/server/entities/index.ts

@@ -1,36 +0,0 @@
-import { Inventory } from './inventory'
-import { InventoryChange } from './inventory-change'
-import { InventoryHistory } from './inventory-history'
-import { ReducedInventoryHistory } from './reduced-inventory-history'
-import { Location } from './location'
-import { Movement } from './movement'
-import { Warehouse } from './warehouse'
-import { Pallet } from './pallet'
-import { PalletHistory } from './pallet-history'
-import { PalletCount } from './pallet-count'
-
-export const entities = [
-  Location,
-  Inventory,
-  InventoryChange,
-  InventoryHistory,
-  ReducedInventoryHistory,
-  Warehouse,
-  Movement,
-  Pallet,
-  PalletHistory,
-  PalletCount
-]
-
-export {
-  Location,
-  Inventory,
-  InventoryChange,
-  InventoryHistory,
-  ReducedInventoryHistory,
-  Warehouse,
-  Movement,
-  Pallet,
-  PalletHistory,
-  PalletCount
-}

package/server/entities/pallet-count.ts

@@ -1,40 +0,0 @@
-import { CreateDateColumn, UpdateDateColumn, Entity, Index, Column, OneToMany, ManyToOne, PrimaryGeneratedColumn } from 'typeorm'
-import { Domain } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-
-@Entity()
-@Index('ix_pallet-count_0', (palletCount: PalletCount) => [palletCount.domain, palletCount.name], { unique: true })
-export class PalletCount {
-  @PrimaryGeneratedColumn('uuid')
-  id: string
-
-  @ManyToOne(type => Domain)
-  domain: Domain
-
-  @Column()
-  name: string
-
-  @Column({ default: 0 })
-  seq: number
-
-  @Column({
-    nullable: true
-  })
-  description: string
-
-  @CreateDateColumn()
-  createdAt: Date
-  
-  @UpdateDateColumn()
-  updatedAt: Date
-  
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  creator: User
-  
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  updater: User  
-}