@things-factory/marketplace-base 8.0.0-beta.9 → 8.0.2

package/server/entities/store-replenishment-item.ts

@@ -0,0 +1,48 @@
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+import { Column, CreateDateColumn, Entity, Index, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm'
+import { StoreReplenishment } from '../entities'
+
+@Entity()
+@Index(
+  'ix_store_replenishment_item_0',
+  (storeReplenishmentItem: StoreReplenishmentItem) => [storeReplenishmentItem.domain, storeReplenishmentItem.name],
+  { unique: true }
+)
+export class StoreReplenishmentItem {
+  @PrimaryGeneratedColumn('uuid')
+  id: string
+
+  @ManyToOne(type => Domain)
+  domain: Domain
+
+  @Column()
+  name: string
+
+  @Column({
+    nullable: true
+  })
+  description: string
+
+  @ManyToOne(type => StoreReplenishment)
+  storeReplenishment: StoreReplenishment
+
+  @Column({ nullable: true })
+  type: string
+
+  @CreateDateColumn()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  updatedAt: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  creator: User
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  updater: User
+}

package/server/entities/store-replenishment.ts

@@ -0,0 +1,79 @@
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn
+} from 'typeorm'
+import { StoreReplenishmentItem } from '../entities'
+
+@Entity()
+@Index(
+  'ix_store_replenishment_0',
+  (storeReplenishment: StoreReplenishment) => [storeReplenishment.domain, storeReplenishment.name],
+  { unique: true }
+)
+export class StoreReplenishment {
+  @PrimaryGeneratedColumn('uuid')
+  id: string
+
+  @ManyToOne(type => Domain)
+  domain: Domain
+
+  @Column()
+  name: string
+
+  @Column({ nullable: true })
+  refNo: string
+
+  @Column()
+  etaDate: string
+
+  @Column({ nullable: true })
+  containerNo: string
+
+  @Column({ nullable: true })
+  truckNo: string
+
+  @Column({ nullable: true })
+  deliverOrderNo: string
+
+  @Column({ default: false })
+  importCargo: boolean
+
+  @Column({ default: false })
+  ownTransport: boolean
+
+  @Column({ nullable: true })
+  description: string
+
+  @Column({ nullable: true })
+  arrivalNoticeId: string
+
+  @OneToMany(type => StoreReplenishmentItem, storeReplenishmentItem => storeReplenishmentItem.storeReplenishment)
+  storeReplenishmentItems: StoreReplenishmentItem[]
+
+  @Column()
+  status: string
+
+  @CreateDateColumn()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  updatedAt: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  creator: User
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  updater: User
+}

package/server/graphql/index.ts

@@ -0,0 +1,9 @@
+import { deepMerge } from '@things-factory/utils'
+
+import * as resolvers from './resolvers'
+import * as typeDefs from './types'
+
+export const schema = {
+  typeDefs,
+  resolvers: deepMerge.apply(null, Object.values(resolvers))
+}

package/server/graphql/resolvers/index.ts

@@ -0,0 +1,14 @@
+export * from './marketplace-order'
+export * from './marketplace-order-item'
+export * from './marketplace-order-shipping'
+export * from './marketplace-order-shipping-item'
+export * from './marketplace-product'
+export * from './marketplace-product-attribute'
+export * from './marketplace-product-category'
+export * from './marketplace-product-variation'
+export * from './store-replenishment'
+export * from './store-replenishment-item'
+export * from './marketplace-refund-order'
+export * from './marketplace-report'
+
+export * from './marketplace-product-variation-price'

package/server/graphql/resolvers/marketplace-order/auto-initialise-logistics-by-batch.ts

