@mx-cartographer/experiences 4.0.13 → 4.0.14-alpha.JB1

package/src/recurringactivity/components/shared/activitysettings/AddActivityDetails.tsx

@@ -0,0 +1,148 @@
+import React from 'react'
+import { observer } from 'mobx-react-lite'
+import { fromUnixTime } from 'date-fns/fromUnixTime'
+
+import MenuItem from '@mui/material/MenuItem'
+import Stack from '@mui/material/Stack'
+import TextField from '@mui/material/TextField'
+
+import { AdapterDateFns } from '@mui/x-date-pickers/AdapterDateFnsV3'
+import { DatePicker } from '@mui/x-date-pickers'
+import { LocalizationProvider } from '@mui/x-date-pickers/LocalizationProvider'
+
+import { Icon, Text } from '@kyper/mui'
+
+import { RecurrenceTypes, useGlobalCopyStore, type Transaction } from '../../../../common'
+import SubheaderRow from '../../../../common/components/SubheaderRow'
+
+import { TransactionRow } from '../../../../transactions'
+
+import {
+  fromUnixToDayOfWeekAndDate,
+  getNextBiMonthlyDate,
+  getNextBiQuarterlyDate,
+  getNextBiWeeklyDate,
+  getNextMonthlyDate,
+  getNextQuarterlyDate,
+  getNextWeeklyDate,
+  getNextYearlyDate,
+} from '../../../../common/utils/DateUtil'
+
+interface ActivityDetailsProps {
+  bgcolor?: string
+  frequency: RecurrenceTypes
+  isIncome: boolean
+  nextDate: Date | null
+  onFrequencyChange: (frequency: RecurrenceTypes) => void
+  onNextDateChange: (date: Date | null) => void
+  transaction: Transaction
+}
+
+const AddActivityDetails: React.FC<ActivityDetailsProps> = ({
+  bgcolor = 'background.default',
+  frequency,
+  isIncome,
+  nextDate,
+  onFrequencyChange,
+  onNextDateChange,
+  transaction,
+}) => {
+  const { recurring: recurringCopy } = useGlobalCopyStore()
+  const frequencies = [
+    { id: RecurrenceTypes.EveryWeek, label: recurringCopy.frequency_every_week },
+    { id: RecurrenceTypes.EveryOtherWeek, label: recurringCopy.frequency_every_other_week },
+    { id: RecurrenceTypes.EveryMonth, label: recurringCopy.frequency_every_month },
+    { id: RecurrenceTypes.EveryOtherMonth, label: recurringCopy.frequency_every_other_month },
+    { id: RecurrenceTypes.EveryQuarter, label: recurringCopy.frequency_every_quarter },
+    { id: RecurrenceTypes.EveryOtherQuarter, label: recurringCopy.frequency_every_other_quarter },
+    { id: RecurrenceTypes.EveryYear, label: recurringCopy.frequency_every_year },
+  ]
+
+  React.useEffect(() => {
+    // Calculate the next payment date based on monthly
+    const transactionDate = fromUnixTime(transaction.date)
+
+    onNextDateChange(getNextMonthlyDate(transactionDate))
+
+    // Default the frequency to Monthly
+    onFrequencyChange(RecurrenceTypes.EveryMonth)
+  }, [transaction])
+
+  const handleFrequencyChange = (e: React.ChangeEvent<HTMLTextAreaElement>) => {
+    const transactionDate = fromUnixTime(transaction.date)
+
+    switch (Number(e.target.value)) {
+      case RecurrenceTypes.EveryWeek:
+        onNextDateChange(getNextWeeklyDate(transactionDate))
+        break
+      case RecurrenceTypes.EveryOtherWeek:
+        onNextDateChange(getNextBiWeeklyDate(transactionDate))
+        break
+      case RecurrenceTypes.EveryMonth:
+        onNextDateChange(getNextMonthlyDate(transactionDate))
+        break
+      case RecurrenceTypes.EveryOtherMonth:
+        onNextDateChange(getNextBiMonthlyDate(transactionDate))
+        break
+      case RecurrenceTypes.EveryQuarter:
+        onNextDateChange(getNextQuarterlyDate(transactionDate))
+        break
+      case RecurrenceTypes.EveryOtherQuarter:
+        onNextDateChange(getNextBiQuarterlyDate(transactionDate))
+        break
+      case RecurrenceTypes.EveryYear:
+        onNextDateChange(getNextYearlyDate(transactionDate))
+        break
+    }
+    onFrequencyChange(Number(e.target.value))
+  }
+
+  return (
+    <Stack bgcolor={bgcolor} gap={24} height="100%">
+      <Stack>
+        <SubheaderRow bgcolor={bgcolor}>
+          {fromUnixToDayOfWeekAndDate(transaction.date)}
+        </SubheaderRow>
+        <TransactionRow transaction={transaction} />
+      </Stack>
+
+      <Text bold={true} sx={{ mx: 24 }} variant="Body">
+        {isIncome ? recurringCopy.income_schedule : recurringCopy.expense_schedule}
+      </Text>
+
+      <TextField
+        InputLabelProps={{ shrink: true }}
+        SelectProps={{
+          IconComponent: (props) => (
+            <Icon fill={false} name="expand_more" size={20} sx={{ mr: 4 }} {...props} />
+          ),
+        }}
+        defaultValue={0}
+        label={recurringCopy.frequency}
+        onChange={handleFrequencyChange}
+        select={true}
+        sx={{ mx: 24 }}
+        value={frequency}
+        variant="outlined"
+      >
+        {frequencies.map((frequency) => (
+          <MenuItem key={frequency.id} value={frequency.id}>
+            {frequency.label}
+          </MenuItem>
+        ))}
+      </TextField>
+
+      <LocalizationProvider dateAdapter={AdapterDateFns}>
+        <DatePicker
+          disablePast={true}
+          label={isIncome ? recurringCopy.income_date_label : recurringCopy.expense_date_label}
+          onChange={onNextDateChange}
+          sx={{ mx: 24 }}
+          value={nextDate}
+        />
+      </LocalizationProvider>
+    </Stack>
+  )
+}
+
+export default observer(AddActivityDetails)

