@things-factory/warehouse-base 3.7.13 → 3.8.1

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

@@ -0,0 +1,258 @@
+import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository, In } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { convertListParams, Domain, ListParam } from '@things-factory/shell'
+
+import { InventoryHistory } from '../inventory-history/inventory-history'
+import { Movement } from './movement'
+import { MovementCount, MovementList } from './movement-types'
+
+@Resolver(Movement)
+export class MovementQuery {
+  @Directive('@privilege(category: "movement", privilege: "query")')
+  @Query(returns => MovementList)
+  async movements(@Args() params: ListParam, @Ctx() context: any): Promise<MovementList> {
+    const convertedParams = convertListParams(params)
+    convertedParams.where.bizplace = In(await getPermittedBizplaceIds(context.state.domain, context.state.user))
+
+    const [items, total] = await getRepository(Movement).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'bizplace', 'inventory', 'creator', 'updater']
+    })
+    return { items, total }
+  }
+
+  @Directive('@privilege(category: "movement", privilege: "query")')
+  @Query(returns => Movement)
+  async movement(@Arg('name') name: string, @Ctx() context: any): Promise<Movement> {
+    return await getRepository(Movement).findOne({
+      where: {
+        domain: context.state.domain,
+        name,
+        bizplace: In(await getPermittedBizplaceIds(context.state.domain, context.state.user))
+      },
+      relations: ['domain', 'bizplace', 'inventory', 'creator', 'updater']
+    })
+  }
+
+  @Query(returns => [MovementCount])
+  async inboundMovementsCounter(@Args() params: ListParam, @Ctx() context: any): Promise<MovementCount[]> {
+    const { domain, user }: { domain: Domain; user: User } = context.state
+
+    let bizplaces = await getPermittedBizplaceIds(domain, user)
+    bizplaces = bizplaces
+      .map(bizplace => {
+        return "'" + bizplace.trim() + "'"
+      })
+      .join(',')
+
+    let startDate = new Date()
+    let endDate = new Date()
+    startDate.setDate(startDate.getDate() - 30)
+    startDate.setHours(0)
+    startDate.setMinutes(0)
+    startDate.setSeconds(0)
+    const timeNow = `${endDate.getHours()}:${endDate.getMinutes()}:${endDate.getSeconds()}`
+
+    const counter = await getRepository(InventoryHistory).query(`
+      select inbound_date, count(*) from(
+        select date(ih.created_at) inbound_date from inventory_histories ih
+        where ih.bizplace_id in (${bizplaces})
+        and ih.transaction_type in ('NEW', 'PUTAWAY')
+        and created_at between '${startDate.toLocaleDateString()} 00:00:00' and '${endDate.toLocaleDateString()} ${timeNow}'
+        and domain_id = '${domain.id}'
+      ) as foo
+      group by inbound_date
+      order by inbound_date asc
+    `)
+
+    let items = []
+    for (let i = 0; i < 30; i++) {
+      const month = startDate.toLocaleString('default', { month: 'short' })
+      const day = startDate.getDate()
+
+      items.push({
+        date: `${month} ${day.toString().padStart(2, '0')}`,
+        count: '0'
+      })
+      startDate.setDate(startDate.getDate() + 1)
+    }
+
+    let compareDate = new Date()
+    compareDate.setDate(compareDate.getDate() - 30)
+    compareDate.setHours(0)
+    compareDate.setMinutes(0)
+    compareDate.setSeconds(0)
+
+    items = items.map((item: { date: string; count: number }) => {
+      item.count =
+        counter.find(ctr => ctr.inbound_date.toLocaleDateString() === compareDate.toLocaleDateString())?.count || 0
+
+      compareDate.setDate(compareDate.getDate() + 1)
+
+      return item
+    })
+
+    return items
+  }
+
+  @Query(returns => [MovementCount])
+  async outboundMovementsCounter(@Args() params: ListParam, @Ctx() context: any): Promise<MovementCount[]> {
+    const { domain, user }: { domain: Domain; user: User } = context.state
+
+    let bizplaces = await getPermittedBizplaceIds(domain, user)
+    bizplaces = bizplaces
+      .map(bizplace => {
+        return "'" + bizplace.trim() + "'"
+      })
+      .join(',')
+
+    let startDate = new Date()
+    let endDate = new Date()
+    startDate.setDate(startDate.getDate() - 30)
+    startDate.setHours(0)
+    startDate.setMinutes(0)
+    startDate.setSeconds(0)
+    const timeNow = `${endDate.getHours()}:${endDate.getMinutes()}:${endDate.getSeconds()}`
+
+    const counter = await getRepository(InventoryHistory).query(`
+      select outbound_date, count(*) from(
+        select date(ih.created_at) outbound_date, row_number() over(partition by ih.pallet_id order by ih.created_at desc) as rn, ih.*, iv.bizplace_id
+        from inventory_histories ih
+        inner join inventories iv on iv.pallet_id = ih.pallet_id and iv.domain_id = ih.domain_id
+        where ih.domain_id='${domain.id}'
+        and iv.bizplace_id in (${bizplaces}) and ih.status = 'TERMINATED'
+      ) as src 
+      where rn = 1
+      and created_at between '${startDate.toLocaleDateString()} 00:00:00' and '${endDate.toLocaleDateString()} ${timeNow}'
+      group by src.outbound_date
+      order by src.outbound_date
+    `)
+
+    let items = []
+    for (let i = 0; i < 30; i++) {
+      const month = startDate.toLocaleString('default', { month: 'short' })
+      const day = startDate.getDate()
+
+      items.push({
+        date: `${month} ${day.toString().padStart(2, '0')}`,
+        count: '0'
+      })
+      startDate.setDate(startDate.getDate() + 1)
+    }
+
+    let compareDate = new Date()
+    compareDate.setDate(compareDate.getDate() - 30)
+    compareDate.setHours(0)
+    compareDate.setMinutes(0)
+    compareDate.setSeconds(0)
+
+    items = items.map((item: { date: string; count: number }) => {
+      item.count =
+        counter.find(ctr => ctr.outbound_date.toLocaleDateString() === compareDate.toLocaleDateString())?.count || 0
+
+      compareDate.setDate(compareDate.getDate() + 1)
+
+      return item
+    })
+
+    return items
+  }
+
+  @Query(returns => [MovementCount])
+  async weeklyMovementsCounter(
+    @Arg('month') month: number,
+    @Arg('year') year: number,
+    @Ctx() context: any
+  ): Promise<MovementCount[]> {
+    const { domain, user }: { domain: Domain; user: User } = context.state
+
+    let bizplaces = await getPermittedBizplaceIds(domain, user)
+    bizplaces = bizplaces
+      .map(bizplace => {
+        return "'" + bizplace.trim() + "'"
+      })
+      .join(',')
+
+    if (!month && !year) {
+      // if user didn't specify the month and year, set default as last month
+      var firstOfMonth = new Date()
+      var lastOfMonth = new Date()
+
+      firstOfMonth.setMonth(firstOfMonth.getMonth() - 1)
+      firstOfMonth.setDate(1)
+      lastOfMonth.setDate(0)
+    } else {
+      var firstOfMonth = new Date(year, month - 1, 1)
+      var lastOfMonth = new Date(year, month, 0)
+    }
+
+    // get data from database
+    const data = await getRepository(InventoryHistory).query(`
+			select movement_date, sum(outbound_count) as outbound_count, sum(inbound_count) as inbound_count from (
+				select movement_date, count(*) as outbound_count, 0 as inbound_count from(
+					select date(ih.created_at) movement_date, row_number() over(partition by ih.pallet_id order by ih.created_at desc) as rn, ih.*, iv.bizplace_id
+					from inventory_histories ih
+					inner join inventories iv on iv.pallet_id = ih.pallet_id and iv.domain_id = ih.domain_id
+					where ih.domain_id = '${domain.id}'
+					and iv.bizplace_id in (${bizplaces}) and ih.status = 'TERMINATED'
+				) as src 
+				where rn = 1
+				and created_at between '${firstOfMonth.toLocaleDateString()} 00:00:00' and '${lastOfMonth.toLocaleDateString()} 23:59:59'
+				group by movement_date
+				union all
+				select movement_date, 0 as outbound_count, count(*) as inbound_count from(
+						select date(ih.created_at) movement_date from inventory_histories ih
+						where ih.bizplace_id in (${bizplaces})
+						and ih.transaction_type in ('NEW', 'PUTAWAY')
+						and created_at between '${firstOfMonth.toLocaleDateString()} 00:00:00' and '${lastOfMonth.toLocaleDateString()} 23:59:59'
+					and domain_id = '${domain.id}'
+				) as foo
+				group by movement_date
+				order by movement_date
+			) src
+			group by movement_date
+		`)
+
+    let movements = [
+      { week: 'Week 01', ...getMovementByWeek(data, [0, 7]) },
+      { week: 'Week 02', ...getMovementByWeek(data, [8, 14]) },
+      { week: 'Week 03', ...getMovementByWeek(data, [15, 21]) },
+      { week: 'Week 04', ...getMovementByWeek(data, [21, 31]) }
+    ]
+
+    // return total 4 weeks of in/outbound movements for a specific month
+    return movements
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() movement: Movement) {
+    return await getRepository(Domain).findOne(movement.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() movement: Movement) {
+    return await getRepository(User).findOne(movement.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() movement: Movement) {
+    return await getRepository(User).findOne(movement.creatorId)
+  }
+}
+
+function getMovementByWeek(data, range): { inbound: number; outbound: number } {
+  return data
+    .filter(item => item.movement_date.getDate() > range[0] && item.movement_date.getDate() <= range[1])
+    .reduce(
+      (inout: { inbound: number; outbound: number }, curr) => {
+        inout.inbound += Number(curr.inbound_count)
+        inout.outbound += Number(curr.outbound_count)
+
+        return inout
+      },
+      { inbound: 0, outbound: 0 }
+    )
+}

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

@@ -0,0 +1,74 @@
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef } from '@things-factory/shell'
+
+import { Movement } from './movement'
+
+@ObjectType()
+export class MovementCount {
+  @Field({ nullable: true })
+  date?: string
+
+  @Field({ nullable: true })
+  count?: string
+
+  @Field({ nullable: true })
+  week?: string
+
+  @Field(type => Int, { nullable: true })
+  inbound?: number
+
+  @Field(type => Int, { nullable: true })
+  outbound?: number
+}
+
+@ObjectType()
+export class MovementList {
+  @Field(type => [Movement], { nullable: true })
+  items?: Movement[]
+
+  @Field(type => Int, { nullable: true })
+  total?: number
+}
+
+@InputType()
+export class MovementPatch {
+  @Field({ nullable: true })
+  id?: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  bizplace?: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  inventory?: ObjectRef
+
+  @Field(type => Int, { nullable: true })
+  inQty?: number
+
+  @Field(type => Int, { nullable: true })
+  outQty?: number
+
+  @Field({ nullable: true })
+  descrtiption?: string
+}
+
+@InputType()
+export class NewMovement {
+  @Field({ nullable: true })
+  id?: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  bizplace?: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  inventory?: ObjectRef
+
+  @Field(type => Int)
+  inQty: number
+
+  @Field(type => Int)
+  outQty: number
+
+  @Field({ nullable: true })
+  description?: string
+}

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

