@things-factory/warehouse-base 8.0.0-beta.8 → 8.0.0

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

@@ -0,0 +1,134 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { Repository } from 'typeorm'
+
+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: ResolverContext): 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: ResolverContext
+  ): Promise<Location> {
+    return await updateLocation(id, patch, context)
+  }
+
+  @Directive('@privilege(category: "warehouse", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => [Location])
+  async updateMultipleLocation(
+    @Arg('patches', type => [LocationPatch]) patches: LocationPatch[],
+    @Ctx() context: ResolverContext
+  ): 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: ResolverContext): 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: ResolverContext
+  ): 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: ResolverContext) {
+    const { tx } = context.state
+
+    await tx.getRepository(Location).delete({
+      warehouse: { id: warehouseId }
+    })
+  }
+}
+
+export async function createLocation(location: NewLocation, context: ResolverContext): Promise<Location> {
+  const { domain, user, tx } = context.state
+
+  const locationRepository: Repository<Location> = tx.getRepository(Location)
+  const warehouseRepository: Repository<Warehouse> = tx.getRepository(Warehouse)
+
+  return await locationRepository.save({
+    ...location,
+    warehouse: await warehouseRepository.findOneBy({ id: location.warehouse.id }),
+    domain,
+    creator: user,
+    updater: user
+  })
+}
+
+export async function updateLocation(id: string, patch: LocationPatch, context: ResolverContext): Promise<Location> {
+  const { user, tx } = context.state
+
+  const locationRepository: Repository<Location> = tx.getRepository(Location)
+  const warehouseRepository: Repository<Warehouse> = tx.getRepository(Warehouse)
+  const location: Location = await locationRepository.findOneBy({ id })
+
+  if (patch.warehouse && patch.warehouse.id) {
+    patch.warehouse = await warehouseRepository.findOneBy({ id: patch.warehouse.id })
+  }
+
+  return await locationRepository.save({
+    ...location,
+    ...patch,
+    updater: user
+  })
+}
+
+export async function deleteLocation(id: string, context: ResolverContext) {
+  const { tx } = context.state
+
+  const repository: Repository<Location> = tx.getRepository(Location)
+  await repository.delete(id)
+  return true
+}
+
+export async function deleteLocations(ids: string[], context: ResolverContext) {
+  const { tx } = context.state
+
+  const repository: Repository<Location> = tx.getRepository(Location)
+  await repository.delete(ids)
+  return true
+}

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