package/src/recurringactivity/components/shared/activitysettings/ManageExpenses.tsx

@@ -0,0 +1,84 @@
+import React from 'react'
+import { parseISO } from 'date-fns/parseISO'
+import { observer } from 'mobx-react-lite'
+
+import Divider from '@mui/material/Divider'
+import List from '@mui/material/List'
+
+import {
+  Account,
+  Activity,
+  ActivityStatus,
+  ActivityType,
+  ANALYTICS_EVENTS,
+  ScheduledPayment,
+  Transaction,
+  useEvent,
+  useGlobalCopyStore,
+  useGlobalUiStore,
+  useRecurringActivityStore,
+  useTransactionStore,
+} from '../../../../common'
+import ActivityRow from '../../ActivityRow'
+import AddActivity from './AddActivity'
+
+const buildExpenses = (
+  accounts: Account[],
+  payments: ScheduledPayment[],
+  transactions: Transaction[],
+) => {
+  return payments.map((payment) => {
+    // TODO: Refactor to shared filter functions
+    const transaction = transactions.find((t) => t.scheduled_payment_guid === payment.guid)
+    const account = accounts.find((a) => a.guid === transaction?.account_guid)
+
+    return {
+      activityStatus: ActivityStatus.Upcoming,
+      activityType: ActivityType.Expense,
+      amount: payment.amount,
+      categoryGuid: transaction?.category_guid,
+      expectedDate: parseISO(payment.occurs_on),
+      name: payment.description,
+      institution: account?.user_name,
+      institutionGuid: account?.institution_guid,
+      merchantGuid: payment.merchant_guid,
+      recurrenceType: payment.recurrence_type,
+      recurrenceDay: payment.recurrence_day,
+      scheduledPaymentGuid: payment.guid,
+    } as Activity
+  })
+}
+
+const ManageExpenses = () => {
+  const { recurring: recurringCopy } = useGlobalCopyStore()
+  const { scheduledPayments } = useRecurringActivityStore()
+  const { transactions } = useTransactionStore()
+  const { selectedAccounts } = useGlobalUiStore()
+  const { onEvent } = useEvent()
+
+  const expenses = buildExpenses(selectedAccounts, scheduledPayments, transactions)
+
+  const onActivityClick = (activity: Activity) => {
+    onEvent(ANALYTICS_EVENTS.RECURRING_ACTIVITY_CLICK_EXPENSE, {
+      transaction_guid: activity.transactionGuid,
+    })
+  }
+
+  const onAddActivity = () => {
+    onEvent(ANALYTICS_EVENTS.RECURRING_ACTIVITY_CLICK_ADD_EXPENSE)
+  }
+
+  return (
+    <List sx={{ bgcolor: 'background.paper' }}>
+      {expenses.map((expense, index) => (
+        <React.Fragment key={expense.scheduledPaymentGuid}>
+          <ActivityRow activity={expense} onActivityClick={onActivityClick} showOrdinal={true} />
+          <Divider variant={index < expenses.length - 1 ? 'inset' : 'fullWidth'} />
+        </React.Fragment>
+      ))}
+      <AddActivity label={recurringCopy.add_expense} onAddActivity={onAddActivity} />
+    </List>
+  )
+}
+
+export default observer(ManageExpenses)

