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

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

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

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

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

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

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

@@ -1,312 +0,0 @@
-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`)
-    }
-  }
-}