@things-factory/sales-base 5.0.13 → 6.0.0-alpha.1

package/server/service/transfer-order/transfer-order-query.ts

@@ -1,7 +1,8 @@
-import { User } from '@things-factory/auth-base'
-import { convertListParams, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
 import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { convertListParams, Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
+
 import { TransferOrderList } from '../'
 import { TransferOrder } from './transfer-order'
 
@@ -9,7 +10,7 @@ import { TransferOrder } from './transfer-order'
 export class TransferOrderQuery {
   @Query(returns => TransferOrderList)
   async transferOrders(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[],
     @Arg('pagination', type => Pagination, { nullable: true }) pagination?: Pagination,
     @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
@@ -30,13 +31,13 @@ export class TransferOrderQuery {
   }
 
   @Query(returns => TransferOrder)
-  async transferOrder(@Arg('name') name: string, @Ctx() context: any): Promise<TransferOrder> {
-    const { domain }: { domain: Domain } = context.state
+  async transferOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<TransferOrder> {
+    const { domain } = context.state
 
     const repository = getRepository(TransferOrder)
 
     return await repository.findOne({
-      where: { domain, name },
+      where: { domain: { id: domain.id }, name },
       relations: [
         'domain',
         'orderInventories',
@@ -50,16 +51,16 @@ export class TransferOrderQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() transferOrder: TransferOrder): Promise<Domain> {
-    return await getRepository(Domain).findOne(transferOrder.domainId)
+    return await getRepository(Domain).findOneBy({ id: transferOrder.domainId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() transferOrder: TransferOrder): Promise<User> {
-    return await getRepository(User).findOne(transferOrder.creatorId)
+    return await getRepository(User).findOneBy({ id: transferOrder.creatorId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() transferOrder: TransferOrder): Promise<User> {
-    return await getRepository(User).findOne(transferOrder.updaterId)
+    return await getRepository(User).findOneBy({ id: transferOrder.updaterId })
   }
 }

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

@@ -1,7 +1,5 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager } from 'typeorm'
+
 import { NewVas, VasPatch } from '../'
 import { Vas } from './vas'
 
@@ -10,8 +8,8 @@ export class VasMutation {
   @Directive('@privilege(category: "vas", privilege: "mutation")')
   @Directive('@transaction')
   @Mutation(returns => Vas)
-  async createVas(@Arg('vas', type => NewVas) vas: NewVas, @Ctx() context: any): Promise<Vas> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async createVas(@Arg('vas', type => NewVas) vas: NewVas, @Ctx() context: ResolverContext): Promise<Vas> {
+    const { tx, domain, user } = context.state
 
     return await tx.getRepository(Vas).save({
       ...vas,
@@ -27,11 +25,11 @@ export class VasMutation {
   async updateVas(
     @Arg('name') name: string,
     @Arg('patch', type => VasPatch) patch: VasPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<Vas> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
 
-    const vas = await tx.getRepository(Vas).findOne({ domain, name })
+    const vas = await tx.getRepository(Vas).findOneBy({ domain: { id: domain.id }, name })
 
     return await tx.getRepository(Vas).save({
       ...vas,
@@ -45,9 +43,9 @@ export class VasMutation {
   @Mutation(returns => [Vas])
   async updateMultipleVas(
     @Arg('patches', type => [VasPatch]) patches: VasPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<Vas[]> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
 
     let results: Vas[] = []
     const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
@@ -72,7 +70,7 @@ export class VasMutation {
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
-        const vas = await vasRepo.findOne(newRecord.id)
+        const vas = await vasRepo.findOneBy({ id: newRecord.id })
 
         const result = await vasRepo.save({
           ...vas,
@@ -90,8 +88,8 @@ export class VasMutation {
   @Directive('@privilege(category: "vas", privilege: "mutation")')
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deleteVas(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
-    const { tx }: { tx: EntityManager } = context.state
+  async deleteVas(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { tx } = context.state
 
     await tx.getRepository(Vas).delete(id)
     return true
@@ -100,8 +98,8 @@ export class VasMutation {
   @Directive('@privilege(category: "vas", privilege: "mutation")')
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deleteVass(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
-    const { tx }: { tx: EntityManager } = context.state
+  async deleteVass(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
+    const { tx } = context.state
     await tx.getRepository(Vas).delete(ids)
     return true
   }

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

@@ -1,7 +1,9 @@
-import { User } from '@things-factory/auth-base'
-import { buildQuery, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
 import { Arg, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository, SelectQueryBuilder } from 'typeorm'
+import { SelectQueryBuilder } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { buildQuery, Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
+
 import { VasList } from '../'
 import { Vas } from './vas'
 
@@ -10,7 +12,7 @@ export class VasQuery {
   @Directive('@privilege(category: "vas", privilege: "query")')
   @Query(returns => VasList)
   async vass(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[],
     @Arg('pagination', type => Pagination, { nullable: true }) pagination?: Pagination,
     @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
@@ -29,12 +31,12 @@ export class VasQuery {
 
   @Directive('@privilege(category: "vas", privilege: "query") ')
   @Query(returns => Vas)
-  async vas(@Arg('name') name: string, @Ctx() context: any): Promise<Vas> {
-    const { domain }: { domain: Domain } = context.state
+  async vas(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Vas> {
+    const { domain } = context.state
 
     return await getRepository(Vas).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         name
       },
       relations: ['domain', 'creator', 'updater']
@@ -43,16 +45,16 @@ export class VasQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() vas: Vas): Promise<Domain> {
-    return await getRepository(Domain).findOne(vas.domainId)
+    return await getRepository(Domain).findOneBy({ id: vas.domainId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() vas: Vas): Promise<User> {
-    return await getRepository(User).findOne(vas.creatorId)
+    return await getRepository(User).findOneBy({ id: vas.creatorId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() vas: Vas): Promise<User> {
-    return await getRepository(User).findOne(vas.updaterId)
+    return await getRepository(User).findOneBy({ id: vas.updaterId })
   }
 }

package/server/service/vas-order/vas-order-mutation.ts

@@ -1,11 +1,9 @@
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, In } from 'typeorm'
+import { In } from 'typeorm'
 
-import { Role, User } from '@things-factory/auth-base'
+import { Role } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
-import { sendNotification } from '@things-factory/notification'
 import { Product } from '@things-factory/product-base'
-import { Domain } from '@things-factory/shell'
 
 import { NewOrderVas, NewVasOrder, OrderVas, Vas, VasOrderPatch } from '../'
 import { ORDER_STATUS, ORDER_TYPES, ORDER_VAS_STATUS } from '../../constants'
@@ -16,11 +14,11 @@ import { VasOrder } from './vas-order'
 export class VasOrderMutation {
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deleteVasOrder(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+  async deleteVasOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { tx, domain } = context.state
 
     let foundVasOrder: VasOrder = await tx.getRepository(VasOrder).findOne({
-      where: { domain, name },
+      where: { domain: { id: domain.id }, name },
       relations: ['orderVass', 'creator', 'updater']
     })
 
@@ -39,11 +37,14 @@ export class VasOrderMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deleteVasOrders(@Arg('names', type => [String]) names: string[], @Ctx() context: any): Promise<boolean> {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+  async deleteVasOrders(
+    @Arg('names', type => [String]) names: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { tx, domain } = context.state
 
     await tx.getRepository(VasOrder).delete({
-      domain,
+      domain: { id: domain.id },
       name: In(names)
     })
     return true
@@ -53,9 +54,9 @@ export class VasOrderMutation {
   @Mutation(returns => VasOrder)
   async generateVasOrder(
     @Arg('vasOrder', type => NewVasOrder) vasOrder: NewVasOrder,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<VasOrder> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
 
     const customerBizplace: Bizplace = await tx.getRepository(Bizplace).findOne({
       where: {
@@ -82,13 +83,13 @@ export class VasOrderMutation {
     orderVass = await Promise.all(
       orderVass.map(async (ov: OrderVas) => {
         if (ov?.targetProduct?.id) {
-          ov.targetProduct = await tx.getRepository(Product).findOne(ov.targetProduct.id)
+          ov.targetProduct = await tx.getRepository(Product).findOneBy({ id: ov.targetProduct.id })
         }
         return {
           ...ov,
           domain,
           name: OrderNoGenerator.orderVas(),
-          vas: await tx.getRepository(Vas).findOne({ domain, id: ov.vas.id }),
+          vas: await tx.getRepository(Vas).findOneBy({ domain: { id: domain.id }, id: ov.vas.id }),
           vasOrder: createdVasOrder,
           bizplace: customerBizplace,
           type: ORDER_TYPES.VAS_ORDER,
@@ -105,11 +106,11 @@ export class VasOrderMutation {
 
   @Directive('@transaction')
   @Mutation(returns => VasOrder)
-  async confirmVasOrder(@Arg('name') name: string, @Ctx() context: any): Promise<VasOrder> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async confirmVasOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<VasOrder> {
+    const { tx, domain, user } = context.state
 
     const foundVasOrder: VasOrder = await tx.getRepository(VasOrder).findOne({
-      where: { domain, name },
+      where: { domain: { id: domain.id }, name },
       relations: ['bizplace', 'orderVass', 'orderVass.vas', 'creator', 'updater']
     })
 
@@ -164,10 +165,15 @@ export class VasOrderMutation {
         url: context.header.referer,
         data: { url: context.header.referer }
       }
-      await sendNotification({
-        receivers,
-        message: { ...msg }
-      })
+
+      /**
+       * @notes Temporary off sendNotification due to suspect of causing wms down
+       */
+
+      // await sendNotification({
+      //   receivers,
+      //   message: { ...msg }
+      // })
     }
 
     return vasOrder
@@ -178,14 +184,14 @@ export class VasOrderMutation {
   async rejectVasOrder(
     @Arg('name') name: string,
     @Arg('patch', type => VasOrderPatch) patch: VasOrderPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<VasOrder> {
     try {
-      const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+      const { tx, domain, user } = context.state
       if (!patch.remark) throw new Error('Remark is not exist.')
 
       const vasOrder: VasOrder = await tx.getRepository(VasOrder).findOne({
-        where: { domain, name, status: ORDER_STATUS.PENDING_RECEIVE },
+        where: { domain: { id: domain.id }, name, status: ORDER_STATUS.PENDING_RECEIVE },
         relations: ['bizplace', 'orderVass']
       })
       if (!vasOrder) throw new Error(`Vas order doesn't exists.`)
@@ -235,10 +241,14 @@ export class VasOrderMutation {
           data: { url: context.header.referer }
         }
 
-        await sendNotification({
-          receivers,
-          message: { ...msg }
-        })
+        /**
+         * @notes Temporary off sendNotification due to suspect of causing wms down
+         */
+
+        // await sendNotification({
+        //   receivers,
+        //   message: { ...msg }
+        // })
       }
 
       return vasOrder

package/server/service/vas-order/vas-order-query.ts

@@ -1,8 +1,10 @@
+import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { In } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { convertListParams, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
-import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository, In } from 'typeorm'
+import { convertListParams, Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
+
 import { VasOrderList } from '../'
 import { ORDER_STATUS } from '../../constants'
 import { VasOrder } from './vas-order'
@@ -11,12 +13,12 @@ import { VasOrder } from './vas-order'
 export class VasOrderQuery {
   @Query(returns => VasOrderList)
   async vasOrders(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[],
     @Arg('pagination', type => Pagination, { nullable: true }) pagination?: Pagination,
     @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
   ): Promise<VasOrderList> {
-    const { domain, user }: { domain: Domain; user: User } = context.state
+    const { domain, user } = context.state
 
     const convertedParams = convertListParams({ filters, pagination, sortings })
     convertedParams.where.bizplace = In(await getPermittedBizplaceIds(domain, user))
@@ -37,12 +39,12 @@ export class VasOrderQuery {
   }
 
   @Query(returns => VasOrder)
-  async vasOrder(@Arg('name') name: string, @Ctx() context: any): Promise<VasOrder> {
-    const { domain, user }: { domain: Domain; user: User } = context.state
+  async vasOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<VasOrder> {
+    const { domain, user } = context.state
 
     return await getRepository(VasOrder).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         name,
         bizplace: In(await getPermittedBizplaceIds(domain, user))
       },
@@ -64,12 +66,12 @@ export class VasOrderQuery {
 
   @Query(returns => VasOrderList)
   async vasOrderRequests(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[],
     @Arg('pagination', type => Pagination, { nullable: true }) pagination?: Pagination,
     @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
   ): Promise<VasOrderList> {
-    const { domain, user }: { domain: Domain; user: User } = context.state
+    const { domain, user } = context.state
 
     const convertedParams = convertListParams({ filters, pagination, sortings })
 
@@ -102,16 +104,16 @@ export class VasOrderQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() vasOrder: VasOrder): Promise<Domain> {
-    return await getRepository(Domain).findOne(vasOrder.domainId)
+    return await getRepository(Domain).findOneBy({ id: vasOrder.domainId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() vasOrder: VasOrder): Promise<User> {
-    return await getRepository(User).findOne(vasOrder.creatorId)
+    return await getRepository(User).findOneBy({ id: vasOrder.creatorId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() vasOrder: VasOrder): Promise<User> {
-    return await getRepository(User).findOne(vasOrder.updaterId)
+    return await getRepository(User).findOneBy({ id: vasOrder.updaterId })
   }
 }

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 './order-no-generator'
 export * from './inventory-util'
+export * from './datetime-util'