package/src/recurringactivity/components/shared/activitysettings/ManageIncome.tsx

@@ -0,0 +1,102 @@
+import React from 'react'
+import { observer } from 'mobx-react-lite'
+
+import Divider from '@mui/material/Divider'
+import List from '@mui/material/List'
+
+import {
+  Account,
+  Activity,
+  ActivityStatus,
+  ActivityType,
+  ANALYTICS_EVENTS,
+  CashflowEvent,
+  CashflowSequence,
+  Transaction,
+  useEvent,
+  useGlobalCopyStore,
+  useGlobalUiStore,
+  useRecurringActivityStore,
+  useTransactionStore,
+} from '../../../../common'
+import { fromUnixUTC } from '../../../../common/utils/DateUtil'
+import { getRecurrenceType } from '../../../util/buildActivities'
+import ActivityRow from '../../ActivityRow'
+import AddActivity from './AddActivity'
+
+const buildIncome = (
+  accounts: Account[],
+  events: CashflowEvent[],
+  projectedEvents: CashflowEvent[],
+  sequences: CashflowSequence[],
+  transactions: Transaction[],
+) => {
+  return sequences.map((sequence) => {
+    const event = events.find((e) => e.cashflow_sequence_guid === sequence.guid)
+    const projected = projectedEvents.find((e) => e.cashflow_sequence_guid === sequence.guid)
+    const transaction = transactions.find((t) => t.guid === event?.transaction_guid)
+    const account = accounts.find((a) => a.guid === transaction?.account_guid)
+
+    // Fallback in case both event and projected are null, which should never happen
+    let expectedDate = new Date()
+    if (event) {
+      expectedDate = fromUnixUTC(event.expected_date)
+    } else if (projected) {
+      expectedDate = fromUnixUTC(projected.expected_date)
+    }
+    return {
+      activityStatus: ActivityStatus.Upcoming,
+      activityType: ActivityType.Income,
+      amount: sequence.amount,
+      categoryGuid: event?.category_guid,
+      expectedDate: expectedDate,
+      name: sequence.name,
+      institution: account?.user_name,
+      institutionGuid: account?.institution_guid,
+      merchantGuid: transaction?.merchant_guid,
+      recurrenceType: getRecurrenceType(sequence),
+      recurrenceDay: Number(sequence.repeat_day),
+      sequenceGuid: sequence.guid,
+    } as Activity
+  })
+}
+
+const ManageIncome = () => {
+  const { recurring: recurringCopy } = useGlobalCopyStore()
+  const { selectedAccounts } = useGlobalUiStore()
+  const { cashflowEvents, cashflowSequences, projectedEvents } = useRecurringActivityStore()
+  const { transactions } = useTransactionStore()
+  const { onEvent } = useEvent()
+
+  const income = buildIncome(
+    selectedAccounts,
+    cashflowEvents,
+    projectedEvents,
+    cashflowSequences.filter((cs) => !cs.end_date),
+    transactions,
+  )
+
+  const onActivityClick = (activity: Activity) => {
+    onEvent(ANALYTICS_EVENTS.RECURRING_ACTIVITY_CLICK_INCOME, {
+      transaction_guid: activity.transactionGuid,
+    })
+  }
+
+  const onAddActivity = () => {
+    onEvent(ANALYTICS_EVENTS.RECURRING_ACTIVITY_CLICK_ADD_INCOME)
+  }
+
+  return (
+    <List sx={{ bgcolor: 'background.paper' }}>
+      {income.map((item, index) => (
+        <React.Fragment key={item.sequenceGuid}>
+          <ActivityRow activity={item} onActivityClick={onActivityClick} showOrdinal={true} />
+          <Divider variant={index < income.length - 1 ? 'inset' : 'fullWidth'} />
+        </React.Fragment>
+      ))}
+      <AddActivity isIncome={true} label={recurringCopy.add_income} onAddActivity={onAddActivity} />
+    </List>
+  )
+}
+
+export default observer(ManageIncome)

