@things-factory/sales-base 4.3.769 → 4.3.771

package/server/service/loading-packages/loading-packages-query.ts

@@ -0,0 +1,272 @@
+import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive, Int } from 'type-graphql'
+import { getRepository, In, IsNull } from 'typeorm'
+import { Domain, ListParam, convertListParams } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { ReleaseGood } from '../'
+import { LoadingPackages } from './loading-packages'
+import { LoadingPackagesList } from './loading-packages-type'
+
+@Resolver(LoadingPackages)
+export class LoadingPackagesQuery {
+  @Query(returns => LoadingPackages, { description: 'To fetch a LoadingPackages' })
+  async loadingPackage(@Arg('id') id: string, @Ctx() context: any): Promise<LoadingPackages> {
+    const { domain } = context.state
+
+    return await getRepository(LoadingPackages).findOne({
+      where: { domain, id, deletedAt: IsNull() }
+    })
+  }
+
+  @Query(returns => LoadingPackagesList, { description: 'To fetch multiple LoadingPackages' })
+  async loadingPackages(@Args() params: ListParam, @Ctx() context: any): Promise<LoadingPackagesList> {
+    const { domain } = context.state
+
+    const convertedParams = convertListParams(params, domain.id)
+    const [items, total] = await getRepository(LoadingPackages).findAndCount(convertedParams)
+
+    return { items, total }
+  }
+
+  @Query(returns => [LoadingPackages], { description: 'To fetch LoadingPackages by releaseGoodNo' })
+  async loadingPackagesByReleaseGoodNo(@Arg('releaseGoodNo') releaseGoodNo: string, @Ctx() context: any): Promise<LoadingPackages[]> {
+    const { domain } = context.state
+
+    const releaseGood = await getRepository(ReleaseGood).findOne({
+      where: { domain, name: releaseGoodNo }
+    })
+
+    if (!releaseGood) {
+      return []
+    }
+
+    return await getRepository(LoadingPackages).find({
+      where: { domain, releaseGood, deletedAt: IsNull() },
+      relations: [
+        'loadingPackageItems',
+        'loadingPackageItems.orderProduct',
+        'loadingPackageItems.orderProduct.product',
+        'loadingPackageItems.productDetail',
+        'releaseGood',
+        'bizplace'
+      ],
+      order: { createdAt: 'ASC' }
+    })
+  }
+
+  @Query(returns => [LoadingPackages], { description: 'To fetch LoadingPackages by multiple releaseGoodNos' })
+  async loadingPackagesByReleaseGoodNos(
+    @Arg('releaseGoodNos', type => [String]) releaseGoodNos: string[],
+    @Ctx() context: any
+  ): Promise<LoadingPackages[]> {
+    const { domain } = context.state
+
+    // Step 1: Check if releaseGoodNos is empty
+    if (!releaseGoodNos || releaseGoodNos.length === 0) {
+      throw new Error('No release goods numbers provided')
+    }
+
+    // Step 2: Make them into distinct values
+    const distinctReleaseGoodNos = [...new Set(releaseGoodNos.filter(no => no && no.trim()))]
+
+    if (distinctReleaseGoodNos.length === 0) {
+      throw new Error('No valid release goods numbers provided')
+    }
+
+    // Step 3: Use distinct array to search in the DB
+    const releaseGoods = await getRepository(ReleaseGood).find({
+      where: { domain, name: In(distinctReleaseGoodNos) }
+    })
+
+    // Step 4: Check if the length returned matches the distinct array
+    if (releaseGoods.length !== distinctReleaseGoodNos.length) {
+      const foundNames = releaseGoods.map(rg => rg.name)
+      const notFoundNames = distinctReleaseGoodNos.filter(name => !foundNames.includes(name))
+      throw new Error(`Release good number(s) not found: ${notFoundNames.join(', ')}`)
+    }
+
+    // Step 5: Fetch loading packages and loading package items
+    const releaseGoodIds = releaseGoods.map(rg => rg.id)
+
+    return await getRepository(LoadingPackages)
+      .createQueryBuilder('lp')
+      .leftJoinAndSelect('lp.loadingPackageItems', 'lpi')
+      .leftJoinAndSelect('lpi.orderProduct', 'op')
+      .leftJoinAndSelect('op.product', 'product')
+      .leftJoinAndSelect('lpi.productDetail', 'pd')
+      .leftJoinAndSelect('lp.releaseGood', 'rg')
+      .leftJoinAndSelect('rg.bizplace', 'bizplace')
+      .where('lp.domain_id = :domainId', { domainId: domain.id })
+      .andWhere('lp.release_good_id IN (:...releaseGoodIds)', { releaseGoodIds })
+      .andWhere('lp.deleted_at IS NULL')
+      .andWhere('lpi.deleted_at IS NULL')
+      .orderBy('lp.release_good_id', 'ASC')
+      .addOrderBy('lp.created_at', 'ASC')
+      .getMany()
+  }
+
+  @Query(returns => LoadingPackagesList, { description: 'To fetch printed LoadingPackages history with pagination' })
+  async printedLoadingPackagesHistory(@Args() params: ListParam, @Ctx() context: any): Promise<LoadingPackagesList> {
+    const { domain } = context.state
+
+    const convertedParams = convertListParams(params, domain.id)
+
+    // Extract filters from params
+    const orderNoFilter = params.filters?.find(f => f.name === 'releaseGood.name')
+    const displayNumberFilter = params.filters?.find(f => f.name === 'displayNumber')
+
+    // Build parameters for raw query
+    const queryParams: any[] = [domain.id]
+    let paramIndex = 2
+
+    // Build WHERE clauses for filters
+    let orderNoClause = ''
+    if (orderNoFilter?.value) {
+      orderNoClause = `AND (rg.name ILIKE $${paramIndex} OR rg.ref_no ILIKE $${paramIndex})`
+      queryParams.push(`%${orderNoFilter.value}%`)
+      paramIndex++
+    }
+
+    let displayNumberClause = ''
+    if (displayNumberFilter?.value) {
+      const displayNumber = parseInt(displayNumberFilter.value)
+      if (!isNaN(displayNumber)) {
+        displayNumberClause = `AND dn.display_number = $${paramIndex}`
+        queryParams.push(displayNumber)
+        paramIndex++
+      }
+    }
+
+    // Build sorting - map frontend column names to subquery column names
+    const columnMapping: Record<string, string> = {
+      releaseGood: 'rg_name',
+      refNo: 'rg_ref_no',
+      displayNumber: 'display_number',
+      printedAt: 'printed_at',
+      printedBy: 'user_name'
+    }
+
+    let orderByClause = 'ORDER BY dn.printed_at DESC'
+    if (convertedParams.order) {
+      const sortParts = Object.entries(convertedParams.order)
+        .map(([key, direction]) => {
+          const mappedColumn = columnMapping[key] || key
+          return `dn.${mappedColumn} ${direction}`
+        })
+      if (sortParts.length > 0) {
+        orderByClause = `ORDER BY ${sortParts.join(', ')}`
+      }
+    }
+
+    // Pagination
+    const skip = convertedParams.skip || 0
+    const take = convertedParams.take || 50
+
+    // Single query: Get all data with display numbers and total count using window functions
+    const query = `
+      SELECT
+        dn.id,
+        dn.name,
+        dn.printed_at as "printedAt",
+        dn.display_number as "displayNumber",
+        COUNT(*) OVER() as total_count,
+        dn.rg_id as "releaseGood_id",
+        dn.rg_name as "releaseGood_name",
+        dn.rg_ref_no as "releaseGood_refNo",
+        dn.user_id as "printedBy_id",
+        dn.user_name as "printedBy_name",
+        dn.user_description as "printedBy_description"
+      FROM (
+        SELECT
+          lp.id,
+          lp.name,
+          lp.printed_at,
+          ROW_NUMBER() OVER (PARTITION BY lp.release_good_id ORDER BY lp.created_at ASC) as display_number,
+          rg.id as rg_id,
+          rg.name as rg_name,
+          rg.ref_no as rg_ref_no,
+          u.id as user_id,
+          u.name as user_name,
+          u.description as user_description
+        FROM loading_packages lp
+        LEFT JOIN release_goods rg ON rg.id = lp.release_good_id
+        LEFT JOIN users u ON u.id = lp.printed_by_id
+        WHERE lp.domain_id = $1
+          AND lp.deleted_at IS NULL
+          AND lp.printed_at IS NOT NULL
+          ${orderNoClause}
+      ) dn
+      WHERE 1=1 ${displayNumberClause}
+      ${orderByClause}
+      LIMIT ${take} OFFSET ${skip}
+    `
+
+    const results: any[] = await getRepository(LoadingPackages).query(query, queryParams)
+
+    if (results.length === 0) {
+      return { items: [], total: 0 }
+    }
+
+    // Get total from first row (same for all rows due to COUNT(*) OVER())
+    const total = parseInt(results[0]?.total_count) || 0
+
+    // Map raw results to entity structure
+    const items = results.map(row => ({
+      id: row.id,
+      name: row.name,
+      printedAt: row.printedAt,
+      displayNumber: parseInt(row.displayNumber) || 0,
+      releaseGood: row.releaseGood_id ? {
+        id: row.releaseGood_id,
+        name: row.releaseGood_name,
+        refNo: row.releaseGood_refNo
+      } : null,
+      printedBy: row.printedBy_id ? {
+        id: row.printedBy_id,
+        name: row.printedBy_name,
+        description: row.printedBy_description
+      } : null
+    })) as LoadingPackages[]
+
+    return { items, total }
+  }
+
+  @Query(returns => Int, { description: 'To get the maximum packing label count across all release goods' })
+  async maxPackingLabelCount(@Ctx() context: any): Promise<number> {
+    const { domain } = context.state
+
+    const result = await getRepository(LoadingPackages)
+      .createQueryBuilder('lp')
+      .select('rg.id', 'releaseGoodId')
+      .addSelect('COUNT(lp.id)', 'count')
+      .leftJoin('lp.releaseGood', 'rg')
+      .where('lp.domain_id = :domainId', { domainId: domain.id })
+      .andWhere('lp.deleted_at IS NULL')
+      .andWhere('lp.printed_at IS NOT NULL')
+      .groupBy('rg.id')
+      .orderBy('count', 'DESC')
+      .limit(1)
+      .getRawOne()
+
+    return result ? parseInt(result.count) : 0
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() loadingPackages: LoadingPackages): Promise<Domain> {
+    return await getRepository(Domain).findOne(loadingPackages.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() loadingPackages: LoadingPackages): Promise<User> {
+    return await getRepository(User).findOne(loadingPackages.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() loadingPackages: LoadingPackages): Promise<User> {
+    return await getRepository(User).findOne(loadingPackages.creatorId)
+  }
+
+  @FieldResolver(type => User)
+  async printedBy(@Root() loadingPackages: LoadingPackages): Promise<User> {
+    return await getRepository(User).findOne(loadingPackages.printedById)
+  }
+}

package/server/service/loading-packages/loading-packages-type.ts

@@ -0,0 +1,45 @@
+import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
+
+import { LoadingPackages } from './loading-packages'
+
+@InputType()
+export class NewLoadingPackages {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field({ nullable: true })
+  params?: string
+}
+
+@InputType()
+export class LoadingPackagesPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field()
+  cuFlag: string
+}
+
+@ObjectType()
+export class LoadingPackagesList {
+  @Field(type => [LoadingPackages])
+  items: LoadingPackages[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/loading-packages/loading-packages.ts

@@ -0,0 +1,110 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  OneToMany,
+  ManyToOne,
+  PrimaryGeneratedColumn
+} from 'typeorm'
+import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
+
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { ReleaseGood } from '../'
+import { LoadingPackageItems } from '../loading-package-items/loading-package-items'
+
+@Entity()
+@Index('ix_loading_packages_0', (loadingPackages: LoadingPackages) => [loadingPackages.domain, loadingPackages.name], { unique: true })
+@ObjectType({ description: 'Entity for LoadingPackages' })
+export class LoadingPackages {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  status: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((loadingPackages: LoadingPackages) => loadingPackages.domain)
+  domainId?: string
+
+  @ManyToOne(type => Bizplace)
+  @Field(type => Bizplace, { nullable: true })
+  bizplace?: Bizplace
+
+  @RelationId((loadingPackages: LoadingPackages) => loadingPackages.bizplace)
+  bizplaceId?: string
+
+  @ManyToOne(type => ReleaseGood)
+  @Field(type => ReleaseGood, { nullable: true })
+  releaseGood?: ReleaseGood
+
+  @OneToMany(type => LoadingPackageItems, loadingPackageItems => loadingPackageItems.loadingPackage)
+  @Field(type => [LoadingPackageItems], { nullable: true })
+  loadingPackageItems: LoadingPackageItems[]
+  
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((loadingPackages: LoadingPackages) => loadingPackages.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((loadingPackages: LoadingPackages) => loadingPackages.updater)
+  updaterId?: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  printedBy?: User
+
+  @RelationId((loadingPackages: LoadingPackages) => loadingPackages.printedBy)
+  printedById?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  printedAt?: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  deletedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  deletedBy?: User
+
+  @RelationId((loadingPackages: LoadingPackages) => loadingPackages.deletedBy)
+  deletedById?: string
+
+  @Field(type => Int, { nullable: true })
+  displayNumber?: number
+}

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

@@ -227,6 +227,7 @@ export class OrderInventory {
   orderProduct: OrderProduct
 
   @RelationId((orderInventory: OrderInventory) => orderInventory.orderProduct)
+  @Field({ nullable: true })
   orderProductId: string
 
   @OneToMany(type => OrderToteItem, orderToteItem => orderToteItem.orderInventory, { nullable: true })

package/server/service/release-good/release-good-mutation.ts

@@ -476,14 +476,19 @@ export async function deleteReleaseGood(tx: EntityManager, name: string, user: U
   await Promise.all(
     foundOIs.map(async (oi: OrderInventory) => {
       if (oi?.inventory?.id) {
-        oi.inventory = await tx.getRepository(Inventory).findOne(oi.inventory.id)
-
-        await tx.getRepository(Inventory).save({
-          ...oi.inventory,
-          lockedQty: safeDecimalOperation(oi.inventory.lockedQty, oi.releaseQty, 'subtract'),
-          lockedUomValue: safeDecimalOperation(oi.inventory.lockedUomValue, oi.releaseUomValue, 'subtract'),
-          updater: user
-        })
+        await tx
+          .getRepository(Inventory)
+          .createQueryBuilder()
+          .update(Inventory)
+          .set({
+            lockedQty: () => `GREATEST(COALESCE("locked_qty", 0) - :releaseQty::numeric, 0)`,
+            lockedUomValue: () => `GREATEST(COALESCE("locked_uom_value", 0) - :releaseUomValue::numeric, 0)`,
+            updater: user
+          })
+          .setParameter('releaseQty', oi.releaseQty)
+          .setParameter('releaseUomValue', oi.releaseUomValue)
+          .where('id = :id', { id: oi.inventory.id })
+          .execute()
       }
 
       await tx.getRepository(OrderInventory).delete({ id: oi.id })
@@ -505,9 +510,11 @@ export async function deleteReleaseGood(tx: EntityManager, name: string, user: U
           .createQueryBuilder()
           .update(ProductDetailStock)
           .set({
-            unassignedQty: () => `"unassigned_qty" - ${op.releaseQty}`,
-            unassignedUomValue: () => `"unassigned_uom_value" - ${op.releaseUomValue}`
+            unassignedQty: () => `GREATEST("unassigned_qty" - :releaseQty::numeric, 0)`,
+            unassignedUomValue: () => `GREATEST("unassigned_uom_value" - :releaseUomValue::numeric, 0)`
           })
+          .setParameter('releaseQty', op.releaseQty)
+          .setParameter('releaseUomValue', op.releaseUomValue)
           .where({ productDetail: op.productDetail.id })
           .execute()
 
@@ -1131,20 +1138,37 @@ export async function generateReleaseGoodFunction(
       if (worksheetPickingAssignment?.value !== 'true' || oi.inventory?.id) {
         await tx.getRepository(OrderInventory).save({ ...oi, name: OrderNoGenerator.orderInventory() })
 
-        await tx.getRepository(Inventory).update(oi.inventory.id, {
-          lockedQty: (oi.inventory?.lockedQty || 0) + oi.releaseQty,
-          lockedUomValue: (oi.inventory?.lockedUomValue || 0) + oi.releaseUomValue,
-          updater: user
-        })
+        const lockResult = await tx
+          .getRepository(Inventory)
+          .createQueryBuilder()
+          .update(Inventory)
+          .set({
+            lockedQty: () => `COALESCE("locked_qty", 0) + :releaseQty::numeric`,
+            lockedUomValue: () => `COALESCE("locked_uom_value", 0) + :releaseUomValue::numeric`,
+            updater: user
+          })
+          .setParameter('releaseQty', oi.releaseQty)
+          .setParameter('releaseUomValue', oi.releaseUomValue)
+          .where('id = :id AND qty >= COALESCE(locked_qty, 0) + :newQty', {
+            id: oi.inventory.id,
+            newQty: oi.releaseQty
+          })
+          .execute()
+
+        if (lockResult.affected === 0) {
+          throw new Error(`Insufficient inventory for ${oi.product?.sku || 'unknown product'}`)
+        }
       } else {
         await tx
           .getRepository(ProductDetailStock)
           .createQueryBuilder()
           .update(ProductDetailStock)
           .set({
-            unassignedQty: () => `"unassigned_qty" + ${oi.releaseQty}`,
-            unassignedUomValue: () => `"unassigned_uom_value" + ${oi.releaseUomValue}`
+            unassignedQty: () => `"unassigned_qty" + :releaseQty::numeric`,
+            unassignedUomValue: () => `"unassigned_uom_value" + :releaseUomValue::numeric`
           })
+          .setParameter('releaseQty', oi.releaseQty)
+          .setParameter('releaseUomValue', oi.releaseUomValue)
           .where({ productDetail: oi.productDetail.id })
           .execute()
       }
@@ -1971,10 +1995,12 @@ export async function bulkGenerateReleaseGood(
           .createQueryBuilder()
           .update(Inventory)
           .set({
-            lockedQty: () => `COALESCE("locked_qty",0) + ${generatedOI.releaseQty}`,
-            lockedUomValue: () => `COALESCE("locked_uom_value",0) + ${generatedOI.releaseUomValue}`,
+            lockedQty: () => `COALESCE("locked_qty",0) + :releaseQty::numeric`,
+            lockedUomValue: () => `COALESCE("locked_uom_value",0) + :releaseUomValue::numeric`,
             updater: user
           })
+          .setParameter('releaseQty', generatedOI.releaseQty)
+          .setParameter('releaseUomValue', generatedOI.releaseUomValue)
           .where(`id = :id AND qty >= COALESCE(locked_qty,0) + :newQty`, {
             id: oi.inventory.id,
             newQty: generatedOI.releaseQty
@@ -1990,9 +2016,11 @@ export async function bulkGenerateReleaseGood(
           .createQueryBuilder()
           .update(ProductDetailStock)
           .set({
-            unassignedQty: () => `"unassigned_qty" + ${generatedOI.releaseQty}`,
-            unassignedUomValue: () => `"unassigned_uom_value" + ${generatedOI.releaseUomValue}`
+            unassignedQty: () => `"unassigned_qty" + :releaseQty::numeric`,
+            unassignedUomValue: () => `"unassigned_uom_value" + :releaseUomValue::numeric`
           })
+          .setParameter('releaseQty', generatedOI.releaseQty)
+          .setParameter('releaseUomValue', generatedOI.releaseUomValue)
           .where({ productDetail: oi.productDetail ? oi.productDetail.id : oi.productDetailId })
           .execute()
       }