@things-factory/warehouse-base 4.0.0-alpha.7 → 4.0.0-beta.1

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

@@ -0,0 +1,269 @@
+import { Field, Float, InputType, Int, ObjectType } from 'type-graphql'
+
+import { Bizplace } from '@things-factory/biz-base'
+import { Product } from '@things-factory/product-base'
+import { ObjectRef } from '@things-factory/shell'
+
+import { Location } from '../location/location'
+import { InventoryHistory } from './inventory-history'
+
+@ObjectType()
+export class InventoryHistoryList {
+  @Field(type => [InventoryHistory], { nullable: true })
+  items?: InventoryHistory[]
+
+  @Field(type => Int, { nullable: true })
+  total?: number
+}
+
+@ObjectType()
+export class InventoryHistoryPalletReportList {
+  @Field(type => [InventoryHistoryPalletReportList], { nullable: true })
+  items?: InventoryHistoryPalletReportList[]
+
+  @Field(type => Int, { nullable: true })
+  total?: number
+
+  @Field(type => Int, { nullable: true })
+  totalWithOpeningBalance?: number
+}
+
+@ObjectType()
+export class InventoryHistoryPalletReport {
+  @Field(type => Bizplace, { nullable: true })
+  bizplace?: Bizplace
+
+  @Field(type => Location, { nullable: true })
+  location?: Location
+
+  @Field({ nullable: true })
+  palletId?: string
+
+  @Field({ nullable: true })
+  cartonId?: string
+
+  @Field({ nullable: true })
+  inboundPalletId?: string
+
+  @Field(type => Int, { nullable: true })
+  inboundQty?: number
+
+  @Field(type => Int, { nullable: true })
+  totalQty?: number
+}
+
+@InputType()
+export class InventoryHistoryPatch {
+  @Field({ nullable: true })
+  id?: string
+
+  @Field(type => Int, { nullable: true })
+  seq?: number
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  bizplace: ObjectRef
+
+  @Field({ nullable: true })
+  orderRefNo?: string
+
+  @Field({ nullable: true })
+  orderNo?: string
+
+  @Field({ nullable: true })
+  palletId?: string
+
+  @Field({ nullable: true })
+  cartonId?: string
+
+  @Field({ nullable: true })
+  batchId?: string
+
+  @Field({ nullable: true })
+  batchIdRef?: string
+
+  @Field({ nullable: true })
+  productId?: string
+
+  @Field({ nullable: true })
+  productName?: string
+
+  @Field({ nullable: true })
+  reusablePalletId?: string
+
+  @Field({ nullable: true })
+  reusablePalletName?: string
+
+  @Field({ nullable: true })
+  locationId?: string
+
+  @Field({ nullable: true })
+  locationName?: string
+
+  @Field({ nullable: true })
+  warehouseId?: string
+
+  @Field({ nullable: true })
+  warehouseName?: string
+
+  @Field({ nullable: true })
+  otherRef?: string
+
+  @Field({ nullable: true })
+  zone?: string
+
+  @Field({ nullable: true })
+  packingType?: string
+
+  @Field(type => Float, { nullable: true })
+  packingSize?: number
+
+  @Field(type => Int, { nullable: true })
+  qty?: number
+
+  @Field({ nullable: true })
+  uom?: string
+
+  @Field(type => Float, { nullable: true })
+  uomValue?: number
+
+  @Field({ nullable: true })
+  status?: string
+
+  @Field({ nullable: true })
+  transactionType?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  cuFlag?: string
+
+  @Field({ nullable: true })
+  fromDate?: string
+
+  @Field({ nullable: true })
+  toDate?: string
+}
+
+@ObjectType()
+export class InventoryHistorySummary {
+  @Field({ nullable: true })
+  batchId?: string
+
+  @Field({ nullable: true })
+  packingType?: string
+
+  @Field(type => Int, { nullable: true })
+  packingSize?: number
+
+  @Field(type => Product, { nullable: true })
+  product?: Product
+
+  @Field(type => Float, { nullable: true })
+  openingQty?: number
+
+  @Field(type => Float, { nullable: true })
+  adjustmentQty?: number
+
+  @Field(type => Float, { nullable: true })
+  closingQty?: number
+
+  @Field(type => Float, { nullable: true })
+  totalInQty?: number
+
+  @Field(type => Float, { nullable: true })
+  totalOutQty?: number
+
+  @Field(type => Float, { nullable: true })
+  initialQty?: number
+
+  @Field({ nullable: true })
+  initialDate?: string
+}
+
+@ObjectType()
+export class InventoryHistorySummaryList {
+  @Field(type => [InventoryHistorySummary], { nullable: true })
+  items?: InventoryHistorySummary[]
+
+  @Field(type => Int, { nullable: true })
+  total?: number
+
+  @Field(type => Int, { nullable: true })
+  totalInboundQty?: number
+
+  @Field(type => Int, { nullable: true })
+  totalOpeningBal?: number
+}
+
+@InputType()
+export class NewInventoryHistory {
+  @Field(type => Int, { nullable: true })
+  seq?: number
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  palletId?: string
+
+  @Field({ nullable: true })
+  cartonId?: string
+
+  @Field({ nullable: true })
+  batchId?: string
+
+  @Field({ nullable: true })
+  batchIdRef?: string
+
+  @Field({ nullable: true })
+  productId?: string
+
+  @Field({ nullable: true })
+  reusablePalletId?: string
+
+  @Field({ nullable: true })
+  locationId?: string
+
+  @Field({ nullable: true })
+  warehouseId?: string
+
+  @Field({ nullable: true })
+  otherRef?: string
+
+  @Field({ nullable: true })
+  zone?: string
+
+  @Field({ nullable: true })
+  packingType?: string
+
+  @Field(type => Float, { nullable: true })
+  packingSize?: number
+
+  @Field(type => Float, { nullable: true })
+  uomValue?: number
+
+  @Field(type => Int, { nullable: true })
+  qty?: number
+
+  @Field({ nullable: true })
+  uom?: string
+
+  @Field({ nullable: true })
+  status?: string
+
+  @Field({ nullable: true })
+  transactionType?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  expirationDate?: Date
+
+  @Field(type => Float, { nullable: true })
+  unitCost?: number
+}

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

