void MyMoneySplitTest::testReadXML()
{
MyMoneySplit s;
QString ref_ok = QString(
"<!DOCTYPE TEST>\n"
"<SPLIT-CONTAINER>\n"
" <SPLIT payee=\"P000001\" reconciledate=\"\" shares=\"96379/100\" action=\"Deposit\" bankid=\"SPID\" number=\"124\" reconcileflag=\"2\" memo=\"MyMemo\" value=\"96379/1000\" account=\"A000076\">\n"
" <TAG id=\"G000001\"/>\n"
" </SPLIT>\n"
"</SPLIT-CONTAINER>\n");
QString ref_false = QString(
"<!DOCTYPE TEST>\n"
"<SPLIT-CONTAINER>\n"
" <SPLITS payee=\"P000001\" reconciledate=\"\" shares=\"96379/100\" action=\"Deposit\" bankid=\"SPID\" number=\"124\" reconcileflag=\"2\" memo=\"\" value=\"96379/1000\" account=\"A000076\" />\n"
" <TAG id=\"G000001\"/>\n"
"</SPLIT-CONTAINER>\n");
QDomDocument doc;
QDomElement node;
doc.setContent(ref_false);
node = doc.documentElement().firstChild().toElement();
try {
s = MyMoneySplit(node);
QFAIL("Missing expected exception");
} catch (const MyMoneyException &) {
}
doc.setContent(ref_ok);
node = doc.documentElement().firstChild().toElement();
try {
s = MyMoneySplit(node);
QVERIFY(s.id().isEmpty());
QVERIFY(s.payeeId() == "P000001");
QList<QString> tagIdList;
tagIdList << "G000001";
QVERIFY(s.tagIdList() == tagIdList);
QVERIFY(s.reconcileDate() == QDate());
QVERIFY(s.shares() == MyMoneyMoney(96379, 100));
QVERIFY(s.value() == MyMoneyMoney(96379, 1000));
QVERIFY(s.number() == "124");
QVERIFY(s.bankID() == "SPID");
QVERIFY(s.reconcileFlag() == MyMoneySplit::Reconciled);
QVERIFY(s.action() == MyMoneySplit::ActionDeposit);
QVERIFY(s.accountId() == "A000076");
QVERIFY(s.memo() == "MyMemo");
} catch (const MyMoneyException &) {
}
}
void CsvUtil::dissectTransaction(const MyMoneyTransaction& transaction, const MyMoneySplit& split, MyMoneySplit& assetAccountSplit, QList<MyMoneySplit>& feeSplits, QList<MyMoneySplit>& interestSplits, MyMoneySecurity& security, MyMoneySecurity& currency, MyMoneySplit::investTransactionTypeE& transactionType)
{
// collect the splits. split references the stock account and should already
// be set up. assetAccountSplit references the corresponding asset account (maybe
// empty), feeSplits is the list of all expenses and interestSplits
// the list of all incomes
MyMoneyFile* file = MyMoneyFile::instance();
QList<MyMoneySplit>::ConstIterator it_s;
for (it_s = transaction.splits().constBegin(); it_s != transaction.splits().constEnd(); ++it_s) {
MyMoneyAccount acc = file->account((*it_s).accountId());
if ((*it_s).id() == split.id()) {
security = file->security(acc.currencyId());
} else if (acc.accountGroup() == MyMoneyAccount::Expense) {
feeSplits.append(*it_s);
} else if (acc.accountGroup() == MyMoneyAccount::Income) {
interestSplits.append(*it_s);
} else {
assetAccountSplit = *it_s;
}
}
// determine transaction type
if (split.action() == MyMoneySplit::ActionAddShares) {
transactionType = (!split.shares().isNegative()) ? MyMoneySplit::AddShares : MyMoneySplit::RemoveShares;
} else if (split.action() == MyMoneySplit::ActionBuyShares) {
transactionType = (!split.value().isNegative()) ? MyMoneySplit::BuyShares : MyMoneySplit::SellShares;
} else if (split.action() == MyMoneySplit::ActionDividend) {
transactionType = MyMoneySplit::Dividend;
} else if (split.action() == MyMoneySplit::ActionReinvestDividend) {
transactionType = MyMoneySplit::ReinvestDividend;
} else if (split.action() == MyMoneySplit::ActionYield) {
transactionType = MyMoneySplit::Yield;
} else if (split.action() == MyMoneySplit::ActionSplitShares) {
transactionType = MyMoneySplit::SplitShares;
} else if (split.action() == MyMoneySplit::ActionInterestIncome) {
transactionType = MyMoneySplit::InterestIncome;
} else
transactionType = MyMoneySplit::BuyShares;
currency.setTradingSymbol("???");
try {
currency = file->security(transaction.commodity());
} catch (const MyMoneyException &) {
}
}
void MyMoneySplitTest::testAssignmentConstructor()
{
testSetFunctions();
MyMoneySplit n;
n = *m;
QVERIFY(n.accountId() == "Account");
QVERIFY(n.memo() == "Memo");
QVERIFY(n.reconcileDate() == QDate(1, 2, 3));
QVERIFY(n.reconcileFlag() == MyMoneySplit::Cleared);
QVERIFY(n.shares() == MyMoneyMoney(1234, 100));
QVERIFY(n.value() == MyMoneyMoney(3456, 100));
QVERIFY(n.id() == "MyID");
QVERIFY(n.payeeId() == "Payee");
QList<QString> tagIdList;
tagIdList << "Tag";
QVERIFY(m->tagIdList() == tagIdList);
QVERIFY(n.action() == "Action");
QVERIFY(n.transactionId() == "TestTransaction");
QVERIFY(n.value("Key") == "Value");
}
const MyMoneySplit KMyMoneyUtils::stockSplit(const MyMoneyTransaction& t)
{
QList<MyMoneySplit>::ConstIterator it_s;
MyMoneySplit investmentAccountSplit;
for (it_s = t.splits().begin(); it_s != t.splits().end(); ++it_s) {
if (!(*it_s).accountId().isEmpty()) {
MyMoneyAccount acc = MyMoneyFile::instance()->account((*it_s).accountId());
if (acc.isInvest()) {
return *it_s;
}
// if we have a reference to an investment account, we remember it here
if (acc.accountType() == MyMoneyAccount::Investment)
investmentAccountSplit = *it_s;
}
}
// if we haven't found a stock split, we see if we've seen
// an investment account on the way. If so, we return it.
if (!investmentAccountSplit.id().isEmpty())
return investmentAccountSplit;
// if none was found, we return an empty split.
return MyMoneySplit();
}
void MyMoneyForecast::calculateAutoLoan(const MyMoneySchedule& schedule, MyMoneyTransaction& transaction, const QMap<QString, MyMoneyMoney>& balances)
{
if (schedule.type() == MyMoneySchedule::TYPE_LOANPAYMENT) {
//get amortization and interest autoCalc splits
MyMoneySplit amortizationSplit = transaction.amortizationSplit();
MyMoneySplit interestSplit = transaction.interestSplit();
if(!amortizationSplit.id().isEmpty() && !interestSplit.id().isEmpty()) {
MyMoneyAccountLoan acc(MyMoneyFile::instance()->account(amortizationSplit.accountId()));
MyMoneyFinancialCalculator calc;
QDate dueDate;
// FIXME: setup dueDate according to when the interest should be calculated
// current implementation: take the date of the next payment according to
// the schedule. If the calculation is based on the payment reception, and
// the payment is overdue then take the current date
dueDate = schedule.nextDueDate();
if(acc.interestCalculation() == MyMoneyAccountLoan::paymentReceived) {
if(dueDate < QDate::currentDate())
dueDate = QDate::currentDate();
}
// we need to calculate the balance at the time the payment is due
MyMoneyMoney balance;
if(balances.count() == 0)
balance = MyMoneyFile::instance()->balance(acc.id(), dueDate.addDays(-1));
else
balance = balances[acc.id()];
/*
QValueList<MyMoneyTransaction> list;
QValueList<MyMoneyTransaction>::ConstIterator it;
MyMoneySplit split;
MyMoneyTransactionFilter filter(acc.id());
filter.setDateFilter(QDate(), dueDate.addDays(-1));
list = MyMoneyFile::instance()->transactionList(filter);
for(it = list.begin(); it != list.end(); ++it) {
try {
split = (*it).splitByAccount(acc.id());
balance += split.value();
} catch(MyMoneyException *e) {
// account is not referenced within this transaction
delete e;
}
}
*/
// FIXME: for now, we only support interest calculation at the end of the period
calc.setBep();
// FIXME: for now, we only support periodic compounding
calc.setDisc();
calc.setPF(MyMoneySchedule::eventsPerYear(schedule.occurence()));
MyMoneySchedule::occurenceE compoundingOccurence = static_cast<MyMoneySchedule::occurenceE>(acc.interestCompounding());
if(compoundingOccurence == MyMoneySchedule::OCCUR_ANY)
compoundingOccurence = schedule.occurence();
calc.setCF(MyMoneySchedule::eventsPerYear(compoundingOccurence));
calc.setPv(balance.toDouble());
calc.setIr(static_cast<FCALC_DOUBLE> (acc.interestRate(dueDate).abs().toDouble()));
calc.setPmt(acc.periodicPayment().toDouble());
MyMoneyMoney interest(calc.interestDue()), amortization;
interest = interest.abs(); // make sure it's positive for now
amortization = acc.periodicPayment() - interest;
if(acc.accountType() == MyMoneyAccount::AssetLoan) {
interest = -interest;
amortization = -amortization;
}
amortizationSplit.setShares(amortization);
interestSplit.setShares(interest);
// FIXME: for now we only assume loans to be in the currency of the transaction
amortizationSplit.setValue(amortization);
interestSplit.setValue(interest);
transaction.modifySplit(amortizationSplit);
transaction.modifySplit(interestSplit);
}
}
}
void TransactionMatcher::match(MyMoneyTransaction tm, MyMoneySplit sm, MyMoneyTransaction ti, MyMoneySplit si, bool allowImportedTransactions)
{
const MyMoneySecurity& sec = MyMoneyFile::instance()->security(m_account.currencyId());
// Now match the transactions.
//
// 'Matching' the transactions entails DELETING the end transaction,
// and MODIFYING the start transaction as needed.
//
// There are a variety of ways that a transaction can conflict.
// Post date, splits, amount are the ones that seem to matter.
// TODO: Handle these conflicts intelligently, at least warning
// the user, or better yet letting the user choose which to use.
//
// For now, we will just use the transaction details from the start
// transaction. The only thing we'll take from the end transaction
// are the bank ID's.
//
// What we have to do here is iterate over the splits in the end
// transaction, and find the corresponding split in the start
// transaction. If there is a bankID in the end split but not the
// start split, add it to the start split. If there is a bankID
// in BOTH, then this transaction cannot be merged (both transactions
// were imported!!) If the corresponding start split cannot be
// found and the end split has a bankID, we should probably just fail.
// Although we could ADD it to the transaction.
// ipwizard: Don't know if iterating over the transactions is a good idea.
// In case of a split transaction recorded with KMyMoney and the transaction
// data being imported consisting only of a single category assignment, this
// does not make much sense. The same applies for investment transactions
// stored in KMyMoney against imported transactions. I think a better solution
// is to just base the match on the splits referencing the same (currently
// selected) account.
// verify, that tm is a manual (non-matched) transaction
// allow matching two manual transactions
if ((!allowImportedTransactions && tm.isImported()) || sm.isMatched())
throw MYMONEYEXCEPTION(i18n("First transaction does not match requirement for matching"));
// verify that the amounts are the same, otherwise we should not be matching!
if (sm.shares() != si.shares()) {
throw MYMONEYEXCEPTION(i18n("Splits for %1 have conflicting values (%2,%3)", m_account.name(), MyMoneyUtils::formatMoney(sm.shares(), m_account, sec), MyMoneyUtils::formatMoney(si.shares(), m_account, sec)));
}
// check that dates are within user's setting
const int gap = abs(tm.postDate().toJulianDay() - ti.postDate().toJulianDay());
if (gap > KMyMoneyGlobalSettings::matchInterval()) {
int rc = KMessageBox::questionYesNo(0, i18np("The transaction dates are one day apart. Do you want to match them anyway?",
"The transaction dates are %1 days apart. Do you want to match them anyway?", gap));
if (rc == KMessageBox::No) {
return;
}
}
// ipwizard: I took over the code to keep the bank id found in the endMatchTransaction
// This might not work for QIF imports as they don't setup this information. It sure
// makes sense for OFX and HBCI.
const QString& bankID = si.bankID();
if (!bankID.isEmpty()) {
try {
if (sm.bankID().isEmpty()) {
sm.setBankID(bankID);
tm.modifySplit(sm);
}
} catch (const MyMoneyException &e) {
QString estr = e.what();
throw MYMONEYEXCEPTION(i18n("Unable to match all splits (%1)", estr));
}
}
//
// we now allow matching of two non-imported transactions
//
// mark the split as cleared if it does not have a reconciliation information yet
if (sm.reconcileFlag() == MyMoneySplit::NotReconciled) {
sm.setReconcileFlag(MyMoneySplit::Cleared);
}
// if we don't have a payee assigned to the manually entered transaction
// we use the one we found in the imported transaction
if (sm.payeeId().isEmpty() && !si.payeeId().isEmpty()) {
sm.setValue("kmm-orig-payee", sm.payeeId());
sm.setPayeeId(si.payeeId());
}
// We use the imported postdate and keep the previous one for unmatch
if (tm.postDate() != ti.postDate()) {
sm.setValue("kmm-orig-postdate", tm.postDate().toString(Qt::ISODate));
tm.setPostDate(ti.postDate());
}
// combine the two memos into one
QString memo = sm.memo();
if (!si.memo().isEmpty() && si.memo() != memo) {
sm.setValue("kmm-orig-memo", memo);
if (!memo.isEmpty())
memo += '\n';
memo += si.memo();
}
sm.setMemo(memo);
// remember the split we matched
sm.setValue("kmm-match-split", si.id());
sm.addMatch(ti);
tm.modifySplit(sm);
ti.modifySplit(si);///
MyMoneyFile::instance()->modifyTransaction(tm);
// Delete the end transaction if it was stored in the engine
if (!ti.id().isEmpty())
MyMoneyFile::instance()->removeTransaction(ti);
}
void TransactionMatcher::match(MyMoneyTransaction tm, MyMoneySplit sm, MyMoneyTransaction ti, MyMoneySplit si, bool allowImportedTransactions)
{
const MyMoneySecurity& sec = MyMoneyFile::instance()->security(m_account.currencyId());
// Now match the transactions.
//
// 'Matching' the transactions entails DELETING the end transaction,
// and MODIFYING the start transaction as needed.
//
// There are a variety of ways that a transaction can conflict.
// Post date, splits, amount are the ones that seem to matter.
// TODO: Handle these conflicts intelligently, at least warning
// the user, or better yet letting the user choose which to use.
//
// For now, we will just use the transaction details from the start
// transaction. The only thing we'll take from the end transaction
// are the bank ID's.
//
// What we have to do here is iterate over the splits in the end
// transaction, and find the corresponding split in the start
// transaction. If there is a bankID in the end split but not the
// start split, add it to the start split. If there is a bankID
// in BOTH, then this transaction cannot be merged (both transactions
// were imported!!) If the corresponding start split cannot be
// found and the end split has a bankID, we should probably just fail.
// Although we could ADD it to the transaction.
// ipwizard: Don't know if iterating over the transactions is a good idea.
// In case of a split transaction recorded with KMyMoney and the transaction
// data being imported consisting only of a single category assignment, this
// does not make much sense. The same applies for investment transactions
// stored in KMyMoney against imported transactions. I think a better solution
// is to just base the match on the splits referencing the same (currently
// selected) account.
// verify, that tm is a manually (non-matched) transaction and ti an imported one
if(sm.isMatched() || (!allowImportedTransactions && tm.isImported()))
throw new MYMONEYEXCEPTION(i18n("First transaction does not match requirement for matching"));
if(!ti.isImported())
throw new MYMONEYEXCEPTION(i18n("Second transaction does not match requirement for matching"));
// verify that the amounts are the same, otherwise we should not be matching!
if(sm.shares() != si.shares()) {
throw new MYMONEYEXCEPTION(i18n("Splits for %1 have conflicting values (%2,%3)").arg(m_account.name()).arg(sm.shares().formatMoney(m_account, sec), si.shares().formatMoney(m_account, sec)));
}
// ipwizard: I took over the code to keep the bank id found in the endMatchTransaction
// This might not work for QIF imports as they don't setup this information. It sure
// makes sense for OFX and HBCI.
const QString& bankID = si.bankID();
if (!bankID.isEmpty()) {
try {
if (sm.bankID().isEmpty() ) {
sm.setBankID( bankID );
tm.modifySplit(sm);
} else if(sm.bankID() != bankID) {
throw new MYMONEYEXCEPTION(i18n("Both of these transactions have been imported into %1. Therefore they cannot be matched. Matching works with one imported transaction and one non-imported transaction.").arg(m_account.name()));
}
} catch(MyMoneyException *e) {
QString estr = e->what();
delete e;
throw new MYMONEYEXCEPTION(i18n("Unable to match all splits (%1)").arg(estr));
}
}
#if 0 // Ace's original code
// TODO (Ace) Add in another error to catch the case where a user
// tries to match two hand-entered transactions.
QValueList<MyMoneySplit> endSplits = endMatchTransaction.splits();
QValueList<MyMoneySplit>::const_iterator it_split = endSplits.begin();
while (it_split != endSplits.end())
{
// find the corresponding split in the start transaction
MyMoneySplit startSplit;
QString accountid = (*it_split).accountId();
try
{
startSplit = startMatchTransaction.splitByAccount( accountid );
}
// only exception is thrown if we cannot find a split like this
catch(MyMoneyException *e)
{
delete e;
startSplit = (*it_split);
startSplit.clearId();
startMatchTransaction.addSplit(startSplit);
}
// verify that the amounts are the same, otherwise we should not be
// matching!
if ( (*it_split).value() != startSplit.value() )
{
QString accountname = MyMoneyFile::instance()->account(accountid).name();
throw new MYMONEYEXCEPTION(i18n("Splits for %1 have conflicting values (%2,%3)").arg(accountname).arg((*it_split).value().formatMoney(),startSplit.value().formatMoney()));
}
QString bankID = (*it_split).bankID();
if ( ! bankID.isEmpty() )
{
try
{
if ( startSplit.bankID().isEmpty() )
{
startSplit.setBankID( bankID );
startMatchTransaction.modifySplit(startSplit);
}
else
{
QString accountname = MyMoneyFile::instance()->account(accountid).name();
throw new MYMONEYEXCEPTION(i18n("Both of these transactions have been imported into %1. Therefore they cannot be matched. Matching works with one imported transaction and one non-imported transaction.").arg(accountname));
}
}
catch(MyMoneyException *e)
{
QString estr = e->what();
delete e;
throw new MYMONEYEXCEPTION(i18n("Unable to match all splits (%1)").arg(estr));
}
}
++it_split;
}
#endif
// mark the split as cleared if it does not have a reconciliation information yet
if(sm.reconcileFlag() == MyMoneySplit::NotReconciled) {
sm.setReconcileFlag(MyMoneySplit::Cleared);
}
// if we don't have a payee assigned to the manually entered transaction
// we use the one we found in the imported transaction
if(sm.payeeId().isEmpty() && !si.payeeId().isEmpty()) {
sm.setValue("kmm-orig-payee", sm.payeeId());
sm.setPayeeId(si.payeeId());
}
// We use the imported postdate and keep the previous one for unmatch
if(tm.postDate() != ti.postDate()) {
sm.setValue("kmm-orig-postdate", tm.postDate().toString(Qt::ISODate));
tm.setPostDate(ti.postDate());
}
// combine the two memos into one
QString memo = sm.memo();
if(!si.memo().isEmpty() && si.memo() != memo) {
sm.setValue("kmm-orig-memo", memo);
if(!memo.isEmpty())
memo += "\n";
memo += si.memo();
}
sm.setMemo(memo);
// remember the split we matched
sm.setValue("kmm-match-split", si.id());
sm.addMatch(ti);
tm.modifySplit(sm);
MyMoneyFile::instance()->modifyTransaction(tm);
// Delete the end transaction if it was stored in the engine
if(!ti.id().isEmpty())
MyMoneyFile::instance()->removeTransaction(ti);
}