@things-factory/sales-base 4.3.769 → 4.3.771

package/server/service/index.ts

@@ -49,6 +49,8 @@ import { entities as ShippingOrderEntity, resolvers as ShippingOrderResolvers }
 import { entities as TransferOrderEntity, resolvers as TransferOrderResolvers } from './transfer-order'
 import { entities as VasEntity, resolvers as VasResolvers } from './vas'
 import { entities as VasOrderEntity, resolvers as VasOrderResolvers } from './vas-order'
+import { entities as LoadingPackagesEntities, resolvers as LoadingPackagesResolvers } from './loading-packages'
+import { entities as LoadingPackageItemsEntities, resolvers as LoadingPackageItemsResolvers } from './loading-package-items'
 
 /* EXPORT ENTITY TYPES */
 export * from './order-consignment/order-consignment'
@@ -89,6 +91,8 @@ export * from './shipping-order/shipping-order'
 export * from './transfer-order/transfer-order'
 export * from './vas-order/vas-order'
 export * from './vas/vas'
+export * from './loading-packages/loading-packages'
+export * from './loading-package-items/loading-package-items'
 
 /* EXPORT TYPES */
 export * from './arrival-notice/arrival-notice-types'
@@ -123,6 +127,8 @@ export * from './transfer-order/transfer-order-types'
 export * from './vas-order/vas-order-types'
 export * from './vas/vas-types'
 export * from './order-vas-item/order-vas-item-type'
+export * from './loading-packages/loading-packages-type'
+export * from './loading-package-items/loading-package-items-type'
 
 /* EXPORT MUTATIONS */
 export * from './arrival-notice/arrival-notice-mutation'
@@ -156,6 +162,8 @@ export * from './transfer-order/transfer-order-mutation'
 export * from './vas-order/vas-order-mutation'
 export * from './vas/vas-mutation'
 export * from './release-good-logs/release-good-logs-mutation'
+export * from './loading-packages/loading-packages-mutation'
+export * from './loading-package-items/loading-package-items-mutation'
 
 /* EXPORT QUERIES */
 export * from './arrival-notice/arrival-notice-query'
@@ -189,6 +197,8 @@ export * from './shipping-order/shipping-order-query'
 export * from './transfer-order/transfer-order-query'
 export * from './vas-order/vas-order-query'
 export * from './vas/vas-query'