@@ -0,0 +1,164 @@
+import { IsNull, Not } from 'typeorm'
+
+import { config } from '@things-factory/env'
+import { MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
+import { Domain, getRepository } from '@things-factory/shell'
+
+import { MARKETPLACE_PLATFORM, ORDER_STATUS } from '../../../constants'
+import { MarketplaceOrder, MarketplaceOrderItem } from '../../../entities'
+import { getLogisticsParam } from '../marketplace-order/get-logistics-param'
+
+const shopeeConfig = config.get('marketplaceIntegrationShopee', {})
+const { v2 } = shopeeConfig
+
+export const autoInitialiseLogisticsByBatch = {
+  async autoInitialiseLogisticsByBatch(_: any, { companyDomainId }, context: ResolverContext) {
+    const { user } = context.state
+
+    const companyDomain: Domain = await getRepository(Domain).findOneBy({ id: companyDomainId })
+
+    // Step 1: get all available marketplace-store
+    const marketplaceStores: MarketplaceStore[] = await StoreAPI.getMarketplaceStores(companyDomain)
+
+    for (var i = 0; i < marketplaceStores?.length; i++) {
+      const marketplaceStore: MarketplaceStore = marketplaceStores[i]
+
+      let marketplaceOrders: MarketplaceOrder[] = []
+      if (marketplaceStore.platform == MARKETPLACE_PLATFORM.LAZADA) {
+        marketplaceOrders = await getRepository(MarketplaceOrder).find({
+          where: {
+            marketplaceStore: { id: marketplaceStore.id },
+            status: ORDER_STATUS.PENDING
+          },
+          relations: [
+            'marketplaceOrderItems',
+            'marketplaceOrderItems.marketplaceOrderShippingItems',
+            'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping',
+            'marketplaceOrderItems.marketplaceProductVariation'
+          ]
+        })
+      } else {
+        if (marketplaceStore.isOwnTransport) {
+          marketplaceOrders = await getRepository(MarketplaceOrder).find({
+            where: {
+              marketplaceStore: { id: marketplaceStore.id },
+              trackingNo: IsNull(),
+              ownTrackingNo: Not(IsNull()),
+              status: ORDER_STATUS.READY_TO_SHIP
+            },
+            relations: [
+              'marketplaceOrderItems',
+              'marketplaceOrderItems.marketplaceOrderShippingItems',
+              'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping',
+              'marketplaceOrderItems.marketplaceProductVariation'
+            ]
+          })
+        } else {
+          marketplaceOrders = await getRepository(MarketplaceOrder).find({
+            where: {
+              marketplaceStore: { id: marketplaceStore.id },
+              trackingNo: IsNull(),
+              status: ORDER_STATUS.READY_TO_SHIP
+            },
+            relations: [
+              'marketplaceOrderItems',
+              'marketplaceOrderItems.marketplaceOrderShippingItems',
+              'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping',
+              'marketplaceOrderItems.marketplaceProductVariation'
+            ]
+          })
+        }
+      }
+
+      for (var j = 0; j < marketplaceOrders?.length; j++) {
+        const marketplaceOrder: MarketplaceOrder = marketplaceOrders[j]
+        if (marketplaceStore.platform == MARKETPLACE_PLATFORM.SHOPEE) {
+          let fullLogisticsDetail = await getLogisticsParam.getLogisticsParam(
+            _,
+            { storeId: marketplaceStore.id, orderNo: marketplaceOrder.orderNo },
+            context
+          )
+
+          let deliveryType = {}
+          if (fullLogisticsDetail.non_integrated) {
+            deliveryType = {
+              non_integrated: {
+                trackingNo: marketplaceOrder.ownTrackingNo
+              }
+            }
+          } else if (fullLogisticsDetail.dropoff) {
+            const dropoff = fullLogisticsDetail.logisticsDetail.dropoff
+            deliveryType = {
+              dropoff: {}
+            }
+
+            if (dropoff.branchId) deliveryType['dropoff'] = { ...deliveryType['dropoff'], branchId: dropoff.branchId }
+            if (dropoff.senderRealName)
+              deliveryType['dropoff'] = {
+                ...deliveryType['dropoff'],
+                senderRealName: dropoff.senderRealName
+              }
+            if (dropoff.trackingNo)
+              deliveryType['dropoff'] = { ...deliveryType['dropoff'], trackingNo: dropoff.trackingNo }
+          } else {
+            return false
+          }
+
+          await StoreAPI.initLogistics(marketplaceStore, { deliveryType, orderNo: marketplaceOrder.orderNo })
+          if (marketplaceStore.platform == MARKETPLACE_PLATFORM.SHOPEE && v2) {
+            await StoreAPI.createShippingDocument(marketplaceStore, { orderNo: marketplaceOrder.orderNo })
+          }
+        } else if (marketplaceStore.platform == MARKETPLACE_PLATFORM.LAZADA) {
+          const shippingProviders: any[] = await StoreAPI.getStoreLogistics(marketplaceStore, {})
+          const shippingProvider: string = shippingProviders[0].name
+          const deliveryType: string = 'dropship'
+          const storeOrder = await StoreAPI.getStoreOrder(marketplaceStore, { orderId: marketplaceOrder.orderNo })
+
+          const arrItemIds = storeOrder.orderItems.reduce((newItemID, item) => {
+            return [...newItemID, ...item.name.split(',')]
+          }, [])
+
+          if (storeOrder?.status == 'pending' && deliveryType && arrItemIds.length > 0 && shippingProvider) {
+            const storeOrderItemsPBM = await StoreAPI.setStoreOrderStatusPackedByMarketplace(marketplaceStore, {
+              deliveryType,
+              orderItemId: arrItemIds,
+              shippingProvider
+            })
+
+            marketplaceOrder.trackingNo = storeOrderItemsPBM.trackingNumber[0] || '[]'
+            marketplaceOrder.otherInfoJSON = JSON.stringify({
+              deliveryType: deliveryType,
+              shippingProvider: shippingProvider
+            })
+          }
+
+          let updatedOrder = await StoreAPI.getStoreOrder(marketplaceStore, { orderId: marketplaceOrder.name })
+
+          await getRepository(MarketplaceOrder).save({
+            ...marketplaceOrder,
+            status: updatedOrder.status,
+            orderUpdatedAt: storeOrder.orderUpdatedAt
+          })
+
+          for (let idx = 0; idx < marketplaceOrder.marketplaceOrderItems.length; idx++) {
+            let matchItem = updatedOrder.orderItems.find(
+              i => i.variationId == marketplaceOrder.marketplaceOrderItems[idx].marketplaceProductVariation.variationId
+            )
+
+            if (matchItem) {
+              let targetMarketplaceOrderItem = {
+                ...marketplaceOrder.marketplaceOrderItems[idx],
+                shippingProvider: matchItem.shippingProvider,
+                trackingCode: matchItem.trackingNo,
+                status: matchItem.status
+              }
+
+              await getRepository(MarketplaceOrderItem).save(targetMarketplaceOrderItem)
+            }
+          }
+        }
+      }
+    }
+    return true
+  }
+}

package/server/graphql/resolvers/marketplace-order/auto-update-order-ready-to-ship.ts

@@ -0,0 +1,136 @@
+import { IsNull, Not } from 'typeorm'
+
+import { MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
+import { Domain, getRepository } from '@things-factory/shell'
+
+import { MARKETPLACE_PLATFORM, ORDER_STATUS } from '../../../constants'
+import {
+  MarketplaceOrder,
+  MarketplaceOrderItem,
+  MarketplaceOrderShipping,
+  MarketplaceOrderShippingItem
+} from '../../../entities'
+
+export const autoUpdateOrderReadyToShip = {
+  async autoUpdateOrderReadyToShip(_: any, { companyDomainId }, context: ResolverContext) {
+    const companyDomain: Domain = await getRepository(Domain).findOne(companyDomainId)
+
+    // Step 1: get all available marketplace-store
+    const marketplaceStores: MarketplaceStore[] = await StoreAPI.getMarketplaceStores(companyDomain)
+    const lazadaStores: MarketplaceStore[] = marketplaceStores.filter(
+      marketplaceStore => marketplaceStore.platform === MARKETPLACE_PLATFORM.LAZADA
+    )
+
+    for (var i = 0; i < lazadaStores?.length; i++) {
+      const marketplaceStore: MarketplaceStore = lazadaStores[i]
+
+      let marketplaceOrders: MarketplaceOrder[] = await getRepository(MarketplaceOrder).find({
+        where: {
+          marketplaceStore: { id: marketplaceStore.id },
+          trackingNo: Not(IsNull()),
+          status: ORDER_STATUS.PACKED
+        },
+        relations: [
+          'marketplaceOrderItems',
+          'marketplaceOrderItems.marketplaceOrderShippingItems',
+          'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping',
+          'marketplaceOrderItems.marketplaceProductVariation'
+        ]
+      })
+
+      for (var j = 0; j < marketplaceOrders?.length; j++) {
+        const marketplaceOrder: MarketplaceOrder = marketplaceOrders[j]
+
+        const otherInfo = JSON.parse(marketplaceOrder.otherInfoJSON)
+        const shippingProvider: string = otherInfo.shippingProvider
+        const deliveryType: string = otherInfo.deliveryType
+
+        let trackingInfoArr: any[] = []
+        let marketplaceOrderShippings: MarketplaceOrderShipping[] = []
+
+        marketplaceOrder.marketplaceOrderItems.map(item => {
+          const marketplaceOrderShippingItems: MarketplaceOrderShippingItem[] = item.marketplaceOrderShippingItems
+          marketplaceOrderShippingItems.map(itm => {
+            if (itm?.marketplaceOrderShipping) {
+              marketplaceOrderShippings.push(itm.marketplaceOrderShipping)
+            }
+          })
+        })
+
+        const uniqueMarketplaceOrderShippings = Array.from(new Set(marketplaceOrderShippings.map(a => a.id))).map(
+          id => {
+            return marketplaceOrderShippings.find(a => a.id === id)
+          }
+        )
+
+        if (
+          uniqueMarketplaceOrderShippings.some(marketplaceOrderShipping => marketplaceOrderShipping.trackingNo != null)
+        ) {
+          uniqueMarketplaceOrderShippings.map((orderShipping: MarketplaceOrderShipping) => {
+            if (orderShipping?.trackingNo) {
+              const trackingNoInfo: any[] = JSON.parse(orderShipping.trackingNo)
+              const orderTrackingNos: string[] = trackingNoInfo.map(item => item.tracking_code)
+              const uniqueTrackingNos = [...new Set(orderTrackingNos)]
+
+              let orderItemIds: string[] = []
+
+              if (uniqueTrackingNos?.length == 1) {
+                orderItemIds = trackingNoInfo.map(item => item.order_item_id)
+                trackingInfoArr.push({ orderItemIds, trackingNo: uniqueTrackingNos[0] })
+              } else {
+                uniqueTrackingNos.map(trackingNo => {
+                  orderItemIds = trackingNoInfo
+                    .filter(info => info.tracking_code === trackingNo)
+                    .map(filteredInfo => filteredInfo.order_item_id)
+
+                  trackingInfoArr.push({ orderItemIds, trackingNo })
+                })
+              }
+            }
+          })
+        }
+
+        for (var i = 0; i < trackingInfoArr?.length; i++) {
+          const trackingInfo = trackingInfoArr[i]
+          const trackingNo = trackingInfo.trackingNo
+          const orderItemId = trackingInfo.orderItemIds
+
+          await StoreAPI.setStoreOrderStatusReadyToShip(marketplaceStore, {
+            shipmentProvider: shippingProvider,
+            deliveryType,
+            orderItemId,
+            trackingNo,
+            orderId: marketplaceOrder.name
+          })
+        }
+
+        const updatedOrder = await StoreAPI.getStoreOrder(marketplaceStore, { orderId: marketplaceOrder.name })
+
+        marketplaceOrder.status = updatedOrder.status
+        marketplaceOrder.orderUpdatedAt = updatedOrder.orderUpdatedAt
+        marketplaceOrder.trackingNo = updatedOrder.trackingNo
+        marketplaceOrder.shippingProvider = updatedOrder.shippingProvider
+        await getRepository(MarketplaceOrder).save(marketplaceOrder)
+
+        for (let idx = 0; idx < marketplaceOrder.marketplaceOrderItems.length; idx++) {
+          let matchItem = updatedOrder.orderItems.find(
+            i => i.variationId == marketplaceOrder.marketplaceOrderItems[idx].marketplaceProductVariation.variationId
+          )
+
+          if (matchItem) {
+            let targetMarketplaceOrderItem = {
+              ...marketplaceOrder.marketplaceOrderItems[idx],
+              shippingProvider: matchItem.shippingProvider,
+              trackingCode: matchItem.trackingNo,
+              status: matchItem.status
+            }
+
+            await getRepository(MarketplaceOrderItem).save(targetMarketplaceOrderItem)
+          }
+        }
+      }
+    }
+
+    return true
+  }
+}

package/server/graphql/resolvers/marketplace-order/cancel-marketplace-order.ts

@@ -0,0 +1,64 @@
+import { Bizplace, getCustomerBizplaces } from '@things-factory/biz-base'
+import { FulfillmentAPI, FulfillmentCenter } from '@things-factory/integration-fulfillment'
+import { Domain } from '@things-factory/shell'
+
+import { MarketplaceOrder, MarketplaceOrderItem } from '../../../entities'
+
+export const cancelMarketplaceOrderResolver = {
+  async cancelMarketplaceOrder(_: any, { orderNo, patch }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    let marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+      where: { domain: { id: domain.id }, orderNo },
+      relations: ['fulfillmentCenter', 'marketplaceStore', 'marketplaceOrderItems']
+    })
+    if (!marketplaceOrder) throw new Error('No order is found')
+
+    let marketplaceOrderItems: MarketplaceOrderItem[] = marketplaceOrder.marketplaceOrderItems.map(orderItem => {
+      let marketplaceOrderItem: MarketplaceOrderItem = Object.assign({}, orderItem)
+      marketplaceOrderItem.reason = patch.remark
+      marketplaceOrderItem.status = 'cancelled'
+      marketplaceOrderItem.updater = user
+
+      return marketplaceOrderItem
+    })
+    await tx.getRepository(MarketplaceOrderItem).save(marketplaceOrderItems)
+
+    marketplaceOrder.status = 'cancelled'
+    marketplaceOrder.remark = patch.remark
+    marketplaceOrder.updater = user
+    marketplaceOrder = await tx.getRepository(MarketplaceOrder).save(marketplaceOrder)
+
+    const cancelStatuses: string[] = ['cancelled', 'canceled']
+    if (cancelStatuses.includes(marketplaceOrder.status) && marketplaceOrder?.releaseOrderId) {
+      if (marketplaceOrder.isSplitted) {
+        const fulfillmentCenter: FulfillmentCenter = marketplaceOrder.fulfillmentCenter
+        const centerId: string = fulfillmentCenter.centerId
+        const warehouseDomain: Domain = await tx.getRepository(Domain).findOne({ where: { subdomain: centerId } })
+        const customerBizplaces: Bizplace[] = await getCustomerBizplaces(warehouseDomain)
+        const customerBizplaceId: string = customerBizplaces[0].id
+
+        const { items: releaseOrders }: any = await FulfillmentAPI.getOutboundOrders(fulfillmentCenter, {
+          customerBizplaceId,
+          refNo: marketplaceOrder.orderNo
+        })
+        if (releaseOrders?.length) {
+          for (var a = 0; a < releaseOrders.length; a++) {
+            const releaseOrderId: string = releaseOrders[a].id
+            await FulfillmentAPI.cancelReleaseOrder(fulfillmentCenter, { customerBizplaceId, releaseOrderId })
+          }
+        }
+      } else {
+        const releaseOrderId: string = marketplaceOrder.releaseOrderId
+        const fulfillmentCenter: FulfillmentCenter = marketplaceOrder.fulfillmentCenter
+        const centerId: string = fulfillmentCenter.centerId
+
+        const warehouseDomain: Domain = await tx.getRepository(Domain).findOne({ where: { subdomain: centerId } })
+        const customerBizplaces: Bizplace[] = await getCustomerBizplaces(warehouseDomain)
+        const customerBizplaceId: string = customerBizplaces[0].id
+        await FulfillmentAPI.cancelReleaseOrder(fulfillmentCenter, { customerBizplaceId, releaseOrderId })
+      }
+    }
+
+    return marketplaceOrder
+  }
+}

