@things-factory/warehouse-base 3.7.13 → 3.8.1

package/server/{graphql/resolvers/inventory-change/approve-inventory-changes.ts → service/inventory-change/inventory-change-mutation.ts}

@@ -1,19 +1,236 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
 import { EntityManager, In, MoreThan, Not } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
 import { generateId } from '@things-factory/id-rule-base'
 import { MarketplaceStore } from '@things-factory/integration-marketplace'
 import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
+import { Product } from '@things-factory/product-base'
 import { PartnerSetting, Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
 
-import { INVENTORY_STATUS, LOCATION_STATUS } from '../../../constants'
-import { EcommerceController, SellercraftController } from '../../../controllers'
-import { Inventory, InventoryChange, InventoryHistory, Location } from '../../../entities'
-import { InventoryNoGenerator } from '../../../utils'
+import { INVENTORY_STATUS, LOCATION_STATUS } from '../../constants'
+import { EcommerceController, SellercraftController } from '../../controllers'
+import { InventoryNoGenerator } from '../../utils'
+import { InventoryHistory } from '../inventory-history/inventory-history'
+import { Inventory } from '../inventory/inventory'
+import { InventoryPatch } from '../inventory/inventory-types'
+import { Location } from '../location/location'
+import { InventoryChange } from './inventory-change'
+import { InventoryChangeList, InventoryChangePatch, NewInventoryChange } from './inventory-change-types'
+
+@Resolver(InventoryChange)
+export class InventoryChangeMutation {
+  @Directive('@transaction')
+  @Mutation(returns => InventoryChange)
+  async createInventoryChange(
+    @Arg('inventoryChange') inventoryChange: NewInventoryChange,
+    @Ctx() context: any
+  ): Promise<InventoryChange> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
 
-export const approveInventoryChanges = {
-  async approveInventoryChanges(_: any, { patches }, context: any) {
+    return await tx.getRepository(InventoryChange).save({
+      ...inventoryChange,
+      domain: domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => InventoryChange)
+  async updateInventoryChange(
+    @Arg('name') name: string,
+    @Arg('patch') patch: InventoryChangePatch,
+    @Ctx() context: any
+  ): Promise<InventoryChange> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+    const repository = tx.getRepository(InventoryChange)
+    const inventoryChange = await repository.findOne({
+      where: { domain: domain, name }
+    })
+
+    return await repository.save({
+      ...inventoryChange,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [InventoryChange])
+  async updateMultipleInventoryChange(
+    @Arg('patches', type => [InventoryChangePatch]) patches: InventoryChangePatch[],
+    @Ctx() context: any
+  ): Promise<InventoryChange[]> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const inventoryChangeRepo = tx.getRepository(InventoryChange)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await inventoryChangeRepo.save({
+          ...newRecord,
+          domain: 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 inventoryChange = await inventoryChangeRepo.findOne(newRecord.id)
+
+        const result = await inventoryChangeRepo.save({
+          ...inventoryChange,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteInventoryChange(@Arg('name') name: string, @Ctx() context: any): Promise<Boolean> {
+    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+
+    await tx.getRepository(InventoryChange).delete({ domain: domain, name })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteInventoryChanges(@Arg('names', type => [String]) names: string[], @Ctx() context: any): Promise<Boolean> {
+    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+
+    await tx.getRepository(InventoryChange).delete({
+      domain: domain,
+      name: In(names)
+    })
+    return true
+  }
+
+  @Directive('@privilege(category: "inventory", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async submitInventoryChanges(
+    @Arg('patches', type => [InventoryPatch]) patches: InventoryPatch[],
+    @Ctx() context: any
+  ) {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+    const _createRecords = patches.filter((patch: any) => !patch.id)
+    const _updateRecords = patches.filter((patch: any) => patch.id)
+
+    const inventoryChangeRepo = tx.getRepository(InventoryChange)
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        var location = await tx.getRepository(Location).findOne({
+          where: { id: newRecord.location.id },
+          relations: ['warehouse']
+        })
+        newRecord.location = location
+        newRecord.zone = location.zone
+        newRecord.warehouse = location.warehouse
+
+        newRecord.bizplace = await tx.getRepository(Bizplace).findOne(newRecord.bizplace.id)
+
+        var product: Product = await tx.getRepository(Product).findOne(newRecord.product.id)
+        newRecord.product = product
+
+        newRecord.status = 'PENDING'
+        newRecord.transactionType = 'NEW'
+
+        newRecord.expirationDate =
+          ((newRecord?.expirationDate && new Date(newRecord.expirationDate).getFullYear()) || 0) < 2000
+            ? null
+            : newRecord.expirationDate
+
+        await inventoryChangeRepo.save({
+          ...newRecord,
+          id: undefined,
+          name: InventoryNoGenerator.inventoryName(),
+          domain: domain,
+          creator: user,
+          updater: user
+        })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const updateRecord = _updateRecords[i]
+
+        let existingRecord = await tx.getRepository(Inventory).findOne({
+          where: { id: updateRecord.id },
+          relations: ['location', 'warehouse', 'product', 'bizplace']
+        })
+
+        if (!!updateRecord?.location?.id) {
+          var location = await tx.getRepository(Location).findOne({
+            where: { id: updateRecord.location.id },
+            relations: ['warehouse']
+          })
+          updateRecord.location = location
+          updateRecord.zone = location.zone
+          updateRecord.warehouse = location.warehouse
+        }
+
+        if (!!updateRecord?.bizplace?.id)
+          updateRecord.bizplace = await tx.getRepository(Bizplace).findOne(updateRecord.bizplace.id)
+
+        if (!!updateRecord?.product?.id)
+          updateRecord.product = await tx.getRepository(Product).findOne(updateRecord.product.id)
+
+        updateRecord.status = 'PENDING'
+        updateRecord.transactionType = 'CHANGES'
+
+        updateRecord.expirationDate =
+          ((updateRecord?.expirationDate && new Date(updateRecord.expirationDate).getFullYear()) || 0) < 2000
+            ? null
+            : updateRecord.expirationDate
+
+        await inventoryChangeRepo.save({
+          palletId: existingRecord.palletId,
+          ...updateRecord,
+          id: undefined,
+          name: InventoryNoGenerator.inventoryName(),
+          inventory: existingRecord,
+          domain: domain,
+          creator: user,
+          updater: user
+        })
+      }
+    }
+
+    return true
+  }
+
+  @Directive('@privilege(category: "inventory_adjustment_approval", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => InventoryChangeList)
+  async approveInventoryChanges(
+    @Arg('patches', type => [InventoryChangePatch]) patches: InventoryChangePatch[],
+    @Ctx() context: any
+  ): Promise<InventoryChangeList> {
     const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
 
     // Get Selected Inventory Change Data
@@ -415,6 +632,49 @@ export const approveInventoryChanges = {
 
     return { items: arrLockedInventory, total: arrLockedInventory.length }
   }
+
+  @Directive('@privilege(category: "inventory_adjustment_approval", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async rejectInventoryChanges(
+    @Arg('patches', type => [InventoryChangePatch]) patches: InventoryChangePatch[],
+    @Ctx() context: any
+  ): Promise<Boolean> {
+    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+
+    const _inventoryChanges = await tx.getRepository(InventoryChange).find({
+      where: { id: In(patches.map(item => item.id)) },
+      relations: [
+        'inventory',
+        'inventory.bizplace',
+        'inventory.product',
+        'inventory.location',
+        'inventory.warehouse',
+        'bizplace',
+        'product',
+        'location'
+      ]
+    })
+
+    if (_inventoryChanges.length > 0) {
+      for (let i = 0; i < _inventoryChanges.length; i++) {
+        if (_inventoryChanges[i].status.toLocaleLowerCase() != 'pending') return true
+        _inventoryChanges[i].status = 'REJECTED'
+
+        // Get last row of InventoryHistory
+        let latestEntry = await tx.getRepository(InventoryHistory).find({
+          where: { palletId: _inventoryChanges[i].palletId, domain: domain },
+          order: { seq: 'DESC' },
+          take: 1
+        })
+
+        if (latestEntry.length > 0) _inventoryChanges[i].lastInventoryHistory = latestEntry[0]
+      }
+
+      await tx.getRepository(InventoryChange).save(_inventoryChanges.filter(change => change.status == 'REJECTED'))
+    }
+    return true
+  }
 }
 
 function clean(obj) {

package/server/{graphql/resolvers/inventory-change/inventory-changes.ts → service/inventory-change/inventory-change-query.ts}

@@ -1,11 +1,27 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { Brackets, getRepository, SelectQueryBuilder } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Bizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
 import { buildQuery, Domain, ListParam } from '@things-factory/shell'
-import { Brackets, getRepository, SelectQueryBuilder } from 'typeorm'
-import { InventoryChange } from '../../../entities'
 
-export const inventoryChangesResolver = {
-  async inventoryChanges(_: any, params: ListParam, context: any) {
+import { InventoryChange } from './inventory-change'
+import { InventoryChangeList } from './inventory-change-types'
+
+@Resolver(InventoryChange)
+export class InventoryChangeQuery {
+  @Query(returns => InventoryChange)
+  async inventoryChange(@Arg('name') name: string, @Ctx() context: any): Promise<InventoryChange> {
+    const { domain }: { domain: Domain } = context.state
+
+    return await getRepository(InventoryChange).findOne({
+      where: { domain: domain, name },
+      relations: ['domain', 'creator', 'updater']
+    })
+  }
+
+  @Query(returns => InventoryChangeList)
+  async inventoryChanges(@Args() params: ListParam, @Ctx() context: any): Promise<InventoryChangeList> {
     const { domain, user }: { domain: Domain; user: User } = context.state
 
     let bizplaces: Bizplace[]
@@ -51,4 +67,19 @@ export const inventoryChangesResolver = {
 
     return { items, total }
   }
+
+  @FieldResolver(type => InventoryChange)
+  async domain(@Root() inventoryChange: InventoryChange) {
+    return await getRepository(Domain).findOne(inventoryChange.domainId)
+  }
+
+  @FieldResolver(type => InventoryChange)
+  async updater(@Root() inventoryChange: InventoryChange) {
+    return await getRepository(User).findOne(inventoryChange.updaterId)
+  }
+
+  @FieldResolver(type => InventoryChange)
+  async creator(@Root() inventoryChange: InventoryChange) {
+    return await getRepository(User).findOne(inventoryChange.creatorId)
+  }
 }

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

@@ -0,0 +1,36 @@
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+
+import { InventoryChange } from './inventory-change'
+
+@ObjectType()
+export class InventoryChangeList {
+  @Field(type => [InventoryChange], { nullable: true })
+  items?: InventoryChange[]
+
+  @Field(type => Int, { nullable: true })
+  total?: number
+}
+
+@InputType()
+export class InventoryChangePatch {
+  @Field({ nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@InputType()
+export class NewInventoryChange {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+}

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

@@ -1,101 +1,155 @@
+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 { Location } from './location'
-import { Inventory } from './inventory'
-import { InventoryHistory } from './inventory-history'
+import { Domain, ScalarDate } from '@things-factory/shell'
+
+import { InventoryHistory } from '../inventory-history/inventory-history'
+import { Inventory } from '../inventory/inventory'
+import { Location } from '../location/location'
 
 @Entity()
 @Index('ix_inventory-change_0', (inventoryChange: InventoryChange) => [inventoryChange.domain, inventoryChange.id], {
   unique: true
 })
+@Index('ix_inventory-change_1', (inventoryChange: InventoryChange) => [
+  inventoryChange.domain,
+  inventoryChange.inventory
+])
+@ObjectType()
 export class InventoryChange {
   @PrimaryGeneratedColumn('uuid')
-  id: string
+  @Field(type => ID)
+  readonly id: string
 
   @Column()
+  @Field()
   name: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   palletId: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   cartonId: string
 
   @ManyToOne(type => Domain)
+  @Field()
   domain: Domain
 
+  @RelationId((inventoryChange: InventoryChange) => inventoryChange.domain)
+  domainId: string
+
   @Column({ nullable: true })
+  @Field({ nullable: true })
   batchId: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   batchIdRef: string
 
   @ManyToOne(type => Bizplace, { nullable: true })
+  @Field({ nullable: true })
   bizplace: Bizplace
 
   @ManyToOne(type => Inventory, { nullable: true })
+  @Field(type => Inventory, { nullable: true })
   inventory: Inventory
 
   @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 => Location, { nullable: true })
+  @Field(type => Location, { nullable: true })
   location: Location
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   packingType: string
 
   @Column('float', { nullable: true })
+  @Field({ nullable: true })
   packingSize: number
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   uom: string
 
   @Column('float', { nullable: true })
+  @Field({ nullable: true })
   weight: number
 
   @Column('float', { nullable: true })
+  @Field({ nullable: true })
   uomValue: number
 
   @Column('float', { nullable: true })
+  @Field({ nullable: true })
   qty: number
 
   @Column('float', { nullable: true })
+  @Field({ nullable: true })
   unitCost: number
 
   @Column()
+  @Field()
   status: string
 
   @ManyToOne(type => InventoryHistory, { nullable: true })
+  @Field({ nullable: true })
   lastInventoryHistory: InventoryHistory
 
   @Column('date', { nullable: true })
+  @Field(type => ScalarDate, { nullable: true })
   expirationDate: Date
 
   @Column('int', { nullable: true })
+  @Field({ nullable: true })
   manufactureYear: number
 
   @Column()
+  @Field()
   transactionType: string
 
   @CreateDateColumn()
+  @Field({ nullable: true })
   createdAt: Date
 
   @UpdateDateColumn()
+  @Field({ nullable: true })
   updatedAt: Date
 
   @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
   creator: User
 
+  @RelationId((inventoryChange: InventoryChange) => inventoryChange.creator)
+  creatorId: string
+
   @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
   updater: User
+
+  @RelationId((inventoryChange: InventoryChange) => inventoryChange.updater)
+  updaterId: string
 }

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

@@ -0,0 +1,6 @@
+import { InventoryHistory } from './inventory-history'
+import { InventoryHistoryMutation } from './inventory-history-mutation'
+import { InventoryHistoryQuery } from './inventory-history-query'
+
+export const entities = [InventoryHistory]
+export const resolvers = [InventoryHistoryQuery, InventoryHistoryMutation]

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

@@ -0,0 +1,119 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, In } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { InventoryHistory } from './inventory-history'
+import { InventoryHistoryPatch, NewInventoryHistory } from './inventory-history-types'
+
+@Resolver(InventoryHistory)
+export class InventoryHistoryMutation {
+  @Directive('@transaction')
+  @Mutation(returns => InventoryHistory)
+  async createInventoryHistory(
+    @Arg('inventoryHistory') inventoryHistory: NewInventoryHistory,
+    @Ctx() context: any
+  ): Promise<InventoryHistory> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+    return await tx.getRepository(InventoryHistory).save({
+      ...inventoryHistory,
+      domain: domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => InventoryHistory)
+  async updateInventoryHistory(
+    @Arg('name') name: string,
+    @Arg('patch') patch: InventoryHistoryPatch,
+    @Ctx() context: any
+  ): Promise<InventoryHistory> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+    const repository = tx.getRepository(InventoryHistory)
+    const inventoryHistory = await repository.findOne({
+      where: { domain: domain, name }
+    })
+
+    return await repository.save({
+      ...inventoryHistory,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [InventoryHistory])
+  async updateMultipleInventoryHistory(
+    @Arg('patches', type => [InventoryHistoryPatch]) patches: InventoryHistoryPatch[],
+    @Ctx() context: any
+  ): Promise<InventoryHistory[]> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const inventoryHistoryRepo = tx.getRepository(InventoryHistory)
+
+    if (_createRecords.length > 0) {
+      let newRecord: NewInventoryHistory = new InventoryHistory()
+      for (let i = 0; i < _createRecords.length; i++) {
+        newRecord = _createRecords[i]
+      }
+
+      const result = await inventoryHistoryRepo.save({
+        ...newRecord,
+        domain: 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 inventoryHistory = await inventoryHistoryRepo.findOne(newRecord.id)
+
+        const result = await inventoryHistoryRepo.save({
+          ...inventoryHistory,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteInventoryHistory(@Arg('name') name: string, @Ctx() context: any): Promise<Boolean> {
+    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+
+    await tx.getRepository(InventoryHistory).delete({ domain: domain, name })
+    return true
+  }
+
+  @Directive('transaction')
+  @Mutation(returns => Boolean)
+  async deleteInventoryHistories(
+    @Arg('names', type => [String]) names: string[],
+    @Ctx() context: any
+  ): Promise<Boolean> {
+    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+
+    await tx.getRepository(InventoryHistory).delete({
+      domain: domain,
+      name: In(names)
+    })
+    return true
+  }
+}