MaysWind
804 lines
36 KiB
TypeScript
804 lines
36 KiB
TypeScript
import { ref, computed } from 'vue';
|
|
import { defineStore } from 'pinia';
|
|
|
|
import { useSettingsStore } from './setting.ts';
|
|
import { useUserStore } from './user.ts';
|
|
import { useAccountsStore } from './account.ts';
|
|
import { useTransactionCategoriesStore } from './transactionCategory.ts';
|
|
import { useTransactionTagsStore } from './transactionTag.ts';
|
|
import { useExchangeRatesStore } from './exchangeRates.ts';
|
|
|
|
import { itemAndIndex, values } from '@/core/base.ts';
|
|
import { AmountFilterType } from '@/core/numeral.ts';
|
|
import { DateRangeScene, DateRange } from '@/core/datetime.ts';
|
|
import { TimezoneTypeForStatistics } from '@/core/timezone.ts';
|
|
import { AccountCategory } from '@/core/account.ts';
|
|
import { TransactionType } from '@/core/transaction.ts';
|
|
import {
|
|
TransactionExploreChartTypeValue,
|
|
TransactionExploreChartType,
|
|
TransactionExploreDataDimensionType,
|
|
TransactionExploreDataDimension,
|
|
TransactionExploreValueMetricType,
|
|
TransactionExploreValueMetric,
|
|
DEFAULT_TRANSACTION_EXPLORE_DATE_RANGE
|
|
} from '@/core/explore.ts';
|
|
|
|
import { type Account } from '@/models/account.ts';
|
|
import { type TransactionCategory } from '@/models/transaction_category.ts';
|
|
import { type TransactionTag } from '@/models/transaction_tag.ts';
|
|
import {
|
|
type TransactionInfoResponse,
|
|
type TransactionInsightDataItem
|
|
} from '@/models/transaction.ts';
|
|
import {
|
|
TransactionExploreQuery
|
|
} from '@/models/explore.ts';
|
|
|
|
import {
|
|
isDefined,
|
|
isNumber,
|
|
isInteger,
|
|
isEquals,
|
|
} from '@/lib/common.ts';
|
|
import {
|
|
getYearFirstUnixTimeBySpecifiedUnixTime,
|
|
getQuarterFirstUnixTimeBySpecifiedUnixTime,
|
|
getMonthFirstUnixTimeBySpecifiedUnixTime,
|
|
getDayFirstUnixTimeBySpecifiedUnixTime,
|
|
getDateRangeByDateType,
|
|
getFiscalYearStartUnixTime
|
|
} from '@/lib/datetime.ts';
|
|
import services from '@/lib/services.ts';
|
|
import logger from '@/lib/logger.ts';
|
|
|
|
export enum TransactionExploreDimensionType {
|
|
TransactionType = 'transactionType',
|
|
Category = 'category',
|
|
Account = 'account',
|
|
Amount = 'amount',
|
|
Other = 'other'
|
|
}
|
|
|
|
export interface TransactionExplorePartialFilter {
|
|
dateRangeType?: number;
|
|
startTime?: number;
|
|
endTime?: number;
|
|
queryId?: string;
|
|
chartType?: TransactionExploreChartTypeValue;
|
|
categoryDimension?: TransactionExploreDataDimensionType;
|
|
seriesDimension?: TransactionExploreDataDimensionType;
|
|
valueMetric?: TransactionExploreValueMetricType;
|
|
}
|
|
|
|
export interface TransactionExploreFilter extends TransactionExplorePartialFilter {
|
|
dateRangeType: number;
|
|
startTime: number;
|
|
endTime: number;
|
|
query: TransactionExploreQuery[];
|
|
chartType: TransactionExploreChartTypeValue;
|
|
categoryDimension: TransactionExploreDataDimensionType;
|
|
seriesDimension: TransactionExploreDataDimensionType;
|
|
valueMetric: TransactionExploreValueMetricType;
|
|
}
|
|
|
|
export interface CategoriedInfo {
|
|
categoryName: string;
|
|
categoryNameNeedI18n?: boolean;
|
|
categoryNameI18nParameters?: Record<string, string>;
|
|
categoryId: string;
|
|
categoryIdType: TransactionExploreDimensionType;
|
|
}
|
|
|
|
export interface CategoriedTransactions extends CategoriedInfo {
|
|
trasactions: Record<string, SeriesedTransactions>;
|
|
}
|
|
|
|
export interface CategoriedTransactionExploreData extends CategoriedInfo {
|
|
data: CategoriedTransactionExploreDataItem[];
|
|
}
|
|
|
|
export interface SeriesedInfo {
|
|
seriesName: string;
|
|
seriesNameNeedI18n?: boolean;
|
|
seriesNameI18nParameters?: Record<string, string>;
|
|
seriesId: string;
|
|
seriesIdType: TransactionExploreDimensionType;
|
|
}
|
|
|
|
export interface SeriesedTransactions extends SeriesedInfo {
|
|
trasactions: TransactionInsightDataItem[];
|
|
}
|
|
|
|
export interface CategoriedTransactionExploreDataItem extends SeriesedInfo {
|
|
value: number;
|
|
}
|
|
|
|
export const useExploresStore = defineStore('explores', () => {
|
|
const settingsStore = useSettingsStore();
|
|
const userStore = useUserStore();
|
|
const accountsStore = useAccountsStore();
|
|
const transactionCategoriesStore = useTransactionCategoriesStore();
|
|
const transactionTagsStore = useTransactionTagsStore();
|
|
const exchangeRatesStore = useExchangeRatesStore();
|
|
|
|
function getDataCategoryInfo(dimension: TransactionExploreDataDimension, queryName: string, queryIndex: number, transaction: TransactionInsightDataItem): CategoriedInfo {
|
|
let transactionTimeUtfOffset: number | undefined = undefined;
|
|
|
|
if (settingsStore.appSettings.timezoneUsedForInsightsExplorePage === TimezoneTypeForStatistics.TransactionTimezone.type) {
|
|
transactionTimeUtfOffset = transaction.utcOffset;
|
|
}
|
|
|
|
if (dimension === TransactionExploreDataDimension.None) {
|
|
const valueMetric = TransactionExploreValueMetric.valueOf(transactionExploreFilter.value.valueMetric);
|
|
return {
|
|
categoryName: valueMetric?.name ?? 'Unknown',
|
|
categoryNameNeedI18n: true,
|
|
categoryId: 'none',
|
|
categoryIdType: TransactionExploreDimensionType.Other
|
|
};
|
|
} else if (dimension === TransactionExploreDataDimension.Query) {
|
|
if (queryName) {
|
|
return {
|
|
categoryName: queryName,
|
|
categoryId: (queryIndex + 1).toString(10),
|
|
categoryIdType: TransactionExploreDimensionType.Other
|
|
};
|
|
} else {
|
|
return {
|
|
categoryName: `format.misc.queryIndex`,
|
|
categoryNameNeedI18n: true,
|
|
categoryNameI18nParameters: {
|
|
index: (queryIndex + 1).toString(10)
|
|
},
|
|
categoryId: (queryIndex + 1).toString(10),
|
|
categoryIdType: TransactionExploreDimensionType.Other
|
|
};
|
|
}
|
|
} else if (dimension === TransactionExploreDataDimension.DateTime) {
|
|
const unixTime = transaction.time.toString(10);
|
|
|
|
return {
|
|
categoryName: unixTime,
|
|
categoryId: unixTime,
|
|
categoryIdType: TransactionExploreDimensionType.Other
|
|
};
|
|
} else if (dimension === TransactionExploreDataDimension.DateTimeByYearMonthDay) {
|
|
const unixTime = getDayFirstUnixTimeBySpecifiedUnixTime(transaction.time, transactionTimeUtfOffset).toString(10);
|
|
|
|
return {
|
|
categoryName: unixTime,
|
|
categoryId: unixTime,
|
|
categoryIdType: TransactionExploreDimensionType.Other
|
|
};
|
|
} else if (dimension === TransactionExploreDataDimension.DateTimeByYearMonth) {
|
|
const unixTime = getMonthFirstUnixTimeBySpecifiedUnixTime(transaction.time, transactionTimeUtfOffset).toString(10);
|
|
|
|
return {
|
|
categoryName: unixTime,
|
|
categoryId: unixTime,
|
|
categoryIdType: TransactionExploreDimensionType.Other
|
|
};
|
|
} else if (dimension === TransactionExploreDataDimension.DateTimeByYearQuarter) {
|
|
const unixTime = getQuarterFirstUnixTimeBySpecifiedUnixTime(transaction.time, transactionTimeUtfOffset).toString(10);
|
|
|
|
return {
|
|
categoryName: unixTime,
|
|
categoryId: unixTime,
|
|
categoryIdType: TransactionExploreDimensionType.Other
|
|
};
|
|
} else if (dimension === TransactionExploreDataDimension.DateTimeByYear) {
|
|
const unixTime = getYearFirstUnixTimeBySpecifiedUnixTime(transaction.time, transactionTimeUtfOffset).toString(10);
|
|
|
|
return {
|
|
categoryName: unixTime,
|
|
categoryId: unixTime,
|
|
categoryIdType: TransactionExploreDimensionType.Other
|
|
};
|
|
} else if (dimension === TransactionExploreDataDimension.DateTimeByFiscalYear) {
|
|
const unixTime = getFiscalYearStartUnixTime(transaction.time, userStore.currentUserFiscalYearStart, transactionTimeUtfOffset).toString(10);
|
|
|
|
return {
|
|
categoryName: unixTime,
|
|
categoryId: unixTime,
|
|
categoryIdType: TransactionExploreDimensionType.Other
|
|
};
|
|
} else if (dimension === TransactionExploreDataDimension.TransactionType) {
|
|
let transactionTypeName = 'Unknown';
|
|
|
|
if (transaction.type === TransactionType.ModifyBalance) {
|
|
transactionTypeName = 'Modify Balance';
|
|
} else if (transaction.type === TransactionType.Income) {
|
|
transactionTypeName = 'Income';
|
|
} else if (transaction.type === TransactionType.Expense) {
|
|
transactionTypeName = 'Expense';
|
|
} else if (transaction.type === TransactionType.Transfer) {
|
|
transactionTypeName = 'Transfer';
|
|
}
|
|
|
|
return {
|
|
categoryName: transactionTypeName,
|
|
categoryNameNeedI18n: true,
|
|
categoryId: transaction.type.toString(10),
|
|
categoryIdType: TransactionExploreDimensionType.TransactionType
|
|
};
|
|
} else if (dimension === TransactionExploreDataDimension.SourceAccount) {
|
|
return {
|
|
categoryName: transaction.sourceAccountName || 'Unknown',
|
|
categoryNameNeedI18n: !transaction.sourceAccountName,
|
|
categoryId: transaction.sourceAccountId || 'unknown',
|
|
categoryIdType: TransactionExploreDimensionType.Account
|
|
};
|
|
} else if (dimension === TransactionExploreDataDimension.SourceAccountCategory) {
|
|
const accountCategory = AccountCategory.valueOf(transaction.sourceAccount.category);
|
|
|
|
return {
|
|
categoryName: accountCategory?.name || 'Unknown',
|
|
categoryNameNeedI18n: true,
|
|
categoryId: accountCategory?.type.toString(10) || 'unknown',
|
|
categoryIdType: TransactionExploreDimensionType.Other
|
|
};
|
|
} else if (dimension === TransactionExploreDataDimension.SourceAccountCurrency) {
|
|
return {
|
|
categoryName: transaction.sourceAccount.currency || 'Unknown',
|
|
categoryNameNeedI18n: !transaction.sourceAccount.currency,
|
|
categoryId: transaction.sourceAccount.currency || 'unknown',
|
|
categoryIdType: TransactionExploreDimensionType.Other
|
|
};
|
|
} else if (dimension === TransactionExploreDataDimension.DestinationAccount) {
|
|
return {
|
|
categoryName: transaction.type === TransactionType.Transfer ? (transaction.destinationAccountName || 'Unknown') : 'None',
|
|
categoryNameNeedI18n: transaction.type !== TransactionType.Transfer || !transaction.destinationAccountName,
|
|
categoryId: transaction.type === TransactionType.Transfer ? (transaction.destinationAccountId || 'unknown') : 'none',
|
|
categoryIdType: TransactionExploreDimensionType.Account
|
|
};
|
|
} else if (dimension === TransactionExploreDataDimension.DestinationAccountCategory) {
|
|
const accountCategory = transaction.type === TransactionType.Transfer && transaction.destinationAccount ? AccountCategory.valueOf(transaction.destinationAccount.category) : undefined;
|
|
|
|
return {
|
|
categoryName: transaction.type === TransactionType.Transfer ? (accountCategory?.name || 'Unknown') : 'None',
|
|
categoryNameNeedI18n: true,
|
|
categoryId: transaction.type === TransactionType.Transfer ? (accountCategory?.name || 'unknown') : 'none',
|
|
categoryIdType: TransactionExploreDimensionType.Other
|
|
};
|
|
} else if (dimension === TransactionExploreDataDimension.DestinationAccountCurrency) {
|
|
return {
|
|
categoryName: transaction.type === TransactionType.Transfer ? (transaction.destinationAccount?.currency || 'Unknown') : 'None',
|
|
categoryNameNeedI18n: transaction.type !== TransactionType.Transfer || !transaction.destinationAccount?.currency,
|
|
categoryId: transaction.type === TransactionType.Transfer ? (transaction.destinationAccount?.currency || 'unknown') : 'none',
|
|
categoryIdType: TransactionExploreDimensionType.Other
|
|
};
|
|
} else if (dimension === TransactionExploreDataDimension.PrimaryCategory) {
|
|
return {
|
|
categoryName: transaction.primaryCategory.name,
|
|
categoryId: transaction.primaryCategory.id,
|
|
categoryIdType: TransactionExploreDimensionType.Category
|
|
};
|
|
} else if (dimension === TransactionExploreDataDimension.SecondaryCategory) {
|
|
return {
|
|
categoryName: transaction.secondaryCategory.name,
|
|
categoryId: transaction.categoryId,
|
|
categoryIdType: TransactionExploreDimensionType.Category
|
|
};
|
|
} else if (dimension === TransactionExploreDataDimension.SourceAmount) {
|
|
return {
|
|
categoryName: transaction.sourceAmount.toString(10),
|
|
categoryId: transaction.sourceAmount.toString(10),
|
|
categoryIdType: TransactionExploreDimensionType.Amount
|
|
};
|
|
} else if (dimension === TransactionExploreDataDimension.DestinationAmount) {
|
|
return {
|
|
categoryName: transaction.type === TransactionType.Transfer ? transaction.destinationAmount.toString(10) : 'None',
|
|
categoryNameNeedI18n: transaction.type !== TransactionType.Transfer,
|
|
categoryId: transaction.type === TransactionType.Transfer ? transaction.destinationAmount.toString(10) : 'none',
|
|
categoryIdType: TransactionExploreDimensionType.Other
|
|
};
|
|
} else {
|
|
return {
|
|
categoryName: '',
|
|
categoryId: '',
|
|
categoryIdType: TransactionExploreDimensionType.Other
|
|
};
|
|
}
|
|
}
|
|
|
|
function addTransactionToCategoriedDataMap(categoriedDataMap: Record<string, CategoriedTransactions>, categoryDimension: TransactionExploreDataDimension, seriesDemension: TransactionExploreDataDimension, queryName: string, queryIndex: number, transaction: TransactionInsightDataItem): void {
|
|
const categoriedInfo = getDataCategoryInfo(categoryDimension, queryName, queryIndex, transaction);
|
|
let categoriedData = categoriedDataMap[categoriedInfo.categoryId];
|
|
|
|
if (!categoriedData) {
|
|
categoriedData = {
|
|
categoryName: categoriedInfo.categoryName,
|
|
categoryNameNeedI18n: categoriedInfo.categoryNameNeedI18n,
|
|
categoryNameI18nParameters: categoriedInfo.categoryNameI18nParameters,
|
|
categoryId: categoriedInfo.categoryId,
|
|
categoryIdType: categoriedInfo.categoryIdType,
|
|
trasactions: {}
|
|
};
|
|
categoriedDataMap[categoriedInfo.categoryId] = categoriedData;
|
|
}
|
|
|
|
const seriesedInfo = getDataCategoryInfo(seriesDemension, queryName, queryIndex, transaction);
|
|
let seriesedData = categoriedData.trasactions[seriesedInfo.categoryId];
|
|
|
|
if (!seriesedData) {
|
|
seriesedData = {
|
|
seriesName: seriesedInfo.categoryName,
|
|
seriesNameNeedI18n: seriesedInfo.categoryNameNeedI18n,
|
|
seriesNameI18nParameters: seriesedInfo.categoryNameI18nParameters,
|
|
seriesId: seriesedInfo.categoryId,
|
|
seriesIdType: seriesedInfo.categoryIdType,
|
|
trasactions: []
|
|
};
|
|
categoriedData.trasactions[seriesedInfo.categoryId] = seriesedData;
|
|
}
|
|
|
|
seriesedData.trasactions.push(transaction);
|
|
}
|
|
|
|
const transactionExploreFilter = ref<TransactionExploreFilter>({
|
|
dateRangeType: DEFAULT_TRANSACTION_EXPLORE_DATE_RANGE.type,
|
|
startTime: 0,
|
|
endTime: 0,
|
|
query: [],
|
|
categoryDimension: TransactionExploreDataDimension.CategoryDimensionDefault.value,
|
|
seriesDimension: TransactionExploreDataDimension.SeriesDimensionDefault.value,
|
|
valueMetric: TransactionExploreValueMetric.Default.value,
|
|
chartType: TransactionExploreChartType.Default.value
|
|
});
|
|
|
|
const transactionExploreAllData = ref<TransactionInfoResponse[]>([]);
|
|
const transactionExploreStateInvalid = ref<boolean>(true);
|
|
|
|
const allTransactions = computed<TransactionInsightDataItem[]>(() => {
|
|
if (!transactionExploreAllData.value || transactionExploreAllData.value.length < 1) {
|
|
return [];
|
|
}
|
|
|
|
const result: TransactionInsightDataItem[] = [];
|
|
|
|
for (const transaction of transactionExploreAllData.value) {
|
|
const sourceAccount: Account | undefined = accountsStore.allAccountsMap[transaction.sourceAccountId];
|
|
|
|
if (!sourceAccount) {
|
|
continue;
|
|
}
|
|
|
|
let destinationAccount: Account | undefined = undefined
|
|
|
|
if (transaction.destinationAccountId && transaction.destinationAccountId !== '0') {
|
|
destinationAccount = accountsStore.allAccountsMap[transaction.destinationAccountId];
|
|
|
|
if (!destinationAccount) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
const secondaryCategory: TransactionCategory | undefined = transactionCategoriesStore.allTransactionCategoriesMap[transaction.categoryId];
|
|
|
|
if (!secondaryCategory) {
|
|
continue;
|
|
}
|
|
|
|
const primaryCategory: TransactionCategory | undefined = transactionCategoriesStore.allTransactionCategoriesMap[secondaryCategory.parentId];
|
|
|
|
if (!primaryCategory) {
|
|
continue;
|
|
}
|
|
|
|
const tags: TransactionTag[] = [];
|
|
|
|
for (const tagId of transaction.tagIds) {
|
|
const tag: TransactionTag | undefined = transactionTagsStore.allTransactionTagsMap[tagId];
|
|
|
|
if (tag) {
|
|
tags.push(tag);
|
|
}
|
|
}
|
|
|
|
const item: TransactionInsightDataItem = {
|
|
...transaction,
|
|
id: transaction.id,
|
|
time: transaction.time,
|
|
utcOffset: transaction.utcOffset,
|
|
type: transaction.type,
|
|
primaryCategory: primaryCategory,
|
|
primaryCategoryName: primaryCategory.name,
|
|
secondaryCategory: secondaryCategory,
|
|
secondaryCategoryName: secondaryCategory.name,
|
|
sourceAccount: sourceAccount,
|
|
sourceAccountName: sourceAccount.name,
|
|
destinationAccount: destinationAccount,
|
|
destinationAccountName: destinationAccount?.name,
|
|
sourceAmount: transaction.sourceAmount,
|
|
destinationAmount: transaction.destinationAmount,
|
|
hideAmount: transaction.hideAmount,
|
|
tags: tags,
|
|
comment: transaction.comment,
|
|
geoLocation: transaction.geoLocation
|
|
};
|
|
|
|
result.push(item);
|
|
}
|
|
|
|
return result;
|
|
});
|
|
|
|
const filteredTransactions = computed<TransactionInsightDataItem[]>(() => {
|
|
if (!allTransactions.value || allTransactions.value.length < 1) {
|
|
return [];
|
|
}
|
|
|
|
if (!transactionExploreFilter.value.query || transactionExploreFilter.value.query.length < 1) {
|
|
return allTransactions.value;
|
|
}
|
|
|
|
const result: TransactionInsightDataItem[] = [];
|
|
|
|
for (const transaction of allTransactions.value) {
|
|
for (const query of transactionExploreFilter.value.query) {
|
|
if (query.match(transaction)) {
|
|
result.push(transaction);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
});
|
|
|
|
const categoriedTransactions = computed<Record<string, CategoriedTransactions>>(() => {
|
|
if (!allTransactions.value || allTransactions.value.length < 1) {
|
|
return {};
|
|
}
|
|
|
|
const chartType = TransactionExploreChartType.valueOf(transactionExploreFilter.value.chartType);
|
|
const categoryDimension = TransactionExploreDataDimension.valueOf(transactionExploreFilter.value.categoryDimension);
|
|
const seriesDimension = chartType?.seriesDimensionRequired ? TransactionExploreDataDimension.valueOf(transactionExploreFilter.value.seriesDimension) : TransactionExploreDataDimension.SeriesDimensionDefault;
|
|
|
|
if (!chartType || !categoryDimension || !seriesDimension) {
|
|
return {};
|
|
}
|
|
|
|
const categoriedDataMap: Record<string, CategoriedTransactions> = {};
|
|
|
|
for (const transaction of allTransactions.value) {
|
|
if (!transactionExploreFilter.value.query || transactionExploreFilter.value.query.length < 1) {
|
|
addTransactionToCategoriedDataMap(categoriedDataMap, categoryDimension, seriesDimension, '', 0, transaction);
|
|
continue;
|
|
}
|
|
|
|
for (const [query, index] of itemAndIndex(transactionExploreFilter.value.query)) {
|
|
if (query.match(transaction)) {
|
|
addTransactionToCategoriedDataMap(categoriedDataMap, categoryDimension, seriesDimension, query.name, index, transaction);
|
|
|
|
if (categoryDimension !== TransactionExploreDataDimension.Query) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return categoriedDataMap;
|
|
});
|
|
|
|
const categoriedTransactionExploreData = computed<CategoriedTransactionExploreData[]>(() => {
|
|
if (!allTransactions.value || allTransactions.value.length < 1) {
|
|
return [];
|
|
}
|
|
|
|
const chartType = TransactionExploreChartType.valueOf(transactionExploreFilter.value.chartType);
|
|
const categoryDimension = TransactionExploreDataDimension.valueOf(transactionExploreFilter.value.categoryDimension);
|
|
const seriesDimension = chartType?.seriesDimensionRequired ? TransactionExploreDataDimension.valueOf(transactionExploreFilter.value.seriesDimension) : TransactionExploreDataDimension.SeriesDimensionDefault;
|
|
const valueMetric = TransactionExploreValueMetric.valueOf(transactionExploreFilter.value.valueMetric);
|
|
|
|
if (!chartType || !categoryDimension || !seriesDimension || !valueMetric) {
|
|
return [];
|
|
}
|
|
|
|
const defaultCurrency = userStore.currentUserDefaultCurrency;
|
|
const result: CategoriedTransactionExploreData[] = [];
|
|
const categoriedDataMap = categoriedTransactions.value;
|
|
|
|
for (const categoriedTransactions of values(categoriedDataMap)) {
|
|
const dataItems: CategoriedTransactionExploreDataItem[] = [];
|
|
let allSeriesedTransactions: Record<string, SeriesedTransactions> = categoriedTransactions.trasactions;
|
|
|
|
// merge all series into one for pie/radar chart
|
|
if (chartType === TransactionExploreChartType.Pie || chartType === TransactionExploreChartType.Radar) {
|
|
const transactions: TransactionInsightDataItem[] = [];
|
|
|
|
for (const seriesedTransactions of values(categoriedTransactions.trasactions)) {
|
|
transactions.push(...seriesedTransactions.trasactions);
|
|
}
|
|
|
|
allSeriesedTransactions = {};
|
|
allSeriesedTransactions['none'] = {
|
|
seriesName: valueMetric?.name ?? 'Unknown',
|
|
seriesNameNeedI18n: true,
|
|
seriesId: 'none',
|
|
seriesIdType: TransactionExploreDimensionType.Other,
|
|
trasactions: transactions
|
|
};
|
|
}
|
|
|
|
for (const seriesedTransactions of values(allSeriesedTransactions)) {
|
|
const allSourceAmountsInDefaultCurrency: number[] = [];
|
|
let totalSourceAmountSumInDefaultCurrency: number = 0;
|
|
let minimumSourceAmountInDefaultCurrency: number = Number.MAX_SAFE_INTEGER;
|
|
let maximumSourceAmountInDefaultCurrency: number = Number.MIN_SAFE_INTEGER;
|
|
|
|
for (const transaction of seriesedTransactions.trasactions) {
|
|
let amountInDefaultCurrency: number = transaction.sourceAmount;
|
|
|
|
if (transaction.sourceAccount.currency !== defaultCurrency) {
|
|
const amount = exchangeRatesStore.getExchangedAmount(transaction.sourceAmount, transaction.sourceAccount.currency, defaultCurrency);
|
|
|
|
if (isNumber(amount)) {
|
|
amountInDefaultCurrency = Math.trunc(amount);
|
|
} else {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
allSourceAmountsInDefaultCurrency.push(amountInDefaultCurrency);
|
|
totalSourceAmountSumInDefaultCurrency += amountInDefaultCurrency;
|
|
|
|
if (amountInDefaultCurrency >= 0 && amountInDefaultCurrency < minimumSourceAmountInDefaultCurrency) {
|
|
minimumSourceAmountInDefaultCurrency = amountInDefaultCurrency;
|
|
}
|
|
|
|
if (amountInDefaultCurrency > maximumSourceAmountInDefaultCurrency) {
|
|
maximumSourceAmountInDefaultCurrency = amountInDefaultCurrency;
|
|
}
|
|
}
|
|
|
|
let value: number = 0;
|
|
|
|
if (valueMetric === TransactionExploreValueMetric.TransactionCount) {
|
|
value = allSourceAmountsInDefaultCurrency.length;
|
|
} else if (valueMetric === TransactionExploreValueMetric.SourceAmountSum) {
|
|
value = totalSourceAmountSumInDefaultCurrency;
|
|
} else if (valueMetric === TransactionExploreValueMetric.SourceAmountAverage) {
|
|
value = allSourceAmountsInDefaultCurrency.length > 0 ? Math.trunc(totalSourceAmountSumInDefaultCurrency / allSourceAmountsInDefaultCurrency.length) : 0;
|
|
} else if (valueMetric === TransactionExploreValueMetric.SourceAmountMedian) {
|
|
if (allSourceAmountsInDefaultCurrency.length > 0) {
|
|
allSourceAmountsInDefaultCurrency.sort((a, b) => a - b);
|
|
value = allSourceAmountsInDefaultCurrency[Math.floor(allSourceAmountsInDefaultCurrency.length / 2)] as number;
|
|
} else {
|
|
value = 0;
|
|
}
|
|
} else if (valueMetric === TransactionExploreValueMetric.SourceAmountMinimum) {
|
|
value = minimumSourceAmountInDefaultCurrency === Number.MAX_SAFE_INTEGER ? 0 : minimumSourceAmountInDefaultCurrency;
|
|
} else if (valueMetric === TransactionExploreValueMetric.SourceAmountMaximum) {
|
|
value = maximumSourceAmountInDefaultCurrency === Number.MIN_SAFE_INTEGER ? 0 : maximumSourceAmountInDefaultCurrency;
|
|
}
|
|
|
|
dataItems.push({
|
|
seriesName: seriesedTransactions.seriesName,
|
|
seriesNameNeedI18n: seriesedTransactions.seriesNameNeedI18n,
|
|
seriesNameI18nParameters: seriesedTransactions.seriesNameI18nParameters,
|
|
seriesId: seriesedTransactions.seriesId,
|
|
seriesIdType: seriesedTransactions.seriesIdType,
|
|
value: value
|
|
});
|
|
}
|
|
|
|
result.push({
|
|
categoryName: categoriedTransactions.categoryName,
|
|
categoryNameNeedI18n: categoriedTransactions.categoryNameNeedI18n,
|
|
categoryNameI18nParameters: categoriedTransactions.categoryNameI18nParameters,
|
|
categoryId: categoriedTransactions.categoryId,
|
|
categoryIdType: categoriedTransactions.categoryIdType,
|
|
data: dataItems
|
|
});
|
|
}
|
|
|
|
return result;
|
|
});
|
|
|
|
function updateTransactionExploreInvalidState(invalidState: boolean): void {
|
|
transactionExploreStateInvalid.value = invalidState;
|
|
}
|
|
|
|
function resetTransactionExplores(): void {
|
|
transactionExploreFilter.value.dateRangeType = DEFAULT_TRANSACTION_EXPLORE_DATE_RANGE.type;
|
|
transactionExploreFilter.value.startTime = 0;
|
|
transactionExploreFilter.value.endTime = 0;
|
|
transactionExploreFilter.value.query = [];
|
|
transactionExploreFilter.value.chartType = TransactionExploreChartType.Default.value;
|
|
transactionExploreFilter.value.categoryDimension = TransactionExploreDataDimension.CategoryDimensionDefault.value;
|
|
transactionExploreFilter.value.seriesDimension = TransactionExploreDataDimension.SeriesDimensionDefault.value;
|
|
transactionExploreFilter.value.valueMetric = TransactionExploreValueMetric.Default.value;
|
|
transactionExploreAllData.value = [];
|
|
transactionExploreStateInvalid.value = true;
|
|
}
|
|
|
|
function initTransactionExploreFilter(filter?: TransactionExplorePartialFilter, resetQuery?: boolean): void {
|
|
if (filter && isInteger(filter.dateRangeType)) {
|
|
transactionExploreFilter.value.dateRangeType = filter.dateRangeType;
|
|
} else {
|
|
transactionExploreFilter.value.dateRangeType = settingsStore.appSettings.insightsExploreDefaultDateRangeType;
|
|
}
|
|
|
|
let dateRangeTypeValid = true;
|
|
|
|
if (!DateRange.isAvailableForScene(transactionExploreFilter.value.dateRangeType, DateRangeScene.InsightsExplore)) {
|
|
transactionExploreFilter.value.dateRangeType = DEFAULT_TRANSACTION_EXPLORE_DATE_RANGE.type;
|
|
dateRangeTypeValid = false;
|
|
}
|
|
|
|
if (dateRangeTypeValid && transactionExploreFilter.value.dateRangeType === DateRange.Custom.type) {
|
|
if (filter && isInteger(filter.startTime)) {
|
|
transactionExploreFilter.value.startTime = filter.startTime;
|
|
} else {
|
|
transactionExploreFilter.value.startTime = 0;
|
|
}
|
|
|
|
if (filter && isInteger(filter.endTime)) {
|
|
transactionExploreFilter.value.endTime = filter.endTime;
|
|
} else {
|
|
transactionExploreFilter.value.endTime = 0;
|
|
}
|
|
} else {
|
|
const dateRange = getDateRangeByDateType(transactionExploreFilter.value.dateRangeType, userStore.currentUserFirstDayOfWeek, userStore.currentUserFiscalYearStart);
|
|
|
|
if (dateRange) {
|
|
transactionExploreFilter.value.dateRangeType = dateRange.dateType;
|
|
transactionExploreFilter.value.startTime = dateRange.minTime;
|
|
transactionExploreFilter.value.endTime = dateRange.maxTime;
|
|
}
|
|
}
|
|
|
|
if (resetQuery) {
|
|
transactionExploreFilter.value.query = [];
|
|
transactionExploreFilter.value.chartType = TransactionExploreChartType.Default.value;
|
|
transactionExploreFilter.value.categoryDimension = TransactionExploreDataDimension.CategoryDimensionDefault.value;
|
|
transactionExploreFilter.value.seriesDimension = TransactionExploreDataDimension.SeriesDimensionDefault.value;
|
|
transactionExploreFilter.value.valueMetric = TransactionExploreValueMetric.Default.value;
|
|
}
|
|
}
|
|
|
|
function updateTransactionExploreFilter(filter: TransactionExplorePartialFilter): boolean {
|
|
let changed = false;
|
|
|
|
if (filter && isInteger(filter.dateRangeType) && transactionExploreFilter.value.dateRangeType !== filter.dateRangeType) {
|
|
transactionExploreFilter.value.dateRangeType = filter.dateRangeType;
|
|
changed = true;
|
|
}
|
|
|
|
if (filter && isInteger(filter.startTime) && transactionExploreFilter.value.startTime !== filter.startTime) {
|
|
transactionExploreFilter.value.startTime = filter.startTime;
|
|
changed = true;
|
|
}
|
|
|
|
if (filter && isInteger(filter.endTime) && transactionExploreFilter.value.endTime !== filter.endTime) {
|
|
transactionExploreFilter.value.endTime = filter.endTime;
|
|
changed = true;
|
|
}
|
|
|
|
if (filter && isDefined(filter.chartType) && transactionExploreFilter.value.chartType !== filter.chartType) {
|
|
transactionExploreFilter.value.chartType = filter.chartType;
|
|
changed = true;
|
|
}
|
|
|
|
if (filter && isDefined(filter.categoryDimension) && transactionExploreFilter.value.categoryDimension !== filter.categoryDimension) {
|
|
transactionExploreFilter.value.categoryDimension = filter.categoryDimension;
|
|
changed = true;
|
|
}
|
|
|
|
if (filter && isDefined(filter.seriesDimension) && transactionExploreFilter.value.seriesDimension !== filter.seriesDimension) {
|
|
transactionExploreFilter.value.seriesDimension = filter.seriesDimension;
|
|
changed = true;
|
|
}
|
|
|
|
if (filter && isDefined(filter.valueMetric) && transactionExploreFilter.value.valueMetric !== filter.valueMetric) {
|
|
transactionExploreFilter.value.valueMetric = filter.valueMetric;
|
|
changed = true;
|
|
}
|
|
|
|
if (transactionExploreFilter.value.seriesDimension === transactionExploreFilter.value.categoryDimension && transactionExploreFilter.value.seriesDimension !== TransactionExploreDataDimension.SeriesDimensionDefault.value) {
|
|
transactionExploreFilter.value.seriesDimension = TransactionExploreDataDimension.SeriesDimensionDefault.value;
|
|
changed = true;
|
|
}
|
|
|
|
return changed;
|
|
}
|
|
|
|
function getTransactionExplorePageParams(currentExploreId: string, activeTab: string): string {
|
|
const querys: string[] = [];
|
|
|
|
if (currentExploreId) {
|
|
querys.push('id=' + currentExploreId);
|
|
}
|
|
|
|
if (activeTab) {
|
|
querys.push('activeTab=' + activeTab);
|
|
}
|
|
|
|
querys.push('dateRangeType=' + transactionExploreFilter.value.dateRangeType);
|
|
querys.push('startTime=' + transactionExploreFilter.value.startTime);
|
|
querys.push('endTime=' + transactionExploreFilter.value.endTime);
|
|
|
|
return querys.join('&');
|
|
}
|
|
|
|
function getTransactionListPageParams(dimensionType: TransactionExploreDimensionType, itemId: string): string {
|
|
const querys: string[] = [];
|
|
|
|
if (dimensionType === TransactionExploreDimensionType.TransactionType) {
|
|
querys.push(`type=${itemId}`);
|
|
} else if (dimensionType === TransactionExploreDimensionType.Account) {
|
|
querys.push(`accountIds=${itemId}`);
|
|
} else if (dimensionType === TransactionExploreDimensionType.Category) {
|
|
querys.push(`categoryIds=${itemId}`);
|
|
} else if (dimensionType === TransactionExploreDimensionType.Amount) {
|
|
querys.push(`amountFilter=${encodeURIComponent(AmountFilterType.EqualTo.toTextualFilter(parseInt(itemId)))}`);
|
|
} else {
|
|
return '';
|
|
}
|
|
|
|
querys.push('dateType=' + transactionExploreFilter.value.dateRangeType);
|
|
querys.push('minTime=' + transactionExploreFilter.value.startTime);
|
|
querys.push('maxTime=' + transactionExploreFilter.value.endTime);
|
|
|
|
return querys.join('&');
|
|
}
|
|
|
|
function loadAllTransactions({ force }: { force: boolean }): Promise<TransactionInfoResponse[]> {
|
|
return new Promise((resolve, reject) => {
|
|
services.getAllTransactions({
|
|
startTime: transactionExploreFilter.value.startTime,
|
|
endTime: transactionExploreFilter.value.endTime
|
|
}).then(response => {
|
|
const data = response.data;
|
|
|
|
if (!data || !data.success || !data.result) {
|
|
reject({ message: 'Unable to retrieve all transactions' });
|
|
return;
|
|
}
|
|
|
|
if (transactionExploreStateInvalid.value) {
|
|
updateTransactionExploreInvalidState(false);
|
|
}
|
|
|
|
if (force && data.result && isEquals(transactionExploreAllData.value, data.result)) {
|
|
reject({ message: 'Data is up to date', isUpToDate: true });
|
|
return;
|
|
}
|
|
|
|
transactionExploreAllData.value = data.result;
|
|
|
|
resolve(data.result);
|
|
}).catch(error => {
|
|
logger.error('failed to load all transactions', error);
|
|
|
|
if (error.response && error.response.data && error.response.data.errorMessage) {
|
|
reject({ error: error.response.data });
|
|
} else if (!error.processed) {
|
|
reject({ message: 'Unable to retrieve all transactions' });
|
|
} else {
|
|
reject(error);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
return {
|
|
// states
|
|
transactionExploreFilter,
|
|
transactionExploreStateInvalid,
|
|
// computed
|
|
filteredTransactions,
|
|
categoriedTransactionExploreData,
|
|
// functions
|
|
updateTransactionExploreInvalidState,
|
|
resetTransactionExplores,
|
|
initTransactionExploreFilter,
|
|
updateTransactionExploreFilter,
|
|
getTransactionExplorePageParams,
|
|
getTransactionListPageParams,
|
|
loadAllTransactions
|
|
};
|
|
});
|