@@ -1,48 +1,81 @@
+import { Field, Float, 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 { Domain } from '@things-factory/shell'
-import { Column, CreateDateColumn, Entity, Index, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm'
-import { Inventory } from './inventory'
+
+import { Inventory } from '../inventory/inventory'
 
 @Entity()
 @Index('ix_movement_0', (movement: Movement) => [movement.domain], { unique: true })
+@ObjectType()
 export class Movement {
   @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
   id: string
 
   @ManyToOne(type => Domain)
+  @Field()
   domain: Domain
 
+  @RelationId((movement: Movement) => movement.domain)
+  domainId: string
+
   @ManyToOne(type => Bizplace)
+  @Field()
   bizplace: Bizplace
 
   @ManyToOne(type => Inventory)
+  @Field()
   inventory: Inventory
 
   @Column('float')
+  @Field(type => Float)
   inQty: number
 
   @Column('float')
+  @Field(type => Float)
   outQty: number
 
   @Column({
     nullable: true
   })
+  @Field({ nullable: true })
   description: string
 
   @ManyToOne(type => User, {
     nullable: true
   })
+  @Field({ nullable: true })
   creator: User
 
+  @RelationId((movement: Movement) => movement.creator)
+  creatorId: string
+
   @ManyToOne(type => User, {
     nullable: true
   })
+  @Field({ nullable: true })
   updater: User
 
+  @RelationId((movement: Movement) => movement.updater)
+  updaterId: string
+
   @CreateDateColumn()
+  @Field({ nullable: true })
   createdAt: Date
 
   @UpdateDateColumn()
+  @Field({ nullable: true })
   updatedAt: Date
 }

package/server/service/pallet/index.ts

@@ -0,0 +1,6 @@
+import { Pallet } from './pallet'
+import { PalletMutation } from './pallet-mutation'
+import { PalletQuery } from './pallet-query'
+
+export const entities = [Pallet]
+export const resolvers = [PalletQuery, PalletMutation]

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

@@ -0,0 +1,244 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, In } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+
+import { PalletHistory } from '../pallet-history/pallet-history'
+import { Pallet } from './pallet'
+import { NewPallet, PalletPatch } from './pallet-types'
+
+@Resolver(Pallet)
+export class PalletMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Pallet)
+  async createPallet(@Arg('pallet') pallet: NewPallet, @Ctx() context: any): Promise<Pallet> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+    return await tx.getRepository(Pallet).save({
+      ...pallet,
+      domain: domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Pallet)
+  async updatePallet(
+    @Arg('name') name: string,
+    @Arg('patch') patch: PalletPatch,
+    @Ctx() context: any
+  ): Promise<Pallet> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+    const repository = tx.getRepository(Pallet)
+    const pallet = await repository.findOne({
+      where: { domain: domain, name }
+    })
+
+    return await repository.save({
+      ...pallet,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [Pallet])
+  async updateMultiplePallet(
+    @Arg('patches', type => [PalletPatch]) patches: PalletPatch[],
+    @Ctx() context: any
+  ): Promise<Pallet[]> {
+    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')
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        if (newRecord.owner && newRecord.owner.id) {
+          newRecord.owner = await tx.getRepository(Bizplace).findOne(newRecord.owner.id)
+        }
+
+        if (newRecord.holder && newRecord.holder.id) {
+          newRecord.holder = await tx.getRepository(Bizplace).findOne(newRecord.holder.id)
+        }
+
+        const result: Pallet = await tx.getRepository(Pallet).save({
+          domain: domain,
+          creator: user,
+          updater: user,
+          ...newRecord
+        })
+
+        await tx.getRepository(PalletHistory).save({
+          ...newRecord,
+          pallet: result,
+          domain: domain,
+          creator: user,
+          updater: user,
+          transactionType: 'NEW'
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const pallet = await tx.getRepository(Pallet).findOne({
+          where: { id: newRecord.id },
+          relations: ['owner', 'holder']
+        })
+        const seq = pallet.seq + 1
+
+        if (newRecord.owner && newRecord.owner.id) {
+          newRecord.owner = await tx.getRepository(Bizplace).findOne(newRecord.owner.id)
+        }
+
+        if (newRecord.holder && newRecord.holder.id) {
+          newRecord.holder = await tx.getRepository(Bizplace).findOne(newRecord.holder.id)
+        }
+
+        const result = await tx.getRepository(Pallet).save({
+          ...pallet,
+          ...newRecord,
+          seq,
+          updater: user,
+          refOrderNo: null
+        })
+
+        let newHistory = {
+          ...pallet,
+          ...newRecord,
+          pallet: result,
+          seq,
+          domain: domain,
+          creator: user,
+          updater: user,
+          transactionType: 'UPDATE'
+        }
+
+        delete newHistory.id
+
+        await tx.getRepository(PalletHistory).save({
+          ...newHistory
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deletePallet(@Arg('name') name: string, @Ctx() context: any): Promise<Boolean> {
+    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+
+    await tx.getRepository(Pallet).delete({ domain: domain, name })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deletePallets(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<Boolean> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+    const pallets = await tx.getRepository(Pallet).find({
+      where: {
+        domain: domain,
+        id: In(ids)
+      },
+      relations: ['owner', 'holder']
+    })
+
+    await Promise.all(
+      pallets.map(async (pallet: Pallet) => {
+        let seq = pallet.seq + 1
+        await tx.getRepository(Pallet).save({
+          ...pallet,
+          status: 'TERMINATED',
+          seq,
+          updater: user
+        })
+
+        await tx.getRepository(PalletHistory).save({
+          pallet: pallet,
+          name: pallet.name,
+          owner: pallet.owner,
+          holder: pallet.holder,
+          seq,
+          domain: domain,
+          creator: user,
+          updater: user,
+          status: 'TERMINATED',
+          transactionType: 'UPDATE'
+        })
+      })
+    )
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [Pallet])
+  async palletReturn(
+    @Arg('patches', type => [PalletPatch]) patches: PalletPatch[],
+    @Ctx() context: any
+  ): Promise<Pallet[]> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+    let results = []
+    const _updateRecords = patches
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const pallet = await tx.getRepository(Pallet).findOne({
+          where: { id: newRecord.id },
+          relations: ['owner', 'holder']
+        })
+        const seq = pallet.seq + 1
+
+        newRecord.owner = await tx.getRepository(Bizplace).findOne(newRecord.owner.id)
+        newRecord.holder = newRecord.owner
+
+        const result = await tx.getRepository(Pallet).save({
+          ...pallet,
+          ...newRecord,
+          seq,
+          updater: user,
+          refOrderNo: null
+        })
+
+        let newHistory = {
+          ...pallet,
+          ...newRecord,
+          pallet: result,
+          seq,
+          domain: domain,
+          creator: user,
+          updater: user,
+          transactionType: 'RETURN'
+        }
+
+        delete newHistory.id
+
+        await tx.getRepository(PalletHistory).save({
+          ...newHistory
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+}