@@ -0,0 +1,244 @@
+import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+
+import { User } from '@things-factory/auth-base'
+import { getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { buildQuery, Domain, getQueryBuilderFromListParams, getRepository, 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", domainOwnerGranted: true)')
+  @Query(returns => LocationList)
+  async locations(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<LocationList> {
+    const queryBuilder = getQueryBuilderFromListParams({
+      repository: getRepository(Location),
+      params,
+      domain: context.state.domain,
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  /**
+   * @description this resolver was specially made to return huge locations data
+   * without dropping off performance due to typegraphql limitations
+   * @returns pure location data only. there will be no other table joined to avoid
+   * ORM lagging issue (converting to object extremely withdraws the performance)
+   * */
+  @Directive('@privilege(category: "warehouse", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => LocationList)
+  async pureLocations(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<LocationList> {
+    const queryBuilder = getRepository(Location).createQueryBuilder('location')
+    buildQuery(queryBuilder, params, context)
+    const items = await queryBuilder.getRawMany()
+    const total = await queryBuilder.getCount()
+
+    return { items: items.map(item => new Location(item)), total }
+  }
+
+  @Directive('@privilege(category: "warehouse", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => LocationOccupancy)
+  async locationOccupancies(
+    @Arg('warehouse') warehouse: string,
+    @Arg('types', type => [String], { nullable: true }) types: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<LocationOccupancy> {
+    const { domain } = context.state
+
+    const foundWarehouse: Warehouse = await getRepository(Warehouse).findOne({
+      where: {
+        domain: { id: domain.id },
+        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", domainOwnerGranted: true)')
+  @Query(returns => Location)
+  async location(@Arg('name') name: string, @Ctx() context: ResolverContext): 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", domainOwnerGranted: true)')
+  @Query(returns => Location)
+  async locationByName(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Location> {
+    const { domain } = context.state
+
+    return await getRepository(Location).findOne({
+      where: {
+        domain: { id: domain.id },
+        name
+      },
+      relations: ['domain', 'warehouse', 'creator', 'updater']
+    })
+  }
+
+  @Directive('@privilege(category: "warehouse", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => LocationList)
+  async locationsByGroup(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<LocationList> {
+    const { 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", domainOwnerGranted: true)')
+  @Query(returns => LocationInventories)
+  async locationWithInventories(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<LocationInventories> {
+    const { domain, user } = context.state
+    const bizplaceIds = await getPermittedBizplaceIds(domain, user)
+    const queryBuilder = getRepository(Location).createQueryBuilder()
+
+    const warehouseNames = params.filters.find(
+      x => x.name === 'warehouseNames' && x.operator.toLowerCase() === 'in'
+    )?.value
+
+    const locationTypes = params.filters.find(
+      x => x.name === 'locationTypes' && x.operator.toLowerCase() === 'in'
+    )?.value
+
+    params.filters = []
+    buildQuery(queryBuilder, params, context)
+
+    queryBuilder
+      .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')
+      .addSelect('SUM("Inventory"."qty") OVER(PARTITION BY "Location"."id")', 'accumulate_qty')
+      .where('Location.domain_id = :domainId', { domainId: domain.id })
+
+    if (warehouseNames) {
+      queryBuilder.andWhere('Warehouse.name IN (:...warehouseNames)', { warehouseNames: [...new Set(warehouseNames)] })
+    }
+
+    if (locationTypes) {
+      queryBuilder.andWhere('Location.type ILIKE ANY (ARRAY[:...locationTypes])', {
+        locationTypes: [...new Set(locationTypes)]
+      })
+    }
+
+    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,
+        accumulatedQty: item.accumulate_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
+          ? new Date(item.Inventory_expiration_date).toISOString().split('T')[0].split('-').reverse().join('-')
+          : '',
+        warehouse: {
+          name: item.Warehouse_name,
+          description: item.Warehouse_description,
+          type: item.Warehouse_type
+        },
+        zone: item.Location_zone
+      }
+    })
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() location: Location) {
+    return await getRepository(Domain).findOneBy({ id: location.domain?.id })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() location: Location) {
+    return await getRepository(User).findOneBy({ id: location.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() location: Location) {
+    return await getRepository(User).findOneBy({ id: location.creatorId })
+  }
+
+  @FieldResolver(type => Warehouse)
+  async warehouse(@Root() location: Location): Promise<Warehouse> {
+    return await getRepository(Warehouse).findOneBy({ id: location.warehouse?.id })
+  }
+}

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

@@ -0,0 +1,173 @@
+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 { 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(type => Product, { nullable: true })
+  product?: Product
+
+  @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/service/location/location.ts

@@ -0,0 +1,121 @@
+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 { Warehouse } from '../warehouse/warehouse'
+
+@Entity()
+@Index('ix_location_0', (location: Location) => [location.domain, location.name], { unique: true })
+@Index('ix_location_1', (location: Location) => [location.id], { unique: true })
+@Index('ix_location_2', (location: Location) => [location.domain])
+@Index('ix_location_3', (location: Location) => [location.domain, location.name, location.type])
+@ObjectType()
+export class Location {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain)
+  domain: Domain
+
+  @RelationId((location: Location) => location.domain)
+  domainId: string
+
+  @ManyToOne(type => Warehouse, warehouse => warehouse.locations, {
+    nullable: false
+  })
+  @Field(type => Warehouse, { nullable: true })
+  warehouse: Warehouse
+
+  @RelationId((location: Location) => location.warehouse)
+  warehouseId: string
+
+  @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
+
+  constructor(obj?) {
+    if (obj) {
+      this.id = obj.location_id
+      this.name = obj.location_name
+      this.description = obj.location_description
+      this.type = obj.location_type
+      this.zone = obj.location_zone
+      this.row = obj.location_row
+      this.column = obj.location_column
+      this.shelf = obj.location_shelf
+      this.status = obj.location_status
+      this.updatedAt = obj.location_updated_at
+    }
+  }
+}

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]