@things-factory/warehouse-base 3.7.13 → 3.8.1

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

@@ -0,0 +1,209 @@
+import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { buildQuery, Domain, ListParam } from '@things-factory/shell'
+
+import { INVENTORY_STATUS } from '../../constants/inventory'
+import { Warehouse } from '../warehouse/warehouse'
+import { Location } from './location'
+import { LocationInventories, LocationList, LocationOccupancy } from './location-types'
+
+@Resolver(Location)
+export class LocationQuery {
+  @Directive('@privilege(category: "warehouse", privilege: "query")')
+  @Query(returns => LocationList)
+  async locations(@Args() params: ListParam, @Ctx() context: any): Promise<LocationList> {
+    const queryBuilder = getRepository(Location).createQueryBuilder()
+    buildQuery(queryBuilder, params, context)
+    const [items, total] = await queryBuilder
+      .leftJoinAndSelect('Location.domain', 'Domain')
+      .leftJoinAndSelect('Location.warehouse', 'Warehouse')
+      .leftJoinAndSelect('Location.creator', 'Creator')
+      .leftJoinAndSelect('Location.updater', 'Updater')
+      .getManyAndCount()
+
+    return { items, total }
+  }
+
+  @Directive('@privilege(category: "warehouse", privilege: "query")')
+  @Query(returns => LocationOccupancy)
+  async locationOccupancies(
+    @Arg('warehouse') warehouse: string,
+    @Arg('types', type => [String], { nullable: true }) types: string[],
+    @Ctx() context: any
+  ): Promise<LocationOccupancy> {
+    const { domain }: { domain: Domain } = context.state
+
+    const foundWarehouse: Warehouse = await getRepository(Warehouse).findOne({
+      where: {
+        domain,
+        name: warehouse
+      },
+      relations: ['locations']
+    })
+
+    if (!foundWarehouse) throw new Error(`${warehouse} was not found!`)
+
+    const locations: Location[] =
+      types && types.length
+        ? foundWarehouse?.locations?.filter((location: Location) => types.indexOf(location.type) !== -1)
+        : foundWarehouse?.locations
+
+    const total: number = locations.length
+    const occupied: number = locations.filter((location: Location) => location.status === 'OCCUPIED')?.length || 0
+    const empty: number = total - occupied
+    const percentage: number = occupied > 0 ? Math.round((occupied / total) * 100) : 0
+
+    return { total, occupied, empty, percentage }
+  }
+
+  @Directive('@privilege(category: "warehouse", privilege: "query")')
+  @Query(returns => Location)
+  async location(@Arg('name') name: string, @Ctx() context: any): Promise<Location> {
+    const foundLocation: Location | null = await getRepository(Location).findOne({
+      where: { name },
+      relations: ['domain', 'warehouse', 'creator', 'updater']
+    })
+    if (!foundLocation) throw new Error(context.t('error.no_location_found'))
+
+    return foundLocation
+  }
+
+  @Directive('@privilege(category: "warehouse", privilege: "query")')
+  @Query(returns => Location)
+  async locationByName(@Arg('name') name: string, @Ctx() context: any): Promise<Location> {
+    const { domain }: { domain: Domain } = context.state
+
+    return await getRepository(Location).findOne({
+      where: {
+        domain: domain,
+        name
+      },
+      relations: ['domain', 'warehouse', 'creator', 'updater']
+    })
+  }
+
+  @Directive('@privilege(category: "warehouse", privilege: "query")')
+  @Query(returns => LocationList)
+  async locationsByGroup(@Args() params: ListParam, @Ctx() context: any): Promise<LocationList> {
+    const { domain }: { domain: Domain } = context.state
+    const warehouseIdParam = params.filters.find(param => (param.name = 'warehouse_id'))
+
+    if (!warehouseIdParam.value) throw new Error(`invalid warehouse ID`)
+
+    const items = await getRepository(Location).query(`
+      SELECT CONCAT("zone",'-',"row",'-',"column") as name, "zone", "row", "column"
+      FROM locations WHERE domain_id = '${domain.id}'
+      AND warehouse_id = '${warehouseIdParam.value}'
+      GROUP BY "zone", "row", "column"
+    `)
+
+    let [{ total }] = await getRepository(Location).query(`
+      SELECT COUNT(DISTINCT("zone", "row", "column")) as total
+      FROM locations WHERE domain_id = '${domain.id}'
+      AND warehouse_id = '${warehouseIdParam.value}'
+    `)
+
+    total = parseInt(total)
+
+    return { items, total }
+  }
+
+  @Directive('@privilege(category: "warehouse", privilege: "query")')
+  @Query(returns => LocationInventories)
+  async locationWithInventories(@Args() params: ListParam, @Ctx() context: any): Promise<LocationInventories> {
+    const { domain, user }: { domain: Domain; user: User } = context.state
+    const bizplaceIds = await getPermittedBizplaceIds(domain, user)
+    const queryBuilder = getRepository(Location).createQueryBuilder()
+
+    const warehouseName = params.filters.find(x => x.name === 'warehouseName' && x.operator.toLowerCase() === 'eq')
+      ?.value
+
+    params.filters = []
+    buildQuery(queryBuilder, params, context)
+
+    queryBuilder
+      .innerJoinAndSelect('Location.domain', 'Domain')
+      .leftJoinAndSelect('Location.warehouse', 'Warehouse')
+      .leftJoinAndSelect(
+        'inventories',
+        'Inventory',
+        'Location.id = Inventory.location_id AND Inventory.status = :InvStatus',
+        {
+          InvStatus: INVENTORY_STATUS.STORED
+        }
+      )
+      .leftJoinAndSelect('Inventory.product', 'Product')
+      .leftJoinAndSelect('Inventory.bizplace', 'Bizplace', 'Bizplace.id IN (:...bizplaceIds)', {
+        bizplaceIds: [...new Set(bizplaceIds)]
+      })
+      .leftJoinAndSelect('Inventory.creator', 'Creator')
+      .leftJoinAndSelect('Inventory.updater', 'Updater')
+
+    if (warehouseName) {
+      queryBuilder.andWhere('Warehouse.name = :warehouseName', { warehouseName })
+    }
+
+    let items = await queryBuilder.getRawMany()
+    const total = await queryBuilder.getCount()
+
+    items = items
+      .map(item => {
+        return {
+          id: item.Location_id,
+          name: item.Location_name,
+          bizplace: {
+            name: item.Bizplace_name || '',
+            description: item.Bizplace_description || ''
+          },
+          product: {
+            name: item.Product_name || '',
+            sku: item.Product_sku || '',
+            description: item.Product_description || ''
+          },
+          palletId: item.Inventory_pallet_id || '',
+          batchId: item.Inventory_batch_id || '',
+          qty: item.Inventory_qty || 0,
+          uomValue: item.Inventory_uom_value || 0.0,
+          uom: item.Inventory_uom || '',
+          packingType: item.Inventory_packing_type || '',
+          packingSize: item.Inventory_packing_size || 0.0,
+          expirationDate: item.Inventory_expiration_date || '',
+          warehouse: item.Warehouse_name,
+          zone: item.Location_zone
+        }
+      })
+      .reduce((acc, curr) => {
+        acc.push(curr)
+
+        const accQty: number =
+          curr.palletId !== '' ? acc.filter(x => x.id === curr.id).reduce((x, y) => (x += y.qty), 0) : 0
+
+        acc = acc.map(x => {
+          if (x.id === curr.id) return { ...x, accumulatedQty: accQty }
+          else return { ...x }
+        })
+
+        return acc
+      }, [])
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() location: Location) {
+    return await getRepository(Domain).findOne(location.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() location: Location) {
+    return await getRepository(User).findOne(location.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() location: Location) {
+    return await getRepository(User).findOne(location.creatorId)
+  }
+}

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

@@ -0,0 +1,169 @@
+import { Field, Float, InputType, Int, ObjectType } from 'type-graphql'
+
+import { Bizplace } from '@things-factory/biz-base'
+import { ObjectRef } from '@things-factory/shell'
+
+import { Warehouse } from '../warehouse/warehouse'
+import { Location } from './location'
+
+@ObjectType()
+export class LocationInventory {
+  @Field({ nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field(type => Bizplace, { nullable: true })
+  bizplace?: Bizplace
+
+  @Field({ nullable: true })
+  palletId?: string
+
+  @Field({ nullable: true })
+  batchId?: string
+
+  @Field(type => Int, { nullable: true })
+  qty?: number
+
+  @Field(type => Int, { nullable: true })
+  accumulatedQty?: number
+
+  @Field(type => Float, { nullable: true })
+  uomValue?: number
+
+  @Field({ nullable: true })
+  uom?: string
+
+  @Field({ nullable: true })
+  packingType?: string
+
+  @Field(type => Float, { nullable: true })
+  packingSize?: number
+
+  @Field({ nullable: true })
+  expirationDate?: string
+
+  @Field(type => Warehouse, { nullable: true })
+  warehouse?: Warehouse
+
+  @Field({ nullable: true })
+  zone?: string
+}
+
+@ObjectType()
+export class LocationInventories {
+  @Field(type => [LocationInventory], { nullable: true })
+  items?: LocationInventory[]
+
+  @Field(type => Int, { nullable: true })
+  total?: number
+}
+
+@ObjectType()
+export class LocationList {
+  @Field(type => [Location], { nullable: true })
+  items?: Location[]
+
+  @Field(type => Int, { nullable: true })
+  total?: number
+}
+
+@ObjectType()
+export class LocationOccupancy {
+  @Field(type => Int, { nullable: true })
+  total?: number
+
+  @Field(type => Int, { nullable: true })
+  occupied?: number
+
+  @Field(type => Int, { nullable: true })
+  empty?: number
+
+  @Field(type => Int, { nullable: true })
+  percentage?: number
+}
+
+@InputType()
+export class LocationPatch {
+  @Field({ nullable: true })
+  id?: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  warehouse?: ObjectRef
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  type?: string
+
+  @Field({ nullable: true })
+  zone?: string
+
+  @Field({ nullable: true })
+  firstDelimiter?: string
+
+  @Field({ nullable: true })
+  secondDelimiter?: string
+
+  @Field({ nullable: true })
+  thirdDelimiter?: string
+
+  @Field({ nullable: true })
+  row?: string
+
+  @Field({ nullable: true })
+  column?: string
+
+  @Field({ nullable: true })
+  shelf?: string
+
+  @Field({ nullable: true })
+  status?: string
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@InputType()
+export class NewLocation {
+  @Field(type => ObjectRef, { nullable: true })
+  warehouse?: ObjectRef
+
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  type?: string
+
+  @Field()
+  zone: string
+
+  @Field({ nullable: true })
+  firstDelimiter?: string
+
+  @Field({ nullable: true })
+  secondDelimiter?: string
+
+  @Field({ nullable: true })
+  thirdDelimiter?: string
+
+  @Field()
+  row: string
+
+  @Field()
+  column: string
+
+  @Field()
+  shelf: string
+
+  @Field()
+  status: string
+}

package/server/{entities → service/location}/location.ts

@@ -1,64 +1,101 @@
+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 { Domain } from '@things-factory/shell'
-import { Column, CreateDateColumn, Entity, Index, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm'
-import { Warehouse } from './warehouse'
+
+import { Warehouse } from '../warehouse/warehouse'
 
 @Entity()
 @Index('ix_location_0', (location: Location) => [location.domain, location.name], { unique: true })
 @Index('ix_location_1', (location: Location) => [location.domain, location.id], { unique: true })
+@ObjectType()
 export class Location {
   @PrimaryGeneratedColumn('uuid')
-  id: string
+  @Field(type => ID)
+  readonly id: string
 
   @ManyToOne(type => Domain)
+  @Field()
   domain: Domain
 
+  @RelationId((location: Location) => location.domain)
+  domainId: string
+
   @ManyToOne(type => Warehouse, warehouse => warehouse.locations, {
     nullable: false
   })
+  @Field(type => Warehouse, { nullable: true })
   warehouse: Warehouse
 
-  @Column()
+  @Column({ nullable: true })
+  @Field({ nullable: true })
   name: string
 
   @Column({
     nullable: true
   })
+  @Field({ nullable: true })
   description: string
 
   @Column({
     nullable: true
   })
+  @Field({ nullable: true })
   type: string
 
   @Column()
+  @Field()
   zone: string
 
   @Column()
+  @Field()
   row: string
 
   @Column()
+  @Field()
   column: string
 
   @Column()
+  @Field()
   shelf: string
 
   @Column({ type: 'text', comment: 'occupied, hold, empty' })
+  @Field()
   status: string
 
   @ManyToOne(type => User, {
     nullable: true
   })
+  @Field({ nullable: true })
   creator: User
 
+  @RelationId((location: Location) => location.creator)
+  creatorId: string
+
   @ManyToOne(type => User, {
     nullable: true
   })
+  @Field({ nullable: true })
   updater: User
 
+  @RelationId((location: Location) => location.updater)
+  updaterId: string
+
   @CreateDateColumn()
+  @Field({ nullable: true })
   createdAt: Date
 
   @UpdateDateColumn()
+  @Field({ nullable: true })
   updatedAt: Date
 }

package/server/service/movement/index.ts

@@ -0,0 +1,6 @@
+import { Movement } from './movement'
+import { MovementMutation } from './movement-mutation'
+import { MovementQuery } from './movement-query'
+
+export const entities = [Movement]
+export const resolvers = [MovementQuery, MovementMutation]

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

@@ -0,0 +1,61 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { getRepository, In } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+
+import { Inventory } from '../inventory/inventory'
+import { Movement } from './movement'
+import { MovementPatch, NewMovement } from './movement-types'
+
+@Resolver(Movement)
+export class MovementMutation {
+  @Directive('@privilege(category: "movement", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Movement)
+  async createMovement(@Arg('movement') movement: NewMovement, @Ctx() context: any): Promise<Movement> {
+    const { domain, user }: { domain: Domain; user: User } = context.state
+    return await getRepository(Movement).save({
+      ...movement,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@privilege(category: "movement", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Movement)
+  async updateMovement(
+    @Arg('id') id: string,
+    @Arg('patch') patch: MovementPatch,
+    @Ctx() context: any
+  ): Promise<Movement> {
+    const movement = await getRepository(Movement).findOne({
+      where: {
+        domain: context.state.domain,
+        id,
+        bizplace: In(await getPermittedBizplaceIds(context.state.domain, context.state.user))
+      }
+    })
+
+    if (patch.inventory && patch.inventory.id) {
+      patch.inventory = await getRepository(Inventory).findOne(patch.inventory.id)
+    }
+
+    return await getRepository(Movement).save({
+      ...movement,
+      ...patch,
+      updater: context.state.user
+    })
+  }
+
+  @Directive('@privilege(category: "movement", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteMovement(@Arg('name') name: string, @Ctx() context: any): Promise<Boolean> {
+    await getRepository(Movement).delete(name)
+    return true
+  }
+}