@@ -1,9 +1,24 @@
+import { Field, ID, 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 { Product, ProductDetail } from '@things-factory/product-base'
 import { Domain } from '@things-factory/shell'
-import { Column, CreateDateColumn, Entity, Index, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm'
-import { Pallet, Inventory, Warehouse, Location } from '../entities'
+
+import { Inventory } from '../inventory/inventory'
+import { Location } from '../location/location'
+import { Pallet } from '../pallet/pallet'
+import { Warehouse } from '../warehouse/warehouse'
 
 @Entity()
 @Index(
@@ -11,126 +26,170 @@ import { Pallet, Inventory, Warehouse, Location } from '../entities'
   (inventoryHistory: InventoryHistory) => [inventoryHistory.domain, inventoryHistory.name],
   { unique: true }
 )
-@Index(
-  'ix_inventory-history_1',
-  (inventoryHistory: InventoryHistory) => [inventoryHistory.domain, inventoryHistory.palletId],
-  { unique: false }
-)
+@Index('ix_inventory-history_1', (inventoryHistory: InventoryHistory) => [
+  inventoryHistory.domain,
+  inventoryHistory.palletId
+])
+@Index('ix_inventory-history_2', (inventoryHistory: InventoryHistory) => [
+  inventoryHistory.inventory,
+  inventoryHistory.transactionType,
+  inventoryHistory.refOrderId
+])
+@ObjectType()
 export class InventoryHistory {
   @PrimaryGeneratedColumn('uuid')
-  id: string
+  @Field(type => ID)
+  readonly id: string
 
   @Column({ default: 0 })
+  @Field()
   seq: number
 
   @ManyToOne(type => Domain)
+  @Field()
   domain: Domain
 
+  @RelationId((inventoryHistory: InventoryHistory) => inventoryHistory.domain)
+  domainId: string
+
   @ManyToOne(type => Bizplace)
+  @Field()
   bizplace: Bizplace
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   refOrderId: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   orderNo: string
 
   @Column()
+  @Field()
   name: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   palletId: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   cartonId: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   batchId: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   batchIdRef: string
 
   @ManyToOne(type => Pallet, { nullable: true })
+  @Field({ nullable: true })
   reusablePallet: Pallet
 
   @ManyToOne(type => Product, { nullable: true })
+  @Field(type => Product, { nullable: true })
   product: Product
 
   /**
    * To be updated to remove nullable. once all process that links to inventory has been updated to use product detail instead of product
    */
   @ManyToOne(type => ProductDetail, { nullable: true })
+  @Field(type => ProductDetail, { nullable: true })
   productDetail: ProductDetail
 
   @ManyToOne(type => Warehouse, { nullable: true })
+  @Field({ nullable: true })
   warehouse: Warehouse
 
   @ManyToOne(type => Location, { nullable: true })
+  @Field({ nullable: true })
   location: Location
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   zone: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   orderRefNo: string
 
   @Column()
+  @Field()
   packingType: string
 
   @Column('float', { nullable: true, default: 1 })
+  @Field({ nullable: true })
   packingSize: number
 
   @Column('float')
+  @Field({ nullable: true })
   qty: number
 
   @Column('float', { default: 0, nullable: true })
+  @Field({ nullable: true })
   openingQty: number
 
-  @Column('float', { nullable: true })
-  weight: number
-
-  @Column('float', { default: 0, nullable: true })
-  openingWeight: number
-
   @Column({ nullable: true })
+  @Field({ nullable: true })
   uom: string
 
   @Column('float', { nullable: true })
+  @Field({ nullable: true })
   uomValue: number
 
   @Column('float', { default: 0, nullable: true })
+  @Field({ nullable: true })
   openingUomValue: number
 
   @Column('float', { nullable: true })
+  @Field({ nullable: true })
   unitCost: number
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   description: string
 
   @Column()
+  @Field()
   status: string
 
   @Column()
-  transactionType: String
+  @Field()
+  transactionType: string
 
   @ManyToOne(type => Inventory, { nullable: true })
+  @Field(type => Inventory, { nullable: true })
   inventory: Inventory
 
   @Column('date', { nullable: true })
+  @Field({ nullable: true })
   expirationDate: Date
 
   @Column('int', { nullable: true })
+  @Field({ nullable: true })
   manufactureYear: number
 
   @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
   creator: User
 
+  @RelationId((inventoryHistory: InventoryHistory) => inventoryHistory.creator)
+  creatorId: string
+
   @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
   updater: User
 
+  @RelationId((inventoryHistory: InventoryHistory) => inventoryHistory.updater)
+  updaterId: string
+
   @CreateDateColumn()
+  @Field({ nullable: true })
   createdAt: Date
 
   @UpdateDateColumn()
+  @Field({ nullable: true })
   updatedAt: Date
 }

package/server/service/location/index.ts

@@ -0,0 +1,6 @@
+import { Location } from './location'
+import { LocationMutation } from './location-mutation'
+import { LocationQuery } from './location-query'
+
+export const entities = [Location]
+export const resolvers = [LocationQuery, LocationMutation]

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

@@ -0,0 +1,134 @@
+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 { Location } from '../location/location'
+import { Warehouse } from '../warehouse/warehouse'
+import { LocationPatch, NewLocation } from './location-types'
+
+@Resolver(Location)
+export class LocationMutation {
+  @Directive('@privilege(category: "warehouse", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Location)
+  async createLocation(@Arg('location') location: NewLocation, @Ctx() context: any): Promise<Location> {
+    return await createLocation(location, context)
+  }
+
+  @Directive('@privilege(category: "warehouse", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Location)
+  async updateLocation(
+    @Arg('id') id: string,
+    @Arg('patch') patch: LocationPatch,
+    @Ctx() context: any
+  ): Promise<Location> {
+    return await updateLocation(id, patch, context.state.user)
+  }
+
+  @Directive('@privilege(category: "warehouse", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => [Location])
+  async updateMultipleLocation(
+    @Arg('patches', type => [LocationPatch]) patches: LocationPatch[],
+    @Ctx() context: any
+  ): Promise<Location[]> {
+    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 createLocation(patch as NewLocation, context)
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const patch: LocationPatch = _updateRecords[i]
+        const result = await updateLocation(patch.id, patch, context)
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@privilege(category: "warehouse", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteLocation(@Arg('id') id: string, @Ctx() context: any): Promise<Boolean> {
+    return await deleteLocation(id, context)
+  }
+
+  @Directive('@privilege(category: "warehouse", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteLocations(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<Boolean> {
+    return await deleteLocations(ids, context)
+  }
+
+  @Directive('@privilege(category: "warehouse", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteAllLocations(@Arg('warehouseId') warehouseId: string, @Ctx() context: any) {
+    const { tx }: { tx: EntityManager } = context.state
+
+    await tx.getRepository(Location).delete({
+      warehouse: await tx.getRepository(Warehouse).findOne(warehouseId)
+    })
+  }
+}
+
+export async function createLocation(location: NewLocation, context: any) {
+  const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+  const locationRepository: Repository<Location> = tx.getRepository(Location)
+  const warehouseRepository: Repository<Warehouse> = tx.getRepository(Warehouse)
+
+  return await locationRepository.save({
+    ...location,
+    warehouse: await warehouseRepository.findOne(location.warehouse.id),
+    domain,
+    creator: user,
+    updater: user
+  })
+}
+
+export async function updateLocation(id: string, patch: LocationPatch, context: any) {
+  const { user, tx }: { user: User; tx: EntityManager } = context.state
+
+  const locationRepository: Repository<Location> = tx.getRepository(Location)
+  const warehouseRepository: Repository<Warehouse> = tx.getRepository(Warehouse)
+  const location: Location = await locationRepository.findOne(id)
+
+  if (patch.warehouse && patch.warehouse.id) {
+    patch.warehouse = await warehouseRepository.findOne(patch.warehouse.id)
+  }
+
+  return await locationRepository.save({
+    ...location,
+    ...patch,
+    updater: user
+  })
+}
+
+export async function deleteLocation(id: string, context: any) {
+  const { tx }: { tx: EntityManager } = context.state
+
+  const repository: Repository<Location> = tx.getRepository(Location)
+  await repository.delete(id)
+  return true
+}
+
+export async function deleteLocations(ids: string[], context: any) {
+  const { tx }: { tx: EntityManager } = context.state
+
+  const repository: Repository<Location> = tx.getRepository(Location)
+  await repository.delete(ids)
+  return true
+}