@things-factory/marketplace-base 8.0.7 → 9.0.0-beta.12

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

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

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

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

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

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

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

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

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

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