package/src/recurringactivity/components/shared/activitysettings/SelectTransaction.tsx

@@ -0,0 +1,45 @@
+import React from 'react'
+import { observer } from 'mobx-react-lite'
+
+import Stack from '@mui/material/Stack'
+
+import { P } from '@kyper/mui'
+
+import { SearchBox, useGlobalCopyStore } from '../../../../common'
+import { TransactionList, useTransactionsUiStore } from '../../../../transactions'
+
+interface SelectTransactionProps {
+  bgcolor?: string
+  description?: string
+  onSearch: (value: string) => void
+  onSelected: (guid: string) => void
+}
+
+const SelectTransaction: React.FC<SelectTransactionProps> = ({
+  bgcolor = 'background.default',
+  description,
+  onSearch,
+  onSelected,
+}) => {
+  const { recurring: recurringCopy } = useGlobalCopyStore()
+  const { searchValue, setSearchValue } = useTransactionsUiStore()
+
+  return (
+    <Stack sx={{ bgcolor, gap: 16, pt: 8 }}>
+      {description && <P sx={{ mx: 24 }}>{description}</P>}
+      <SearchBox
+        ariaLabel={recurringCopy.select_transaction_search_aria}
+        cancelAriaLabel={recurringCopy.select_transaction_search_cancel_aria}
+        onChange={(value) => {
+          setSearchValue(value)
+          onSearch(value)
+        }}
+        placeholder={recurringCopy.select_transaction_search_placeholder}
+        searchValue={searchValue}
+      />
+      <TransactionList bgcolor={bgcolor} height="auto" onClick={onSelected} showLoader={false} />
+    </Stack>
+  )
+}
+
+export default observer(SelectTransaction)

package/src/recurringactivity/index.ts

@@ -0,0 +1,5 @@
+export { default as ActivitySettings } from './components/shared/ActivitySettings'
+export { default as ManageIncome } from './components/shared/activitysettings/ManageIncome'
+export { default as RecurringActivityWidget } from './RecurringActivityWidget'
+export { default as RecurringActivityMiniWidget } from './RecurringActivityMiniWidget'
+export { RecurringActivityStore } from './stores/RecurringActivityStore'

package/src/recurringactivity/stores/RecurringActivityStore.ts