package/server/graphql/resolvers/marketplace-order/create-marketplace-order-note.ts

@@ -0,0 +1,21 @@
+import { MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
+
+import { MarketplaceOrder } from '../../../entities'
+
+export const createMarketplaceOrderNote = {
+  async createMarketplaceOrderNote(_: any, { note, orderNo }, context: ResolverContext) {
+    const { tx } = context.state
+    let foundMarketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+      where: { name: orderNo },
+      relations: ['marketplaceStore']
+    })
+    if (!foundMarketplaceOrder) throw new Error('No order is found')
+
+    const storeId = foundMarketplaceOrder.marketplaceStore.id
+    const marketplaceStore: MarketplaceStore = await StoreAPI.getMarketplaceStore(storeId)
+
+    const orderNote = await StoreAPI.createOrderNote(marketplaceStore, { orderId: orderNo, note })
+
+    return true
+  }
+}

package/server/graphql/resolvers/marketplace-order/dashboard-marketplace-orders.ts

@@ -0,0 +1,82 @@
+import { getRepository } from '@things-factory/shell'
+
+import { ORDER_STATUS } from '../../../constants'
+import { MarketplaceOrder } from '../../../entities'
+
+export const dashboardMarketplaceOrdersResolver = {
+  async dashboardMarketplaceOrders(_: any, { dayCount, endDate }, context: ResolverContext) {
+    const domain = context.state.domain
+
+    if (!dayCount) dayCount = 7
+
+    // 1. initialize time interval
+    if (endDate && endDate !== '') {
+      endDate = new Date(`${endDate.split(' ').join('')}`)
+
+      if (endDate instanceof Date && !isNaN(endDate.getDate())) var timeNow = '23:59:59'
+      else throw new Error('endDate is invalid')
+    } else {
+      endDate = new Date()
+      var hh = `${String(endDate.getHours()).padStart(2, '0')}`
+      var mm = `${String(endDate.getMinutes()).padStart(2, '0')}`
+      var ss = `${String(endDate.getSeconds()).padStart(2, '0')}`
+      var timeNow = `${hh}:${mm}:${ss}`
+    }
+
+    // 2. set startDate & compare equal 7 days or dayCount before endDate
+    let startDate = new Date(endDate)
+    startDate.setDate(startDate.getDate() - dayCount)
+    startDate.setHours(0)
+    startDate.setMinutes(0)
+    startDate.setSeconds(0)
+
+    let compareDate = new Date(endDate)
+    compareDate.setDate(compareDate.getDate() - dayCount)
+    compareDate.setHours(0)
+    compareDate.setMinutes(0)
+    compareDate.setSeconds(0)
+
+    // 3. get orders data
+    const marketplaceOrders = await getRepository(MarketplaceOrder).query(`
+      select order_date, sum(cancelledCount) as cancelledCount, sum(nonCancelledCount) as nonCancelledCount from (
+        select date(mo.order_created_at) order_date,
+        case when mo.status = '${ORDER_STATUS.CANCELLED}' then 1 else 0 end as cancelledCount,
+        case when mo.status != '${ORDER_STATUS.CANCELLED}' then 1 else 0 end as nonCancelledCount
+        from marketplace_orders mo
+        where mo.order_created_at between '${startDate.toLocaleDateString()} 00:00:00' and '${endDate.toLocaleDateString()} ${timeNow}'
+        and mo.domain_id = '${domain.id}'
+      ) as foo
+      group by order_date
+      order by order_date asc
+    `)
+
+    // 4. initialize item array
+    let items = []
+    for (let i = 0; i < dayCount; i++) {
+      const month = startDate.toLocaleString('default', { month: 'short' })
+      const day = startDate.getDate()
+
+      items.push({
+        date: `${month} ${String(day).padStart(2, '0')}`,
+        cancelledCount: 0,
+        nonCancelledCount: 0
+      })
+      startDate.setDate(startDate.getDate() + 1)
+    }
+
+    // 5. assign sales data according to date
+    items = items.map(item => {
+      marketplaceOrders.forEach(order => {
+        if (order.order_date.toLocaleDateString() === compareDate.toLocaleDateString()) {
+          item.cancelledCount = order.cancelledcount
+          item.nonCancelledCount = order.noncancelledcount
+        }
+      })
+
+      compareDate.setDate(compareDate.getDate() + 1)
+      return item
+    })
+
+    return items
+  }
+}