@things-factory/warehouse-base 8.0.3 → 8.0.6

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

@@ -1,134 +0,0 @@
-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

@@ -1,244 +0,0 @@
-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

@@ -1,173 +0,0 @@
-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

@@ -1,121 +0,0 @@
-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

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