@@ -0,0 +1,312 @@
+import { makeAutoObservable, runInAction } from 'mobx'
+import { addDays } from 'date-fns/addDays'
+import { endOfMonth } from 'date-fns/endOfMonth'
+import { getUnixTime } from 'date-fns/getUnixTime'
+import { isAfter } from 'date-fns/isAfter'
+import { isSameDay } from 'date-fns/isSameDay'
+import { startOfMonth } from 'date-fns/startOfMonth'
+import { startOfToday } from 'date-fns/startOfToday'
+import { subDays } from 'date-fns/subDays'
+
+import {
+  type Activity,
+  ActivityStatus,
+  ActivityType,
+  CashflowEvent,
+  CashflowSequence,
+  GlobalStore,
+  isIncome,
+  ScheduledPayment,
+  ScheduledPaymentsApi,
+  Transaction,
+  TransactionType,
+} from '../../common'
+import { CashflowApi } from '../../cashflow'
+
+import { buildActivities } from '../util/buildActivities'
+
+export class RecurringActivityStore {
+  globalStore: GlobalStore
+  api = new ScheduledPaymentsApi('/', '')
+  cashflowApi = new CashflowApi('/', '')
+
+  cashflowSequences: CashflowSequence[] = []
+  cashflowEvents: CashflowEvent[] = []
+  projectedEvents: CashflowEvent[] = []
+  transactions: Transaction[] = []
+  scheduledPayments: ScheduledPayment[] = []
+  selectedDay: Date | undefined
+
+  isLoading: boolean = true
+
+  constructor(globalStore: GlobalStore) {
+    this.globalStore = globalStore
+
+    makeAutoObservable(this)
+  }
+
+  initialize = async (endpoint: string, token: string) => {
+    this.api = new ScheduledPaymentsApi(endpoint, token)
+    this.cashflowApi = new CashflowApi(endpoint, token)
+
+    this.loadActivity()
+  }
+
+  get activities() {
+    if (!this.isLoading) {
+      return buildActivities(
+        this.globalStore.accountStore.accounts,
+        this.cashflowEvents,
+        this.scheduledPayments,
+        this.projectedEvents,
+        this.cashflowSequences,
+        this.globalStore.transactionStore.transactions,
+      )
+    }
+    return []
+  }
+
+  get paidActivities(): Activity[] {
+    return this.activities.filter((a) => a.activityStatus === ActivityStatus.Paid)
+  }
+
+  get upcomingActivities(): Activity[] {
+    return this.activities.filter((a) => a.activityStatus === ActivityStatus.Upcoming)
+  }
+
+  get missedActivities(): Activity[] {
+    return this.activities.filter((a) => a.activityStatus === ActivityStatus.Missed)
+  }
+
+  get upcomingExpenses(): Activity[] {
+    return this.upcomingActivities.filter((a) => a.activityType === ActivityType.Expense)
+  }
+
+  get upcomingIncome(): Activity[] {
+    return this.upcomingActivities.filter((a) => a.activityType === ActivityType.Income)
+  }
+
+  get nextIncomeActivity(): Activity | undefined {
+    return this.upcomingIncome.find((a) => isAfter(a.expectedDate, startOfToday()))
+  }
+
+  get selectedDayActivities(): Activity[] | undefined {
+    return (
+      this.selectedDay &&
+      this.activities.filter(
+        (a) => this.selectedDay && isSameDay(a.occurredOnDate || a.expectedDate, this.selectedDay),
+      )
+    )
+  }
+
+  get projectedIncome(): number {
+    const categories = this.globalStore.categoryStore.categories
+    return this.cashflowSequences
+      .filter((cs) => cs.transaction_type === TransactionType.CREDIT)
+      .filter((cs) => isIncome(categories, cs.category_guid || ''))
+      .reduce((acc, current) => acc + current.amount, 0)
+  }
+
+  addCashflowEvent = async (cashflowEvent: CashflowEvent) => {
+    try {
+      const event = await this.cashflowApi.addCashflowEvent(cashflowEvent)
+
+      runInAction(() => {
+        this.cashflowEvents = [...this.cashflowEvents, event]
+      })
+    } catch (error) {
+      console.error(`Error adding cashflow event: ${error}`)
+    }
+  }
+
+  addCashflowSequence = async (
+    cashflowSequence: CashflowSequence,
+  ): Promise<CashflowSequence | undefined> => {
+    try {
+      const sequence = await this.cashflowApi.addCashflowSequence(cashflowSequence)
+
+      // Reload all income activity
+      await this.loadIncomeActivity()
+
+      return sequence
+    } catch (error) {
+      console.error(`Error adding cashflow sequence: ${error}`)
+    }
+    return undefined
+  }
+
+  addScheduledPayment = async (scheduledPayemnt: ScheduledPayment, transaction: Transaction) => {
+    try {
+      const payment = await this.api.addScheduledPayment(scheduledPayemnt)
+      await this.globalStore.transactionStore.updateTransaction({
+        ...transaction,
+        scheduled_payment_guid: payment.guid,
+      })
+
+      runInAction(() => {
+        this.scheduledPayments = [...this.scheduledPayments, payment]
+      })
+    } catch (error) {
+      console.error(`Error adding scheduled payment: ${error}`)
+    }
+  }
+
+  deleteCashflowSequence = async (guid: string) => {
+    try {
+      await this.cashflowApi.deleteCashflowSequence(guid)
+
+      // Reload all income activity
+      await this.loadIncomeActivity()
+    } catch (error) {
+      console.error(`Error deleting cashflow sequence`)
+    }
+  }
+
+  deleteScheduledPayment = async (guid: string) => {
+    try {
+      await this.api.deleteScheduledPayment(guid)
+
+      runInAction(() => {
+        const index = this.scheduledPayments.findIndex((sp) => sp.guid === guid)
+        if (index >= 0) {
+          this.scheduledPayments.splice(index, 1)
+        }
+      })
+    } catch (error) {
+      console.error(`Error deleting scheduled payent: ${error}`)
+    }
+  }
+
+  loadActivity = () => {
+    this.isLoading = true
+
+    Promise.all([this.loadExpenseActivity(), this.loadIncomeActivity()]).finally(() =>
+      runInAction(() => {
+        this.isLoading = false
+      }),
+    )
+  }
+
+  loadExpenseActivity = async () => {
+    await this.loadScheduledPayments()
+  }
+
+  loadIncomeActivity = async () => {
+    await this.loadCashflowSequences()
+    await this.loadExpectedEvents()
+    await this.loadPaidEvents()
+  }
+
+  loadCashflowSequences = async () => {
+    const sequences = await this.cashflowApi.getCashflowSequences()
+
+    runInAction(() => {
+      this.cashflowSequences = sequences.filter(
+        (s) => s.transaction_type === TransactionType.CREDIT,
+      )
+    })
+  }
+
+  loadExpectedEvents = async () => {
+    try {
+      const events = await this.cashflowApi.getProjectedCashflowEvents(
+        startOfMonth(startOfToday()),
+        addDays(startOfToday(), 30),
+      )
+
+      runInAction(() => {
+        this.projectedEvents = events.filter(
+          (evt) => evt.transaction_type === TransactionType.CREDIT,
+        )
+      })
+    } catch (error) {
+      console.error(`Error occurred while getting projected events: ${error}`)
+    }
+  }
+
+  loadPaidEvents = async () => {
+    try {
+      const events = await this.cashflowApi.getCashflowEventsByDateRange(
+        subDays(startOfToday(), 90),
+        endOfMonth(startOfToday()),
+      )
+
+      runInAction(() => {
+        this.cashflowEvents = events.filter(
+          (evt) => evt.transaction_type === TransactionType.CREDIT,
+        )
+      })
+    } catch (error) {
+      console.error(`Error occurred while getting cashflow events: ${error}`)
+    }
+  }
+
+  loadScheduledPayments = async () => {
+    try {
+      const scheduledPayments = (await this.api.getScheduledPayments()) as ScheduledPayment[]
+
+      runInAction(() => {
+        this.scheduledPayments = scheduledPayments
+      })
+    } catch (error) {
+      console.error(`Error occurred while getting scheduled payments: ${error}`)
+    }
+  }
+
+  setSelectedDay = (day: Date) => {
+    this.selectedDay = this.selectedDay && isSameDay(day, this.selectedDay) ? undefined : day
+  }
+
+  updateCashflowSequence = async (sequence: CashflowSequence) => {
+    try {
+      const hasEvents = Boolean(
+        this.cashflowEvents.find((e) => e.cashflow_sequence_guid === sequence.guid),
+      )
+
+      if (hasEvents) {
+        // Update existing sequence with enddate
+        const existingSequence = this.cashflowSequences.find((c) => c.guid === sequence.guid)
+        if (!existingSequence) return // TODO: Consider throwing an error
+
+        const lastEvent = this.cashflowEvents.findLast((c) => c.guid === sequence.guid)
+        await this.cashflowApi.updateCashflowSequence({
+          ...existingSequence,
+          end_date: lastEvent?.occurred_on || getUnixTime(new Date()),
+        })
+
+        // Create a new sequence
+        await this.addCashflowSequence({
+          ...sequence,
+          guid: undefined,
+        })
+      } else {
+        // Update current sequence
+        await this.cashflowApi.updateCashflowSequence(sequence)
+      }
+
+      // Reload all income activity
+      await this.loadIncomeActivity()
+    } catch (error) {
+      console.error(`Error updating cashflow sequence: ${error}`)
+    }
+  }
+
+  updateScheduledPayment = async (payment: ScheduledPayment) => {
+    try {
+      const updatedPayment = await this.api.updateScheduledPayment(payment)
+
+      const index = this.scheduledPayments.findIndex((sp) => sp.guid === payment.guid)
+      if (index < 0) return
+
+      runInAction(() => {
+        this.scheduledPayments = [
+          ...this.scheduledPayments.slice(0, index),
+          updatedPayment,
+          ...this.scheduledPayments.slice(index + 1),
+        ]
+      })
+    } catch (error) {
+      console.error(`Error occurred while updating schedule payment`)
+    }
+  }
+}