@things-factory/warehouse-base 3.7.13 → 3.8.1

package/server/service/pallet-history/pallet-history-query.ts

@@ -0,0 +1,46 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { convertListParams, Domain, ListParam } from '@things-factory/shell'
+
+import { PalletHistory } from './pallet-history'
+import { PalletHistoryList } from './pallet-history-types'
+
+@Resolver(PalletHistory)
+export class PalletHistoryQuery {
+  @Query(returns => PalletHistoryList)
+  async palletHistories(@Args() params: ListParam, @Ctx() context: any): Promise<PalletHistoryList> {
+    const convertedParams = convertListParams(params)
+    const [items, total] = await getRepository(PalletHistory).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'creator', 'updater']
+    })
+    return { items, total }
+  }
+
+  @Query(returns => PalletHistory)
+  async palletHistory(@Arg('name') name: string, @Ctx() context: any): Promise<PalletHistory> {
+    const { domain }: { domain: Domain } = context.state
+
+    return await getRepository(PalletHistory).findOne({
+      where: { domain: domain, name },
+      relations: ['domain', 'creator', 'updater']
+    })
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() palletHistory: PalletHistory) {
+    return await getRepository(Domain).findOne(palletHistory.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() palletHistory: PalletHistory) {
+    return await getRepository(User).findOne(palletHistory.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() palletHistory: PalletHistory) {
+    return await getRepository(User).findOne(palletHistory.creatorId)
+  }
+}

package/server/service/pallet-history/pallet-history-types.ts

@@ -0,0 +1,36 @@
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+
+import { PalletHistory } from './pallet-history'
+
+@InputType()
+export class NewPalletHistory {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+}
+
+@ObjectType()
+export class PalletHistoryList {
+  @Field(type => [PalletHistory], { nullable: true })
+  items?: PalletHistory[]
+
+  @Field(type => Int, { nullable: true })
+  total?: number
+}
+
+@InputType()
+export class PalletHistoryPatch {
+  @Field({ nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}

package/server/{entities → service/pallet-history}/pallet-history.ts

@@ -1,63 +1,85 @@
+import { Field, ID, ObjectType } from 'type-graphql'
 import {
+  Column,
   CreateDateColumn,
-  UpdateDateColumn,
   Entity,
   Index,
-  Column,
-  OneToMany,
   ManyToOne,
-  PrimaryGeneratedColumn
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
 } from 'typeorm'
-import { Domain } from '@things-factory/shell'
+
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
-import { Pallet } from '.'
+import { Domain } from '@things-factory/shell'
+
+import { Pallet } from '../pallet/pallet'
 
 @Entity()
 @Index('ix_pallet-history_0', (palletHistory: PalletHistory) => [palletHistory.domain, palletHistory.id], {
   unique: true
 })
+@ObjectType()
 export class PalletHistory {
   @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
   id: string
 
   @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true })
   domain: Domain
 
+  @RelationId((palletHistory: PalletHistory) => palletHistory.domain)
+  domainId: string
+
   @Column()
+  @Field()
   name: string
 
   @Column({ default: 0 })
+  @Field()
   seq: number
 
   @ManyToOne(type => Bizplace)
+  @Field()
   owner: Bizplace
 
   @ManyToOne(type => Bizplace)
+  @Field()
   holder: Bizplace
 
   @ManyToOne(type => Pallet)
+  @Field()
   pallet: Pallet
 
   @Column()
+  @Field()
   status: string
 
   @Column()
+  @Field()
   transactionType: string
 
   @CreateDateColumn()
+  @Field({ nullable: true })
   createdAt: Date
 
   @UpdateDateColumn()
+  @Field({ nullable: true })
   updatedAt: Date
 
-  @ManyToOne(type => User, {
-    nullable: true
-  })
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
   creator: User
 
-  @ManyToOne(type => User, {
-    nullable: true
-  })
+  @RelationId((palletHistory: PalletHistory) => palletHistory.creator)
+  creatorId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
   updater: User
+
+  @RelationId((palletHistory: PalletHistory) => palletHistory.updater)
+  updaterId: string
 }

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

@@ -0,0 +1,3 @@
+import { ReducedInventoryHistory } from './reduced-inventory-history'
+
+export const entities = [ReducedInventoryHistory]

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

@@ -84,12 +84,6 @@ export class ReducedInventoryHistory {
   @ViewColumn()
   openingQty: number
 
-  @ViewColumn()
-  weight: number
-
-  @ViewColumn()
-  openingWeight: number
-
   @ViewColumn()
   status: string
 

package/server/service/warehouse/index.ts

@@ -0,0 +1,6 @@
+import { Warehouse } from './warehouse'
+import { WarehouseMutation } from './warehouse-mutation'
+import { WarehouseQuery } from './warehouse-query'
+
+export const entities = [Warehouse]
+export const resolvers = [WarehouseQuery, WarehouseMutation]

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

@@ -0,0 +1,114 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, Repository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { Warehouse } from './warehouse'
+import { NewWarehouse, WarehousePatch } from './warehouse-types'
+
+@Resolver(Warehouse)
+export class WarehouseMutation {
+  @Directive('@privilege(category: "warehouse", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Warehouse)
+  async createWarehouse(@Arg('warehouse') warehouse: NewWarehouse, @Ctx() context: any): Promise<Warehouse> {
+    return await createWarehouse(warehouse, context)
+  }
+
+  @Directive('@privilege(category: "warehouse", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Warehouse)
+  async updateWarehouse(
+    @Arg('id') id: string,
+    @Arg('patch') patch: WarehousePatch,
+    @Ctx() context: any
+  ): Promise<Warehouse> {
+    return await updateWarehouse(id, patch, context)
+  }
+
+  @Directive('@privilege(category: "warehouse", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => [Warehouse])
+  async updateMultipleWarehouse(
+    @Arg('patches', type => [WarehousePatch]) patches: WarehousePatch[],
+    @Ctx() context: any
+  ): Promise<Warehouse[]> {
+    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 createWarehouse(patch as NewWarehouse, context)
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const patch: WarehousePatch = _updateRecords[i]
+        const result = await updateWarehouse(patch.id, patch, context)
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@privilege(category: "warehouse", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteWarehouse(@Arg('id') id: string, @Ctx() context: any): Promise<Boolean> {
+    return await deleteWarehouse(id, context)
+  }
+
+  @Directive('@privilege(category: "warehouse", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteWarehouses(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<Boolean> {
+    return await deleteWarehouses(ids, context)
+  }
+}
+
+export async function createWarehouse(warehouse: NewWarehouse, context: any) {
+  const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+  const repository: Repository<Warehouse> = tx.getRepository(Warehouse)
+  return await repository.save({
+    ...warehouse,
+    domain,
+    creator: user,
+    updater: user
+  })
+}
+
+export async function updateWarehouse(id: string, patch: WarehousePatch, context: any) {
+  const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+  const repository: Repository<Warehouse> = tx.getRepository(Warehouse)
+  const warehouse = await repository.findOne(id)
+
+  return await repository.save({
+    ...warehouse,
+    ...patch,
+    updater: user
+  })
+}
+
+export async function deleteWarehouse(id: string, context) {
+  const { tx }: { tx: EntityManager } = context.state
+
+  const repository: Repository<Warehouse> = tx.getRepository(Warehouse)
+  await repository.delete(id)
+  return true
+}
+
+export async function deleteWarehouses(ids: string[], context: any) {
+  const { tx }: { tx: EntityManager } = context.state
+
+  const repository: Repository<Warehouse> = tx.getRepository(Warehouse)
+  await repository.delete(ids)
+  return true
+}

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

@@ -0,0 +1,51 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { convertListParams, Domain, ListParam } from '@things-factory/shell'
+
+import { Warehouse } from './warehouse'
+import { WarehouseList } from './warehouse-types'
+
+@Resolver(Warehouse)
+export class WarehouseQuery {
+  @Query(returns => Warehouse)
+  async warehouse(@Arg('id') id: string, @Ctx() context: any): Promise<Warehouse> {
+    const { domain }: { domain: Domain } = context.state
+
+    return await getRepository(Warehouse).findOne({
+      where: {
+        domain: domain,
+        name
+      },
+      relations: ['domain', 'locations', 'creator', 'updater']
+    })
+  }
+
+  @Query(returns => WarehouseList)
+  async warehouses(@Args() params: ListParam, @Ctx() context: any): Promise<WarehouseList> {
+    const { domain }: { domain: Domain } = context.state
+
+    const convertedParams = convertListParams(params, domain.id)
+    const [items, total] = await getRepository(Warehouse).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'creator', 'updater']
+    })
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() warehouse: Warehouse) {
+    return await getRepository(Domain).findOne(warehouse.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() warehouse: Warehouse) {
+    return await getRepository(User).findOne(warehouse.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() warehouse: Warehouse) {
+    return await getRepository(User).findOne(warehouse.creatorId)
+  }
+}

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

@@ -0,0 +1,50 @@
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef } from '@things-factory/shell'
+
+import { Warehouse } from './warehouse'
+
+@InputType()
+export class NewWarehouse {
+  @Field({ nullable: true })
+  id?: string
+
+  @Field()
+  name: string
+
+  @Field(type => [ObjectRef], { nullable: true })
+  locations?: ObjectRef[]
+
+  @Field({ nullable: true })
+  description?: string
+}
+
+@ObjectType()
+export class WarehouseList {
+  @Field(type => [Warehouse], { nullable: true })
+  items?: Warehouse[]
+
+  @Field(type => Int, { nullable: true })
+  total?: number
+}
+
+@InputType()
+export class WarehousePatch {
+  @Field({ nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  type?: string
+
+  @Field(type => [ObjectRef], { nullable: true })
+  locations?: ObjectRef[]
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}

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

@@ -1,6 +1,4 @@
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
+import { Field, ID, ObjectType } from 'type-graphql'
 import {
   Column,
   CreateDateColumn,
@@ -9,50 +7,77 @@ import {
   ManyToOne,
   OneToMany,
   PrimaryGeneratedColumn,
+  RelationId,
   UpdateDateColumn
 } from 'typeorm'
-import { Location } from './location'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+
+import { Location } from '../location/location'
 
 @Entity()
 @Index('ix_warehouse_0', (warehouse: Warehouse) => [warehouse.domain, warehouse.name], { unique: true })
 @Index('ix_warehouse_1', (warehouse: Warehouse) => [warehouse.domain, warehouse.id], { unique: true })
+@ObjectType()
 export class Warehouse {
   @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
   id: string
 
   @ManyToOne(type => Domain)
+  @Field()
   domain: Domain
 
+  @RelationId((warehouse: Warehouse) => warehouse.domain)
+  domainId: string
+
   @ManyToOne(type => Bizplace)
+  @Field()
   bizplace: Bizplace
 
   @Column()
+  @Field()
   name: string
 
   @OneToMany(type => Location, location => location.warehouse)
+  @Field(type => [Location])
   locations: Location[]
 
   @Column()
+  @Field()
   type: string
 
   @Column({
     nullable: true
   })
+  @Field({ nullable: true })
   description: string
 
   @ManyToOne(type => User, {
     nullable: true
   })
+  @Field({ nullable: true })
   creator: User
 
+  @RelationId((warehouse: Warehouse) => warehouse.creator)
+  creatorId: string
+
   @ManyToOne(type => User, {
     nullable: true
   })
+  @Field({ nullable: true })
   updater: User
 
+  @RelationId((warehouse: Warehouse) => warehouse.updater)
+  updaterId: string
+
   @CreateDateColumn()
+  @Field({ nullable: true })
   createdAt: Date
 
   @UpdateDateColumn()
+  @Field({ nullable: true })
   updatedAt: Date
 }

package/server/utils/datetime-util.ts

@@ -0,0 +1,54 @@
+export class DateGenerator {
+  static generateDate() {
+    const today = new Date()
+    const year = today.getFullYear()
+    const month = today.getMonth()
+    const day = today.getDate()
+
+    const yy = String(year).substr(String(year).length - 2)
+    const mm = String(month + 1).padStart(2, '0')
+    const dd = String(day).padStart(2, '0')
+
+    return yy + mm + dd
+  }
+}
+
+export class DateTimeConverter {
+  static date(dateTime) {
+    let unloadDate = ''
+    if (dateTime) {
+      const unloadDateTime: Date = new Date(dateTime)
+      var year = unloadDateTime.getFullYear()
+
+      var month = (1 + unloadDateTime.getMonth()).toString()
+      month = month.length > 1 ? month : '0' + month
+
+      var day = unloadDateTime.getDate().toString()
+      day = day.length > 1 ? day : '0' + day
+
+      unloadDate = day + '-' + month + '-' + year
+    }
+    return unloadDate
+  }
+
+  static datetime(dateTime, timezone) {
+    let unloadDate = ''
+    if (dateTime) {
+      const datetime = Number(dateTime)
+      const timezoneOffset = timezone * 60000
+      const newUnloadDate = new Date(datetime - timezoneOffset).toISOString().slice(0, -1)
+
+      var dateTimeParts: any = newUnloadDate.split('T')
+
+      //handle date parts
+      var dateParts = dateTimeParts[0].split('-')
+      var newDate = DateTimeConverter.date(dateParts)
+
+      //handle time part
+      var timeParts = dateTimeParts[1].slice(0, -7)
+
+      unloadDate = newDate + ' ' + timeParts
+    }
+    return unloadDate
+  }
+}

package/server/utils/index.ts

@@ -1,2 +1,3 @@
 export * from './inventory-no-generator'
 export * from './inventory-util'
+export * from './datetime-util'