MyMoneyMoney KSplitTransactionDlg::diffAmount() { MyMoneyMoney diff; // if there is an amount specified in the transaction, we need to calculate the // difference, otherwise we display the difference as 0 and display the same sum. if (m_amountValid) { MyMoneySplit split = m_transaction.splits()[0]; diff = -(splitsValue() + split.value()); } return diff; }
void MyMoneyQifWriter::writeAccountEntry(QTextStream &s, const QString& accountId, const QDate& startDate, const QDate& endDate) { MyMoneyFile* file = MyMoneyFile::instance(); MyMoneyAccount account; account = file->account(accountId); MyMoneyTransactionFilter filter(accountId); filter.setDateFilter(startDate, endDate); QValueList<MyMoneyTransaction> list = file->transactionList(filter); QString openingBalanceTransactionId; s << "!Type:" << m_qifProfile.profileType() << endl; if(!startDate.isValid() || startDate <= account.openingDate()) { s << "D" << m_qifProfile.date(account.openingDate()) << endl; openingBalanceTransactionId = file->openingBalanceTransaction(account); MyMoneySplit split; if(!openingBalanceTransactionId.isEmpty()) { MyMoneyTransaction openingBalanceTransaction = file->transaction(openingBalanceTransactionId); split = openingBalanceTransaction.splitByAccount(account.id(), true /* match */); } s << "T" << m_qifProfile.value('T', split.value()) << endl; } else { s << "D" << m_qifProfile.date(startDate) << endl; s << "T" << m_qifProfile.value('T', file->balance(accountId, startDate.addDays(-1))) << endl; } s << "CX" << endl; s << "P" << m_qifProfile.openingBalanceText() << endl; s << "L"; if(m_qifProfile.accountDelimiter().length()) s << m_qifProfile.accountDelimiter()[0]; s << account.name(); if(m_qifProfile.accountDelimiter().length() > 1) s << m_qifProfile.accountDelimiter()[1]; s << endl; s << "^" << endl; QValueList<MyMoneyTransaction>::ConstIterator it; signalProgress(0, list.count()); int count = 0; for(it = list.begin(); it != list.end(); ++it) { // don't include the openingBalanceTransaction again if((*it).id() != openingBalanceTransactionId) writeTransactionEntry(s, *it, accountId); signalProgress(++count, 0); } }
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 &) { } }
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 MyMoneyAccountTest::testConstructor() { QString id = "A000001"; QString institutionid = "B000001"; QString parent = "Parent"; MyMoneyAccount r; MyMoneySplit s; r.setAccountType(MyMoneyAccount::Asset); r.setOpeningDate(QDate::currentDate()); r.setLastModified(QDate::currentDate()); r.setDescription("Desc"); r.setNumber("465500"); r.setParentAccountId(parent); r.setValue(QString("key"), "value"); s.setShares(MyMoneyMoney::ONE); r.adjustBalance(s); QVERIFY(r.m_kvp.count() == 1); QVERIFY(r.value("key") == "value"); MyMoneyAccount a(id, r); QVERIFY(a.id() == id); QVERIFY(a.institutionId().isEmpty()); QVERIFY(a.accountType() == MyMoneyAccount::Asset); QVERIFY(a.openingDate() == QDate::currentDate()); QVERIFY(a.lastModified() == QDate::currentDate()); QVERIFY(a.number() == "465500"); QVERIFY(a.description() == "Desc"); QVERIFY(a.accountList().count() == 0); QVERIFY(a.parentAccountId() == "Parent"); QVERIFY(a.balance() == MyMoneyMoney::ONE); QMap<QString, QString> copy; copy = r.pairs(); QVERIFY(copy.count() == 1); QVERIFY(copy[QString("key")] == "value"); }
void TransactionMatcher::accept(const MyMoneyTransaction& _t, const MyMoneySplit& _s) { if (_s.isMatched()) { MyMoneyTransaction tm(_t); MyMoneySplit sm(_s); sm.removeMatch(); sm.deletePair("kmm-orig-postdate"); sm.deletePair("kmm-orig-payee"); sm.deletePair("kmm-orig-memo"); sm.deletePair("kmm-match-split"); tm.modifySplit(sm); MyMoneyFile::instance()->modifyTransaction(tm); } }
void TransactionMatcher::checkTransaction(const MyMoneyTransaction& tm, const MyMoneyTransaction& ti, const MyMoneySplit& si, QPair<MyMoneyTransaction, MyMoneySplit>& lastMatch, TransactionMatcher::autoMatchResultE& result, int variation) const { Q_UNUSED(ti); const QValueList<MyMoneySplit>& splits = tm.splits(); QValueList<MyMoneySplit>::const_iterator it_s; for(it_s = splits.begin(); it_s != splits.end(); ++it_s) { MyMoneyMoney upper((*it_s).shares()); MyMoneyMoney lower(upper); if((variation > 0) && (variation < 100)) { lower = lower - (lower.abs() * MyMoneyMoney(variation, 100)); upper = upper + (upper.abs() * MyMoneyMoney(variation, 100)); } // we only check for duplicates / matches if the sign // of the amount for this split is identical if((si.shares() >= lower) && (si.shares() <= upper)) { // check for duplicate (we can only do that, if we have a bankID) if(!si.bankID().isEmpty()) { if((*it_s).bankID() == si.bankID()) { lastMatch = QPair<MyMoneyTransaction, MyMoneySplit>(tm, *it_s); result = matchedDuplicate; break; } // in case the stored split already has a bankid // assigned, it must be a different one and therefore // will certainly not match if(!(*it_s).bankID().isEmpty()) continue; } // check if this is the one that matches if((*it_s).accountId() == si.accountId() && (si.shares() >= lower) && (si.shares() <= upper) && !(*it_s).isMatched()) { if(tm.postDate() == ti.postDate()) { lastMatch = QPair<MyMoneyTransaction, MyMoneySplit>(tm, *it_s); result = matchedExact; } else if(result != matchedExact) { lastMatch = QPair<MyMoneyTransaction, MyMoneySplit>(tm, *it_s); result = matched; } } } } }
void MyMoneyAccountTest::testAdjustBalance() { MyMoneyAccount a; MyMoneySplit s; s.setShares(MyMoneyMoney(3, 1)); a.adjustBalance(s); QVERIFY(a.balance() == MyMoneyMoney(3, 1)); s.setShares(MyMoneyMoney(5, 1)); a.adjustBalance(s, true); QVERIFY(a.balance() == MyMoneyMoney(-2, 1)); s.setShares(MyMoneyMoney(2, 1)); s.setAction(MyMoneySplit::ActionSplitShares); a.adjustBalance(s); QVERIFY(a.balance() == MyMoneyMoney(-4, 1)); s.setShares(MyMoneyMoney(4, 1)); s.setAction(QString()); a.adjustBalance(s); QVERIFY(a.balance().isZero()); }
void TransactionMatcher::unmatch(const MyMoneyTransaction& _t, const MyMoneySplit& _s) { if(_s.isMatched()) { MyMoneyTransaction tm(_t); MyMoneySplit sm(_s); MyMoneyTransaction ti(sm.matchedTransaction()); MyMoneySplit si; // if we don't have a split, then we don't have a memo try { si = ti.splitById(sm.value("kmm-match-split")); } catch(MyMoneyException* e) { delete e; } sm.removeMatch(); // restore the postdate if modified if(!sm.value("kmm-orig-postdate").isEmpty()) { tm.setPostDate(QDate::fromString(sm.value("kmm-orig-postdate"), Qt::ISODate)); } // restore payee if modified if(!sm.value("kmm-orig-payee").isEmpty()) { sm.setPayeeId(sm.value("kmm-orig-payee")); } // restore memo if modified if(!sm.value("kmm-orig-memo").isEmpty()) { sm.setMemo(sm.value("kmm-orig-memo")); } sm.deletePair("kmm-orig-postdate"); sm.deletePair("kmm-orig-payee"); sm.deletePair("kmm-orig-memo"); sm.deletePair("kmm-match-split"); tm.modifySplit(sm); MyMoneyFile::instance()->modifyTransaction(tm); MyMoneyFile::instance()->addTransaction(ti); } }
void MyMoneyQifWriter::writeSplitEntry(QTextStream& s, const MyMoneySplit& split) { MyMoneyFile* file = MyMoneyFile::instance(); s << "S"; MyMoneyAccount acc = file->account(split.accountId()); if(acc.accountGroup() != MyMoneyAccount::Income && acc.accountGroup() != MyMoneyAccount::Expense) { s << m_qifProfile.accountDelimiter()[0] << file->accountToCategory(split.accountId()) << m_qifProfile.accountDelimiter()[1]; } else { s << file->accountToCategory(split.accountId()); } s << endl; if(split.memo().length() > 0) { QString m = split.memo(); m.replace('\n', "\\n"); s << "E" << m << endl; } s << "$" << m_qifProfile.value('$', -split.value()) << endl; }
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 MyMoneySplitTest::testReplaceId() { MyMoneySplit s; bool changed; s.setPayeeId("P000001"); s.setAccountId("A000076"); changed = s.replaceId("X0001", "Y00001"); QVERIFY(changed == false); QVERIFY(s.payeeId() == "P000001"); QVERIFY(s.accountId() == "A000076"); changed = s.replaceId("P000002", "P000001"); QVERIFY(changed == true); QVERIFY(s.payeeId() == "P000002"); QVERIFY(s.accountId() == "A000076"); changed = s.replaceId("A000079", "A000076"); QVERIFY(changed == true); QVERIFY(s.payeeId() == "P000002"); QVERIFY(s.accountId() == "A000079"); QString ref_ok = QString( "<!DOCTYPE TEST>\n" "<SPLIT-CONTAINER>\n" " <SPLIT payee=\"P000001\" reconciledate=\"\" shares=\"-125000/100\" action=\"Transfer\" bankid=\"A000076-2010-03-05-b6850c0-1\" number=\"\" reconcileflag=\"1\" memo=\"UMBUCHUNG\" value=\"-125000/100\" id=\"S0001\" account=\"A000076\" >\n" " <KEYVALUEPAIRS>\n" " <PAIR key=\"kmm-match-split\" value=\"S0002\" />\n" " <PAIR key=\"kmm-matched-tx\" value=\"&lt;!DOCTYPE MATCH>\n" " &lt;CONTAINER>\n" " &lt;TRANSACTION postdate="2010-03-05" memo="UMBUCHUNG" id="" commodity="EUR" entrydate="2010-03-08" >\n" " &lt;SPLITS>\n" " &lt;SPLIT payee="P000010" reconciledate="" shares="125000/100" action="Transfer" bankid="" number="" reconcileflag="0" memo="UMBUCHUNG" value="125000/100" id="S0001" account="A000087" />\n" " &lt;SPLIT payee="P000011" reconciledate="" shares="-125000/100" action="" bankid="A000076-2010-03-05-b6850c0-1" number="" reconcileflag="0" memo="UMBUCHUNG" value="-125000/100" id="S0002" account="A000076" />\n" " &lt;/SPLITS>\n" " &lt;KEYVALUEPAIRS>\n" " &lt;PAIR key="Imported" value="true" />\n" " &lt;/KEYVALUEPAIRS>\n" " &lt;/TRANSACTION>\n" " &lt;/CONTAINER>\n" "\" />\n" " <PAIR key=\"kmm-orig-memo\" value=\"\" />\n" " </KEYVALUEPAIRS>\n" " </SPLIT>\n" "</SPLIT-CONTAINER>\n" ); QDomDocument doc; QDomElement node; doc.setContent(ref_ok); node = doc.documentElement().firstChild().toElement(); try { s = MyMoneySplit(node); QVERIFY(s.payeeId() == "P000001"); QVERIFY(s.replaceId("P2", "P1") == false); QVERIFY(s.matchedTransaction().splits()[0].payeeId() == "P000010"); QVERIFY(s.matchedTransaction().splits()[1].payeeId() == "P000011"); QVERIFY(s.replaceId("P0010", "P000010") == true); QVERIFY(s.matchedTransaction().splits()[0].payeeId() == "P0010"); QVERIFY(s.matchedTransaction().splits()[1].payeeId() == "P000011"); QVERIFY(s.replaceId("P0011", "P000011") == true); QVERIFY(s.matchedTransaction().splits()[0].payeeId() == "P0010"); QVERIFY(s.matchedTransaction().splits()[1].payeeId() == "P0011"); } catch (const MyMoneyException &) { QFAIL("Unexpected exception"); } }
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 MyMoneySplitTest::testWriteXML() { MyMoneySplit s; s.setPayeeId("P000001"); QList<QString> tagIdList; tagIdList << "G000001"; s.setTagIdList(tagIdList); s.setShares(MyMoneyMoney(96379, 100)); s.setValue(MyMoneyMoney(96379, 1000)); s.setAccountId("A000076"); s.setNumber("124"); s.setBankID("SPID"); s.setAction(MyMoneySplit::ActionDeposit); s.setReconcileFlag(MyMoneySplit::Reconciled); QDomDocument doc("TEST"); QDomElement el = doc.createElement("SPLIT-CONTAINER"); doc.appendChild(el); s.writeXML(doc, el); QCOMPARE(doc.doctype().name(), QLatin1String("TEST")); QDomElement splitContainer = doc.documentElement(); QCOMPARE(splitContainer.tagName(), QLatin1String("SPLIT-CONTAINER")); QCOMPARE(splitContainer.childNodes().size(), 1); QVERIFY(splitContainer.childNodes().at(0).isElement()); QDomElement split = splitContainer.childNodes().at(0).toElement(); QCOMPARE(split.tagName(), QLatin1String("SPLIT")); QCOMPARE(split.attribute("payee"), QLatin1String("P000001")); QCOMPARE(split.attribute("reconcileflag"), QLatin1String("2")); QCOMPARE(split.attribute("shares"), QLatin1String("96379/100")); QCOMPARE(split.attribute("reconciledate"), QString()); QCOMPARE(split.attribute("action"), QLatin1String("Deposit")); QCOMPARE(split.attribute("bankid"), QLatin1String("SPID")); QCOMPARE(split.attribute("account"), QLatin1String("A000076")); QCOMPARE(split.attribute("number"), QLatin1String("124")); QCOMPARE(split.attribute("value"), QLatin1String("96379/1000")); QCOMPARE(split.attribute("memo"), QString()); QCOMPARE(split.attribute("id"), QString()); QCOMPARE(split.childNodes().size(), 1); QVERIFY(split.childNodes().at(0).isElement()); QDomElement tag = split.childNodes().at(0).toElement(); QCOMPARE(tag.tagName(), QLatin1String("TAG")); QCOMPARE(tag.attribute("id"), QLatin1String("G000001")); QCOMPARE(tag.childNodes().size(), 0); QString ref = QString( "<!DOCTYPE TEST>\n" "<SPLIT-CONTAINER>\n" " <SPLIT payee=\"P000001\" reconcileflag=\"2\" shares=\"96379/100\" reconciledate=\"\" action=\"Deposit\" bankid=\"SPID\" account=\"A000076\" number=\"124\" value=\"96379/1000\" memo=\"\" id=\"\">\n" " <TAG id=\"G000001\"/>\n" " </SPLIT>\n" "</SPLIT-CONTAINER>\n"); }
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"); }
void MyMoneyQifWriter::writeTransactionEntry(QTextStream &s, const MyMoneyTransaction& t, const QString& accountId) { MyMoneyFile* file = MyMoneyFile::instance(); MyMoneySplit split = t.splitByAccount(accountId); s << "D" << m_qifProfile.date(t.postDate()) << endl; switch(split.reconcileFlag()) { case MyMoneySplit::Cleared: s << "C*" << endl; break; case MyMoneySplit::Reconciled: case MyMoneySplit::Frozen: s << "CX" << endl; break; default: break; } if(split.memo().length() > 0) { QString m = split.memo(); m.replace('\n', "\\n"); s << "M" << m << endl; } s << "T" << m_qifProfile.value('T', split.value()) << endl; if(split.number().length() > 0) s << "N" << split.number() << endl; if(!split.payeeId().isEmpty()) { MyMoneyPayee payee = file->payee(split.payeeId()); s << "P" << payee.name() << endl; } QValueList<MyMoneySplit> list = t.splits(); if(list.count() > 1) { MyMoneySplit sp = t.splitByAccount(accountId, false); MyMoneyAccount acc = file->account(sp.accountId()); if(acc.accountGroup() != MyMoneyAccount::Income && acc.accountGroup() != MyMoneyAccount::Expense) { s << "L" << m_qifProfile.accountDelimiter()[0] << MyMoneyFile::instance()->accountToCategory(sp.accountId()) << m_qifProfile.accountDelimiter()[1] << endl; } else { s << "L" << file->accountToCategory(sp.accountId()) << endl; } if(list.count() > 2) { QValueList<MyMoneySplit>::ConstIterator it; for(it = list.begin(); it != list.end(); ++it) { if(!((*it) == split)) { writeSplitEntry(s, *it); } } } } s << "^" << endl; }
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); } } }
int KSplitTransactionDlg::exec() { // for deposits, we invert the sign of all splits. // don't forget to revert when we're done ;-) if (m_isDeposit) { for (int i = 0; i < m_transaction.splits().count(); ++i) { MyMoneySplit split = m_transaction.splits()[i]; split.setValue(-split.value()); split.setShares(-split.shares()); m_transaction.modifySplit(split); } } int rc; do { transactionsTable->setFocus(); // initialize the display transactionsTable->setTransaction(m_transaction, m_split, m_account); updateSums(); rc = KSplitTransactionDlgDecl::exec(); if (rc == Accepted) { if (!diffAmount().isZero()) { KSplitCorrectionDlgDecl* corrDlg = new KSplitCorrectionDlgDecl(this); QVBoxLayout *mainLayout = new QVBoxLayout; corrDlg->setLayout(mainLayout); mainLayout->addWidget(corrDlg->findChild<QWidget*>("verticalLayout")); QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel); connect(buttonBox, SIGNAL(accepted()), corrDlg, SLOT(accept())); connect(buttonBox, SIGNAL(rejected()), corrDlg, SLOT(reject())); mainLayout->addWidget(buttonBox); corrDlg->buttonGroup->setId(corrDlg->continueBtn, 0); corrDlg->buttonGroup->setId(corrDlg->changeBtn, 1); corrDlg->buttonGroup->setId(corrDlg->distributeBtn, 2); corrDlg->buttonGroup->setId(corrDlg->leaveBtn, 3); corrDlg->setModal(true); MyMoneySplit split = m_transaction.splits()[0]; QString total = (-split.value()).formatMoney("", m_precision); QString sums = splitsValue().formatMoney("", m_precision); QString diff = diffAmount().formatMoney("", m_precision); // now modify the text items of the dialog to contain the correct values QString q = i18n("The total amount of this transaction is %1 while " "the sum of the splits is %2. The remaining %3 are " "unassigned.", total, sums, diff); corrDlg->explanation->setText(q); q = i18n("Change &total amount of transaction to %1.", sums); corrDlg->changeBtn->setText(q); q = i18n("&Distribute difference of %1 among all splits.", diff); corrDlg->distributeBtn->setText(q); // FIXME remove the following line once distribution among // all splits is implemented corrDlg->distributeBtn->hide(); // if we have only two splits left, we don't allow leaving sth. unassigned. if (m_transaction.splitCount() < 3) { q = i18n("&Leave total amount of transaction at %1.", total); } else { q = i18n("&Leave %1 unassigned.", diff); } corrDlg->leaveBtn->setText(q); if ((rc = corrDlg->exec()) == Accepted) { switch (corrDlg->buttonGroup->checkedId()) { case 0: // continue to edit rc = Rejected; break; case 1: // modify total split.setValue(-splitsValue()); split.setShares(-splitsValue()); m_transaction.modifySplit(split); break; case 2: // distribute difference qDebug("distribution of difference not yet supported in KSplitTransactionDlg::slotFinishClicked()"); break; case 3: // leave unassigned break; } } delete corrDlg; } } else break; } while (rc != Accepted); // for deposits, we inverted the sign of all splits. // now we revert it back, so that things are left correct if (m_isDeposit) { for (int i = 0; i < m_transaction.splits().count(); ++i) { MyMoneySplit split = m_transaction.splits()[i]; split.setValue(-split.value()); split.setShares(-split.shares()); m_transaction.modifySplit(split); } } return rc; }
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); }
TransactionHelper::TransactionHelper( const QDate& _date, const QString& _action, MyMoneyMoney _value, const QString& _accountid, const QString& _categoryid, const QString& _currencyid, const QString& _payee ) { // _currencyid is the currency of the transaction, and of the _value // both the account and category can have their own currency (athough the category having // a foreign currency is not yet supported by the program, the reports will still allow it, // so it must be tested.) MyMoneyFile* file = MyMoneyFile::instance(); bool haspayee = ! _payee.isEmpty(); MyMoneyPayee payeeTest = file->payeeByName(_payee); MyMoneyFileTransaction ft; setPostDate(_date); QString currencyid = _currencyid; if ( currencyid.isEmpty() ) currencyid=MyMoneyFile::instance()->baseCurrency().id(); setCommodity(currencyid); MyMoneyMoney price; MyMoneySplit splitLeft; if ( haspayee ) splitLeft.setPayeeId(payeeTest.id()); splitLeft.setAction(_action); splitLeft.setValue(-_value); price = MyMoneyFile::instance()->price(currencyid, file->account(_accountid).currencyId(),_date).rate(file->account(_accountid).currencyId()); splitLeft.setShares(-_value * price); splitLeft.setAccountId(_accountid); addSplit(splitLeft); MyMoneySplit splitRight; if ( haspayee ) splitRight.setPayeeId(payeeTest.id()); splitRight.setAction(_action); splitRight.setValue(_value); price = MyMoneyFile::instance()->price(currencyid, file->account(_categoryid).currencyId(),_date).rate(file->account(_categoryid).currencyId()); splitRight.setShares(_value * price ); splitRight.setAccountId(_categoryid); addSplit(splitRight); MyMoneyFile::instance()->addTransaction(*this); ft.commit(); }
MyMoneyTransaction KNewLoanWizard::transaction() const { MyMoneyTransaction t; bool hasInterest = !field("interestRateEdit").value<MyMoneyMoney>().isZero(); MyMoneySplit sPayment, sInterest, sAmortization; // setup accounts. at this point, we cannot fill in the id of the // account that the amortization will be performed on, because we // create the account. So the id is yet unknown. sPayment.setAccountId(field("paymentAccountEdit").toStringList().first()); //Only create the interest split if not zero if (hasInterest) { sInterest.setAccountId(field("interestAccountEdit").toStringList().first()); sInterest.setValue(MyMoneyMoney::autoCalc); sInterest.setShares(sInterest.value()); sInterest.setAction(MyMoneySplit::ActionInterest); } // values if (field("borrowButton").toBool()) { sPayment.setValue(-field("paymentEdit").value<MyMoneyMoney>()); } else { sPayment.setValue(field("paymentEdit").value<MyMoneyMoney>()); } sAmortization.setValue(MyMoneyMoney::autoCalc); // don't forget the shares sPayment.setShares(sPayment.value()); sAmortization.setShares(sAmortization.value()); // setup the commodity MyMoneyAccount acc = MyMoneyFile::instance()->account(sPayment.accountId()); t.setCommodity(acc.currencyId()); // actions sPayment.setAction(MyMoneySplit::ActionAmortization); sAmortization.setAction(MyMoneySplit::ActionAmortization); // payee QString payeeId = field("payeeEdit").toString(); sPayment.setPayeeId(payeeId); sAmortization.setPayeeId(payeeId); MyMoneyAccount account("Phony-ID", MyMoneyAccount()); sAmortization.setAccountId(account.id()); // IMPORTANT: Payment split must be the first one, because // the schedule view expects it this way during display t.addSplit(sPayment); t.addSplit(sAmortization); if (hasInterest) { t.addSplit(sInterest); } // copy the splits from the other costs and update the payment split foreach (const MyMoneySplit& it, m_transaction.splits()) { if (it.accountId() != account.id()) { MyMoneySplit sp = it; sp.clearId(); t.addSplit(sp); sPayment.setValue(sPayment.value() - sp.value()); sPayment.setShares(sPayment.value()); t.modifySplit(sPayment); } } return t; }