@things-factory/sales-base 4.3.767 → 4.3.770

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

@@ -0,0 +1,150 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { getRepository, In, IsNull } from 'typeorm'
+import { LoadingPackages } from './loading-packages'
+import { LoadingPackageItems } from '../loading-package-items/loading-package-items'
+import { NewLoadingPackages, LoadingPackagesPatch } from './loading-packages-type'
+
+@Resolver(LoadingPackages)
+export class LoadingPackagesMutation {
+  @Directive('@transaction')
+  @Mutation(returns => LoadingPackages, { description: 'To create new LoadingPackages' })
+  async createLoadingPackages(@Arg('loadingPackages') loadingPackages: NewLoadingPackages, @Ctx() context: any): Promise<LoadingPackages> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(LoadingPackages).save({
+      ...loadingPackages,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => LoadingPackages, { description: 'To modify LoadingPackages information' })
+  async updateLoadingPackages(
+    @Arg('id') id: string,
+    @Arg('patch') patch: LoadingPackagesPatch,
+    @Ctx() context: any
+  ): Promise<LoadingPackages> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(LoadingPackages)
+    const loadingPackages = await repository.findOne({
+      where: { domain, id }
+    })
+
+    return await repository.save({
+      ...loadingPackages,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [LoadingPackages], { description: "To modify multiple LoadingPackages' information" })
+  async updateMultipleLoadingPackages(
+    @Arg('patches', type => [LoadingPackagesPatch]) patches: LoadingPackagesPatch[],
+    @Ctx() context: any
+  ): Promise<LoadingPackages[]> {
+    const { domain, user, tx } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const loadingPackagesRepo = tx.getRepository(LoadingPackages)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await loadingPackagesRepo.save({
+          ...newRecord,
+          domain,
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const loadingPackages = await loadingPackagesRepo.findOne(newRecord.id)
+
+        const result = await loadingPackagesRepo.save({
+          ...loadingPackages,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete LoadingPackages' })
+  async deleteLoadingPackages(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(LoadingPackages).delete({ domain, id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To undo (soft delete) LoadingPackages' })
+  async undoLoadingPackages(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+    const { domain, user, tx } = context.state
+
+    // Find the loading package with its items
+    const loadingPackage = await tx.getRepository(LoadingPackages).findOne({
+      where: { domain, id },
+      relations: ['loadingPackageItems']
+    })
+
+    if (!loadingPackage) {
+      throw new Error('Loading package not found')
+    }
+
+    // Use same timestamp for both package and items
+    const deletedAt = new Date()
+
+    // Soft delete the loading package
+    await tx.getRepository(LoadingPackages).save({
+      ...loadingPackage,
+      deletedAt,
+      deletedBy: user
+    })
+
+    // Soft delete all related loading package items in a single query
+    if (loadingPackage.loadingPackageItems && loadingPackage.loadingPackageItems.length > 0) {
+      const itemIds = loadingPackage.loadingPackageItems.map(item => item.id)
+      await tx.getRepository(LoadingPackageItems).update(
+        { id: In(itemIds) },
+        { deletedAt, deletedBy: user }
+      )
+    }
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple loadingPackagess' })
+  async deleteMultipleLoadingPackages(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: any
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(LoadingPackages).delete({
+      domain,
+      id: In(ids)
+    })
+
+    return true
+  }
+}

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 })