@things-factory/warehouse-base 4.2.12 → 4.3.0

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

@@ -262,7 +262,7 @@ export class InventoryHistoryQuery {
       (
         SELECT prd.name AS product_name, prd.description AS product_description, prd.type as product_type, prd.aux_value_1 AS product_aux_value_1, trim(invh.batch_id) as batch_id, invh.product_id,
         invh.packing_type, invh.bizplace_id, invh.domain_id,
-        invh.ref_order_id, invh.order_no, invh.order_ref_no, invh.transaction_type, invh.created_at,
+        invh.ref_order_id, invh.order_no, invh.order_ref_no, invh.transaction_type, invh.status, invh.created_at,
         invh.qty, invh.opening_qty, 
         invh.uom, COALESCE(invh.uom_value, 0) as uom_value, COALESCE(invh.opening_uom_value, 0) as opening_uom_value
         FROM reduced_inventory_histories invh
@@ -335,6 +335,27 @@ export class InventoryHistoryQuery {
           ) AS inv_movement 
           GROUP BY product_name, product_description, product_type, product_aux_value_1, batch_id, product_id, packing_type, uom, bizplace_id, 
           domain_id, order_name, ref_no, rn, created_at
+          UNION ALL
+          SELECT product_name, product_description, product_type, product_aux_value_1, batch_id, product_id, packing_type, uom, bizplace_id, 
+          domain_id, sum(-opening_qty) as qty, sum(opening_qty) as opening_qty, sum(-opening_uom_value) as uom_value, sum(opening_uom_value) as opening_uom_value,
+          order_name, ref_no, 1 AS rn, created_at - $2::interval as created_at, created_at::date as created_date
+          FROM (
+            SELECT invh.product_name, invh.product_description, invh.product_type, invh.product_aux_value_1, invh.batch_id, invh.product_id, invh.packing_type, invh.uom, invh.bizplace_id, 
+            invh.domain_id,
+            invh.qty, invh.opening_qty,	invh.uom_value, invh.opening_uom_value,
+            invh.transaction_type AS order_name,
+            invh.transaction_type AS ref_no,
+            invh.created_at,
+            invh.created_at:: date as created_date
+            FROM temp_data_src invh
+            WHERE 
+            invh.transaction_type = 'ADJUSTMENT' AND
+            invh.status = 'MISSING'
+            AND invh.created_at >= $1::timestamp
+          ) AS inv_movement 
+          GROUP BY product_name, product_description, product_type, product_aux_value_1, batch_id, product_id, packing_type, uom, bizplace_id, 
+          domain_id, order_name, ref_no, rn, created_at
+          
         )`,
         [fromDate.value, tzoffset]
       )
@@ -1108,7 +1129,7 @@ export class InventoryHistoryQuery {
             group by ih.domain_id, ih.pallet_id
           ) dt
           inner join tmp_src rih on dt.domain_id = rih.domain_id and dt.pallet_id = rih.pallet_id and dt.last_seq = rih.seq and rih.status <> 'TERMINATED'
-          inner join inventories iv on iv.domain_id = dt.domain_id and iv.pallet_id = dt.pallet_id
+          inner join inventories iv on iv.domain_id = dt.domain_id and iv.pallet_id = dt.pallet_id and iv.status <> 'MISSING'
           where exists (
             SELECT * FROM tmp_bizfilter bizFilter
             WHERE bizFilter.bizplace_id = "rih"."bizplace_id"

package/server/service/tote/index.ts

@@ -0,0 +1,6 @@
+import { Tote } from './tote'
+import { ToteMutation } from './tote-mutation'
+import { ToteQuery } from './tote-query'
+
+export const entities = [Tote]
+export const resolvers = [ToteQuery, ToteMutation]

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

@@ -0,0 +1,200 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, In } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+
+import { PalletHistory } from '../pallet-history/pallet-history'
+import { Tote } from './tote'
+import { NewTote, TotePatch } from './tote-types'
+
+@Resolver(Tote)
+export class ToteMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Tote)
+  async createTote(@Arg('pallet') tote: NewTote, @Ctx() context: any): Promise<Tote> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+    const existingTote: string[] = (await tx.getRepository(Tote).find({ relations: ['user'] })).map(tote => tote.name)
+    if (existingTote.includes(tote.name)) throw new Error('tote box already exists')
+
+    return await tx.getRepository(Tote).save({
+      ...tote,
+      domain: domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Tote)
+  async updateTote(@Arg('name') name: string, @Arg('patch') patch: TotePatch, @Ctx() context: any): Promise<Tote> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+    const repository = tx.getRepository(Tote)
+    const tote = await repository.findOne({
+      where: { domain: domain, name }
+    })
+
+    return await repository.save({
+      ...tote,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [Tote])
+  async updateMultipleTote(
+    @Arg('patches', type => [TotePatch]) patches: TotePatch[],
+    @Ctx() context: any
+  ): Promise<Tote[]> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+    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 newRecord = _createRecords[i]
+
+        if (newRecord.bizplace && newRecord.bizplace.id) {
+          newRecord.bizplace = await tx.getRepository(Bizplace).findOne(newRecord.bizplace.id)
+        }
+
+        let foundTote = await tx
+          .getRepository(Tote)
+          .findOne({ where: { domain, name: newRecord.name, bizplace: newRecord.bizplace } })
+
+        if (foundTote) {
+          throw new Error('Duplicated tote found')
+        }
+
+        const result: Tote = await tx.getRepository(Tote).save({
+          domain: domain,
+          creator: user,
+          updater: user,
+          ...newRecord
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const tote = await tx.getRepository(Tote).findOne({
+          where: { id: newRecord.id },
+          relations: ['bizplace']
+        })
+
+        if (newRecord.bizplace && newRecord.bizplace.id) {
+          newRecord.bizplace = await tx.getRepository(Bizplace).findOne(newRecord.bizplace.id)
+        }
+
+        let foundTote = await tx
+          .getRepository(Tote)
+          .findOne({ where: { domain, name: newRecord.name, bizplace: newRecord.bizplace } })
+
+        if (foundTote) {
+          throw new Error('Duplicated tote found')
+        }
+
+        const result = await tx.getRepository(Tote).save({
+          ...tote,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteTote(@Arg('name') id: string, @Ctx() context: any): Promise<Boolean> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+    const foundTote = await tx.getRepository(Tote).find({ where: { id } })
+
+    await tx.getRepository(Tote).save({
+      ...foundTote,
+      deletedAt: new Date(),
+      updater: user
+    })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteTotes(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<Boolean> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+    const totes = await tx.getRepository(Tote).find({
+      where: {
+        domain: domain,
+        id: In(ids)
+      },
+      relations: ['bizplace']
+    })
+
+    await Promise.all(
+      totes.map(async (tote: Tote) => {
+        await tx.getRepository(Tote).save({
+          ...tote,
+          deletedAt: new Date(),
+          updater: user
+        })
+      })
+    )
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async undeleteTotes(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<Boolean> {
+    const { tx, user }: { tx: EntityManager; user: User } = context.state
+    const toteRepo = tx.getRepository(Tote)
+
+    await toteRepo.update(
+      {
+        id: In(ids)
+      },
+      {
+        deletedAt: null,
+        updater: user
+      }
+    )
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async bulkUpdateToteStatus(
+    @Arg('ids', type => [String]) ids: string[],
+    @Arg('status', type => String) status: string,
+    @Ctx() context: any
+  ): Promise<Boolean> {
+    const { tx, user }: { tx: EntityManager; user: User } = context.state
+    const toteRepo = tx.getRepository(Tote)
+
+    await toteRepo.update(
+      {
+        id: In(ids)
+      },
+      {
+        status,
+        updater: user
+      }
+    )
+
+    return true
+  }
+}

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

@@ -0,0 +1,102 @@
+import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository, IsNull } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { buildQuery, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
+
+import { Tote } from './tote'
+import { ToteList } from './tote-types'
+
+@Resolver(Tote)
+export class ToteQuery {
+  @Query(returns => ToteList)
+  async totes(
+    @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<ToteList> {
+    const { domain }: { domain: Domain } = context.state
+
+    const deletedFilter: any = filters.find((filter: any) => filter.name === 'deleted' && filter.value === true)
+
+    const queryBuilder = getRepository(Tote).createQueryBuilder()
+    buildQuery(queryBuilder, { filters, pagination, sortings }, context)
+
+    queryBuilder
+      .leftJoinAndSelect('Tote.domain', 'Domain')
+      .leftJoinAndSelect('Tote.bizplace', 'Bizplace')
+      .leftJoinAndSelect('Tote.creator', 'Creator')
+      .leftJoinAndSelect('Tote.updater', 'Updater')
+      .where('Domain.id = :domainId', { domainId: domain.id })
+
+    if (deletedFilter) {
+      queryBuilder.andWhere('Tote.deletedAt IS NOT NULL')
+    } else {
+      queryBuilder.andWhere('Tote.deletedAt IS NULL')
+    }
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @Query(returns => Tote)
+  async tote(@Arg('name') name: string, @Arg('bizplace') bizplace: string, @Ctx() context: any): Promise<Tote> {
+    const { domain }: { domain: Domain } = context.state
+    let foundBizplace = await getRepository(Bizplace).findOne({ where: { name: bizplace } })
+
+    let foundTote = await getRepository(Tote).findOne({
+      where: { domain, bizplace: foundBizplace, name, deletedAt: IsNull() },
+      relations: ['domain', 'bizplace', 'creator', 'updater']
+    })
+
+    if (!foundTote) {
+      throw new Error('Tote not found')
+    } else {
+      return foundTote
+    }
+  }
+
+  @Query(returns => String)
+  async checkToteStatus(
+    @Arg('name') name: string,
+    @Arg('bizplace') bizplace: string,
+    @Ctx() context: any
+  ): Promise<String> {
+    const { domain }: { domain: Domain } = context.state
+    let foundBizplace = await getRepository(Bizplace).findOne({ where: { name: bizplace } })
+
+    let foundTote = await getRepository(Tote).findOne({
+      where: { domain, bizplace: foundBizplace, name, deletedAt: IsNull() },
+      relations: ['domain', 'bizplace', 'creator', 'updater']
+    })
+
+    if (!foundTote) {
+      return ''
+    } else {
+      return foundTote.status
+    }
+  }
+
+  @FieldResolver()
+  async domain(@Root() tote: Tote) {
+    return await getRepository(Domain).findOne(tote.domainId)
+  }
+
+  @FieldResolver()
+  async bizplace(@Root() tote: Tote) {
+    return await getRepository(Bizplace).findOne(tote.bizplaceId)
+  }
+
+  @FieldResolver()
+  async updater(@Root() tote: Tote) {
+    return await getRepository(User).findOne(tote.updaterId)
+  }
+
+  @FieldResolver()
+  async creator(@Root() tote: Tote) {
+    return await getRepository(User).findOne(tote.creatorId)
+  }
+}

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

@@ -0,0 +1,44 @@
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef } from '@things-factory/shell'
+
+import { Tote } from './tote'
+
+@InputType()
+export class NewTote {
+  @Field()
+  name: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  bizplace?: ObjectRef
+
+  @Field({ nullable: true })
+  status?: string
+}
+
+@ObjectType()
+export class ToteList {
+  @Field(type => [Tote], { nullable: true })
+  items?: Tote[]
+
+  @Field(type => Int, { nullable: true })
+  total?: number
+}
+
+@InputType()
+export class TotePatch {
+  @Field({ nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  bizplace?: ObjectRef
+
+  @Field({ nullable: true })
+  status?: string
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}

package/server/service/tote/tote.ts

@@ -0,0 +1,77 @@
+import { Field, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+
+@Entity()
+@Index('ix_tote_0', (tote: Tote) => [tote.bizplace, tote.name], { unique: true })
+@ObjectType()
+export class Tote {
+  @PrimaryGeneratedColumn('uuid')
+  @Field()
+  id: string
+
+  @ManyToOne(type => Domain)
+  @Field()
+  domain: Domain
+
+  @RelationId((tote: Tote) => tote.domain)
+  domainId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @ManyToOne(type => Bizplace)
+  @ManyToOne(type => Bizplace)
+  @Field(type => Bizplace)
+  bizplace: Bizplace
+
+  @RelationId((tote: Tote) => tote.bizplace)
+  bizplaceId: string
+
+  @Column()
+  @Field()
+  status: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  creator: User
+
+  @RelationId((tote: Tote) => tote.creator)
+  creatorId: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  updater: User
+
+  @RelationId((tote: Tote) => tote.updater)
+  updaterId: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  deletedAt: Date
+}

package/server/utils/inventory-util.ts

@@ -355,7 +355,7 @@ export async function getProductBundleInventory(
         ) 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
+        left join inventories inv on ((inv.status <> 'TERMINATED' and (inv.qty - coalesce(inv.locked_qty,0)) > 0) or (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
@@ -404,7 +404,8 @@ export async function getInventoriesByStrategy(
       "packingSize" INT,
       "uom" VARCHAR(10),
       "releaseQty" INT,
-      "pickingStrategy" VARCHAR(25)
+      "pickingStrategy" VARCHAR(25),
+      "orderProductId" VARCHAR(50)
     );
   `
   )
@@ -412,7 +413,7 @@ export async function getInventoriesByStrategy(
   await trxMgr.query(
     `
     INSERT INTO temp_op2
-    SELECT "productId", "batchId", "packingType", "packingSize", "uom", "releaseQty", "pickingStrategy"
+    SELECT "productId", "batchId", "packingType", "packingSize", "uom", "releaseQty", "pickingStrategy", "orderProductId"
     FROM JSON_POPULATE_RECORDSET(NULL::temp_op2, $1) js
   `,
     [orderProductsJSON]
@@ -445,6 +446,7 @@ export async function getInventoriesByStrategy(
     op."packingType",
     op."packingSize",
     op."uom",
+    op."orderProductId",
     ROW_NUMBER() OVER (
       PARTITION BY op."productId", op."batchId", op."packingType", op."packingSize", op."uom"
       ORDER BY