+export * from './loading-packages/loading-packages-query'
+export * from './loading-package-items/loading-package-items-query'
 
 export const entities = [
   /* ENTITIES */
@@ -229,7 +239,9 @@ export const entities = [
   ...ShippingOrderEntity,
   ...TransferOrderEntity,
   ...VasEntity,
-  ...VasOrderEntity
+  ...VasOrderEntity,
+  ...LoadingPackagesEntities,
+  ...LoadingPackageItemsEntities,
 ]
 
 export const schema = {
@@ -273,7 +285,9 @@ export const schema = {
     ...ShippingOrderResolvers,
     ...TransferOrderResolvers,
     ...VasResolvers,
-    ...VasOrderResolvers
+    ...VasOrderResolvers,
+    ...LoadingPackagesResolvers,
+    ...LoadingPackageItemsResolvers,
   ]
 }
 

package/server/service/loading-package-items/index.ts

@@ -0,0 +1,6 @@
+import { LoadingPackageItems } from './loading-package-items'
+import { LoadingPackageItemsQuery } from './loading-package-items-query'
+import { LoadingPackageItemsMutation } from './loading-package-items-mutation'
+
+export const entities = [LoadingPackageItems]
+export const resolvers = [LoadingPackageItemsQuery, LoadingPackageItemsMutation]

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

@@ -0,0 +1,112 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { getRepository, In } from 'typeorm'
+import { LoadingPackageItems } from './loading-package-items'
+import { NewLoadingPackageItems, LoadingPackageItemsPatch } from './loading-package-items-type'
+
+@Resolver(LoadingPackageItems)
+export class LoadingPackageItemsMutation {
+  @Directive('@transaction')
+  @Mutation(returns => LoadingPackageItems, { description: 'To create new LoadingPackageItems' })
+  async createLoadingPackageItems(@Arg('loadingPackageItems') loadingPackageItems: NewLoadingPackageItems, @Ctx() context: any): Promise<LoadingPackageItems> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(LoadingPackageItems).save({
+      ...loadingPackageItems,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => LoadingPackageItems, { description: 'To modify LoadingPackageItems information' })
+  async updateLoadingPackageItems(
+    @Arg('id') id: string,
+    @Arg('patch') patch: LoadingPackageItemsPatch,
+    @Ctx() context: any
+  ): Promise<LoadingPackageItems> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(LoadingPackageItems)
+    const loadingPackageItems = await repository.findOne({
+      where: { domain, id }
+    })
+
+    return await repository.save({
+      ...loadingPackageItems,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [LoadingPackageItems], { description: "To modify multiple LoadingPackageItems' information" })
+  async updateMultipleLoadingPackageItems(
+    @Arg('patches', type => [LoadingPackageItemsPatch]) patches: LoadingPackageItemsPatch[],
+    @Ctx() context: any
+  ): Promise<LoadingPackageItems[]> {
+    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 loadingPackageItemsRepo = tx.getRepository(LoadingPackageItems)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await loadingPackageItemsRepo.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 loadingPackageItems = await loadingPackageItemsRepo.findOne(newRecord.id)
+
+        const result = await loadingPackageItemsRepo.save({
+          ...loadingPackageItems,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete LoadingPackageItems' })
+  async deleteLoadingPackageItems(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(LoadingPackageItems).delete({ domain, id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple loadingPackageItemss' })
+  async deleteMultipleLoadingPackageItems(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: any
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(LoadingPackageItems).delete({
+      domain,
+      id: In(ids)
+    })
+
+    return true
+  }
+}

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

@@ -0,0 +1,43 @@
+import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
+import { getRepository } from 'typeorm'
+import { Domain, ListParam, convertListParams } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { LoadingPackageItems } from './loading-package-items'
+import { LoadingPackageItemsList } from './loading-package-items-type'
+
+@Resolver(LoadingPackageItems)
+export class LoadingPackageItemsQuery {
+  @Query(returns => LoadingPackageItems, { description: 'To fetch a LoadingPackageItems' })
+  async loadingPackageItem(@Arg('id') id: string, @Ctx() context: any): Promise<LoadingPackageItems> {
+    const { domain } = context.state
+
+    return await getRepository(LoadingPackageItems).findOne({
+      where: { domain, id }
+    })
+  }
+
+  @Query(returns => LoadingPackageItemsList, { description: 'To fetch multiple LoadingPackageItems' })
+  async loadingPackageItems(@Args() params: ListParam, @Ctx() context: any): Promise<LoadingPackageItemsList> {
+    const { domain } = context.state
+
+    const convertedParams = convertListParams(params, domain.id)
+    const [items, total] = await getRepository(LoadingPackageItems).findAndCount(convertedParams)
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() loadingPackageItems: LoadingPackageItems): Promise<Domain> {
+    return await getRepository(Domain).findOne(loadingPackageItems.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() loadingPackageItems: LoadingPackageItems): Promise<User> {
+    return await getRepository(User).findOne(loadingPackageItems.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() loadingPackageItems: LoadingPackageItems): Promise<User> {
+    return await getRepository(User).findOne(loadingPackageItems.creatorId)
+  }
+}

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

@@ -0,0 +1,45 @@
+import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
+
+import { LoadingPackageItems } from './loading-package-items'
+
+@InputType()
+export class NewLoadingPackageItems {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field({ nullable: true })
+  params?: string
+}
+
+@InputType()
+export class LoadingPackageItemsPatch {
+  @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 LoadingPackageItemsList {
+  @Field(type => [LoadingPackageItems])
+  items: LoadingPackageItems[]
+
+  @Field(type => Int)
+  total: number
+}

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

@@ -0,0 +1,140 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  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 { LoadingPackages, OrderProduct, OrderInventory } from '../'
+import { ProductDetail } from '@things-factory/product-base'
+
+@Entity()
+@Index('ix_loading_package_items_0', (loadingPackageItems: LoadingPackageItems) => [loadingPackageItems.domain, loadingPackageItems.name], { unique: true })
+@ObjectType({ description: 'Entity for LoadingPackageItems' })
+export class LoadingPackageItems {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((loadingPackageItems: LoadingPackageItems) => loadingPackageItems.domain)
+  domainId?: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @ManyToOne(type => Bizplace)
+  @Field(type => Bizplace, { nullable: true })
+  bizplace?: Bizplace
+
+  @RelationId((loadingPackageItems: LoadingPackageItems) => loadingPackageItems.bizplace)
+  bizplaceId?: string
+
+  @ManyToOne(type => LoadingPackages)
+  @Field(type => LoadingPackages)
+  loadingPackage?: LoadingPackages
+
+  @RelationId((loadingPackageItems: LoadingPackageItems) => loadingPackageItems.loadingPackage)
+  loadingPackageId?: string
+
+  @ManyToOne(type => OrderProduct)
+  @Field(type => OrderProduct, { nullable: true })
+  orderProduct?: OrderProduct
+
+  @RelationId((loadingPackageItems: LoadingPackageItems) => loadingPackageItems.orderProduct)
+  orderProductId?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  status?: string
+
+  @Column({
+    type: 'decimal',
+    scale: 3,
+    nullable: true,
+    transformer: {
+      to: (value: string | null) => value,
+      from: (value: string | null) => {
+        if (value === null || value === undefined) return null
+        const parsed = parseFloat(value)
+        return isNaN(parsed) ? null : parsed
+      }
+    }
+  })
+  @Field({ nullable: true })
+  releaseQty: number
+
+  @Column({
+    type: 'decimal',
+    scale: 3,
+    nullable: true,
+    transformer: {
+      to: (value: string | null) => value,
+      from: (value: string | null) => {
+        if (value === null || value === undefined) return null
+        const parsed = parseFloat(value)
+        return isNaN(parsed) ? null : parsed
+      }
+    }
+  })
+  @Field({ nullable: true })
+  packedQty: number
+
+  @ManyToOne(type => ProductDetail, { nullable: true })
+  @Field(type => ProductDetail, { nullable: true })
+  productDetail: ProductDetail
+
+  @RelationId((loadingPackageItems: LoadingPackageItems) => loadingPackageItems.productDetail)
+  productDetailId?: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((loadingPackageItems: LoadingPackageItems) => loadingPackageItems.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((loadingPackageItems: LoadingPackageItems) => loadingPackageItems.updater)
+  updaterId?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  deletedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  deletedBy?: User
+
+  @RelationId((loadingPackageItems: LoadingPackageItems) => loadingPackageItems.deletedBy)
+  deletedById?: string
+}

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

@@ -0,0 +1,6 @@
+import { LoadingPackages } from './loading-packages'
+import { LoadingPackagesQuery } from './loading-packages-query'
+import { LoadingPackagesMutation } from './loading-packages-mutation'
+
+export const entities = [LoadingPackages]
+export const resolvers = [LoadingPackagesQuery, LoadingPackagesMutation]

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