void SummaryWizardPage::initializePage()
{
// General
if (field("borrowButton").toBool())
m_summaryLoanType->setText(i18n("borrowed"));
else
m_summaryLoanType->setText(i18n("lend"));
m_summaryFirstPayment->setText(KGlobal::locale()->formatDate(field("firstDueDateEdit").toDate()));
const QString &payeeId = field("payeeEdit").toString();
if (!payeeId.isEmpty()) {
try {
const MyMoneyPayee &payee = MyMoneyFile::instance()->payee(payeeId);
m_summaryPayee->setText(payee.name());
} catch (const MyMoneyException &) {
qWarning("Unable to load the payee name from the id");
}
} else {
m_summaryPayee->setText(i18n("not assigned"));
}
// Calculation
if (field("interestOnReceptionButton").toBool())
m_summaryInterestDue->setText(i18n("on reception"));
else
m_summaryInterestDue->setText(i18n("on due date"));
m_summaryPaymentFrequency->setText(MyMoneySchedule::occurrenceToString(MyMoneySchedule::occurrenceE(field("paymentFrequencyUnitEdit").toInt())));
m_summaryAmount->setText(field("loanAmount6").toString());
m_summaryInterestRate->setText(field("interestRate6").toString());
m_summaryTerm->setText(field("duration6").toString());
m_summaryPeriodicPayment->setText(field("payment6").toString());
m_summaryBalloonPayment->setText(field("balloon6").toString());
// Payment
try {
QStringList sel = field("interestAccountEdit").toStringList();
if (sel.count() != 1)
throw MYMONEYEXCEPTION("Need a single selected interest category");
MyMoneyAccount acc = MyMoneyFile::instance()->account(sel.first());
m_summaryInterestCategory->setText(acc.name());
} catch (const MyMoneyException &) {
qWarning("Unable to determine interest category for loan account creation");
}
m_summaryAdditionalFees->setText(field("additionalCost").toString());
m_summaryTotalPeriodicPayment->setText(field("periodicPayment").toString());
m_summaryNextPayment->setText(KGlobal::locale()->formatDate(field("nextDueDateEdit").toDate()));
try {
QStringList sel = field("paymentAccountEdit").toStringList();
if (sel.count() != 1)
throw MYMONEYEXCEPTION("Need a single selected payment account");
MyMoneyAccount acc = MyMoneyFile::instance()->account(sel.first());
m_summaryPaymentAccount->setText(acc.name());
} catch (const MyMoneyException &) {
qWarning("Unable to determine payment account for loan account creation");
}
}
void MyMoneyAccountTest::testAssignmentConstructor()
{
MyMoneyAccount a;
a.setAccountType(MyMoneyAccount::Checkings);
a.setName("Account");
a.setInstitutionId("Inst1");
a.setDescription("Bla");
a.setNumber("assigned Number");
a.setValue("Key", "Value");
a.addAccountId("ChildAccount");
MyMoneyAccount b;
b.setLastModified(QDate::currentDate());
b = a;
QVERIFY(b.name() == "Account");
QVERIFY(b.institutionId() == "Inst1");
QVERIFY(b.accountType() == MyMoneyAccount::Checkings);
QVERIFY(b.lastModified() == QDate());
QVERIFY(b.openingDate() == a.openingDate());
QVERIFY(b.description() == "Bla");
QVERIFY(b.number() == "assigned Number");
QVERIFY(b.value("Key") == "Value");
QVERIFY(b.accountList().count() == 1);
QVERIFY(b.accountList()[0] == "ChildAccount");
}
void KImportDlg::addCategories(QStringList& strList, const QString& id, const QString& leadIn) const
{
MyMoneyFile *file = MyMoneyFile::instance();
QString name;
MyMoneyAccount account = file->account(id);
QStringList accList = account.accountList();
QStringList::ConstIterator it_a;
for (it_a = accList.constBegin(); it_a != accList.constEnd(); ++it_a) {
account = file->account(*it_a);
strList << leadIn + account.name();
addCategories(strList, *it_a, leadIn + account.name() + MyMoneyFile::AccountSeperator);
}
}
void MyMoneyStorageDump::dumpTransaction(QTextStream& s, IMyMoneyStorage* storage, const MyMoneyTransaction& it_t)
{
s << " ID = " << it_t.id() << "\n";
s << " Postdate = " << it_t.postDate().toString(Qt::ISODate) << "\n";
s << " EntryDate = " << it_t.entryDate().toString(Qt::ISODate) << "\n";
s << " Commodity = [" << it_t.commodity() << "]\n";
s << " Memo = " << it_t.memo() << "\n";
s << " BankID = " << it_t.bankID() << "\n";
dumpKVP("KVP:", s, it_t, 2);
s << " Splits\n";
s << " ------\n";
QList<MyMoneySplit>::ConstIterator it_s;
for (it_s = it_t.splits().constBegin(); it_s != it_t.splits().constEnd(); ++it_s) {
s << " ID = " << (*it_s).id() << "\n";
s << " Transaction = " << (*it_s).transactionId() << "\n";
s << " Payee = " << (*it_s).payeeId();
if (!(*it_s).payeeId().isEmpty()) {
MyMoneyPayee p = storage->payee((*it_s).payeeId());
s << " (" << p.name() << ")" << "\n";
} else
s << " ()\n";
for (int i = 0; i < (*it_s).tagIdList().size(); i++) {
s << " Tag = " << (*it_s).tagIdList()[i];
if (!(*it_s).tagIdList()[i].isEmpty()) {
MyMoneyTag ta = storage->tag((*it_s).tagIdList()[i]);
s << " (" << ta.name() << ")" << "\n";
} else
s << " ()\n";
}
s << " Account = " << (*it_s).accountId();
MyMoneyAccount acc;
try {
acc = storage->account((*it_s).accountId());
s << " (" << acc.name() << ") [" << acc.currencyId() << "]\n";
} catch (const MyMoneyException &) {
s << " (---) [---]\n";
}
s << " Memo = " << (*it_s).memo() << "\n";
if ((*it_s).value() == MyMoneyMoney::autoCalc)
s << " Value = will be calculated" << "\n";
else
s << " Value = " << (*it_s).value().formatMoney("", 2)
<< " (" << (*it_s).value().toString() << ")\n";
s << " Shares = " << (*it_s).shares().formatMoney("", 2)
<< " (" << (*it_s).shares().toString() << ")\n";
s << " Action = '" << (*it_s).action() << "'\n";
s << " Nr = '" << (*it_s).number() << "'\n";
s << " ReconcileFlag = '" << reconcileToString((*it_s).reconcileFlag()) << "'\n";
if ((*it_s).reconcileFlag() != MyMoneySplit::NotReconciled) {
s << " ReconcileDate = " << (*it_s).reconcileDate().toString(Qt::ISODate) << "\n";
}
s << " BankID = " << (*it_s).bankID() << "\n";
dumpKVP("KVP:", s, (*it_s), 4);
s << "\n";
}
s << "\n";
}
void KForecastView::loadAccounts(MyMoneyForecast& forecast, const MyMoneyAccount& account, QTreeWidgetItem* parentItem, int forecastType)
{
QMap<QString, QString> nameIdx;
QStringList accList;
MyMoneyFile* file = MyMoneyFile::instance();
QTreeWidgetItem *forecastItem = 0;
//Get all accounts of the right type to calculate forecast
accList = account.accountList();
if (accList.size() == 0)
return;
QStringList::ConstIterator accList_t;
for (accList_t = accList.constBegin(); accList_t != accList.constEnd(); ++accList_t) {
MyMoneyAccount subAccount = file->account(*accList_t);
//only add the account if it is a forecast account or the parent of a forecast account
if (includeAccount(forecast, subAccount)) {
nameIdx[subAccount.id()] = subAccount.id();
}
}
QMap<QString, QString>::ConstIterator it_nc;
for (it_nc = nameIdx.constBegin(); it_nc != nameIdx.constEnd(); ++it_nc) {
const MyMoneyAccount subAccount = file->account(*it_nc);
MyMoneySecurity currency;
if (subAccount.isInvest()) {
MyMoneySecurity underSecurity = file->security(subAccount.currencyId());
currency = file->security(underSecurity.tradingCurrency());
} else {
currency = file->security(subAccount.currencyId());
}
forecastItem = new QTreeWidgetItem(parentItem);
forecastItem->setText(0, subAccount.name());
forecastItem->setIcon(0, subAccount.accountPixmap());
forecastItem->setData(0, ForecastRole, QVariant::fromValue(forecast));
forecastItem->setData(0, AccountRole, QVariant::fromValue(subAccount));
forecastItem->setExpanded(true);
switch (forecastType) {
case eSummary:
updateSummary(forecastItem);
break;
case eDetailed:
updateDetailed(forecastItem);
break;
case eBudget:
updateBudget(forecastItem);
break;
default:
break;
}
loadAccounts(forecast, subAccount, forecastItem, forecastType);
}
}
void MyMoneyForecast::addFutureTransactions(void)
{
MyMoneyTransactionFilter filter;
MyMoneyFile* file = MyMoneyFile::instance();
// collect and process all transactions that have already been entered but
// are located in the future.
filter.setDateFilter(forecastStartDate(), forecastEndDate());
filter.setReportAllSplits(false);
QValueList<MyMoneyTransaction> transactions = file->transactionList(filter);
QValueList<MyMoneyTransaction>::const_iterator it_t = transactions.begin();
for(; it_t != transactions.end(); ++it_t ) {
const QValueList<MyMoneySplit>& splits = (*it_t).splits();
QValueList<MyMoneySplit>::const_iterator it_s = splits.begin();
for(; it_s != splits.end(); ++it_s ) {
if(!(*it_s).shares().isZero()) {
MyMoneyAccount acc = file->account((*it_s).accountId());
if(isForecastAccount(acc)) {
dailyBalances balance;
balance = m_accountList[acc.id()];
//if it is income, the balance is stored as negative number
if(acc.accountType() == MyMoneyAccount::Income) {
balance[(*it_t).postDate()] += ((*it_s).shares() * MyMoneyMoney(-1, 1));
} else {
balance[(*it_t).postDate()] += (*it_s).shares();
}
m_accountList[acc.id()] = balance;
}
}
}
}
#if 0
QFile trcFile("forecast.csv");
trcFile.open(IO_WriteOnly);
QTextStream s(&trcFile);
{
s << "Already present transactions\n";
QMap<QString, dailyBalances>::Iterator it_a;
QMap<QString, QString>::ConstIterator it_n;
for(it_n = m_nameIdx.begin(); it_n != m_nameIdx.end(); ++it_n) {
MyMoneyAccount acc = file->account(*it_n);
it_a = m_accountList.find(*it_n);
s << "\"" << acc.name() << "\",";
for(int i = 0; i < 90; ++i) {
s << "\"" << (*it_a)[i].formatMoney("") << "\",";
}
s << "\n";
}
}
#endif
}
QString CsvUtil::nameToId(const QString& name, MyMoneyAccount& parent)
{
// Adapted from KMyMoneyApp::createAccount(MyMoneyAccount& newAccount, MyMoneyAccount& parentAccount, MyMoneyAccount& brokerageAccount, MyMoneyMoney openingBal)
// Needed to find/create category:sub-categories
MyMoneyFile* file = MyMoneyFile::instance();
QString id = file->categoryToAccount(name, MyMoneyAccount::UnknownAccountType);
// if it does not exist, we have to create it
if (id.isEmpty()) {
MyMoneyAccount newAccount;
MyMoneyAccount parentAccount = parent;
newAccount.setName(name) ;
int pos;
// check for ':' in the name and use it as separator for a hierarchy
while ((pos = newAccount.name().indexOf(MyMoneyFile::AccountSeperator)) != -1) {
QString part = newAccount.name().left(pos);
QString remainder = newAccount.name().mid(pos + 1);
const MyMoneyAccount& existingAccount = file->subAccountByName(parentAccount, part);
if (existingAccount.id().isEmpty()) {
newAccount.setName(part);
newAccount.setAccountType(parentAccount.accountType());
file->addAccount(newAccount, parentAccount);
parentAccount = newAccount;
} else {
parentAccount = existingAccount;
}
newAccount.setParentAccountId(QString()); // make sure, there's no parent
newAccount.clearId(); // and no id set for adding
newAccount.removeAccountIds(); // and no sub-account ids
newAccount.setName(remainder);
}//end while
newAccount.setAccountType(parentAccount.accountType());
// make sure we have a currency. If none is assigned, we assume base currency
if (newAccount.currencyId().isEmpty())
newAccount.setCurrencyId(file->baseCurrency().id());
file->addAccount(newAccount, parentAccount);
id = newAccount.id();
}
return id;
}
void MyMoneyAccountTest::testEmptyConstructor()
{
MyMoneyAccount a;
QVERIFY(a.id().isEmpty());
QVERIFY(a.name().isEmpty());
QVERIFY(a.accountType() == MyMoneyAccount::UnknownAccountType);
QVERIFY(a.openingDate() == QDate());
QVERIFY(a.lastModified() == QDate());
QVERIFY(a.lastReconciliationDate() == QDate());
QVERIFY(a.accountList().count() == 0);
QVERIFY(a.balance().isZero());
}
void MyMoneyAccountTest::testSetFunctions()
{
MyMoneyAccount a;
QDate today(QDate::currentDate());
QVERIFY(a.name().isEmpty());
QVERIFY(a.lastModified() == QDate());
QVERIFY(a.description().isEmpty());
a.setName("Account");
a.setInstitutionId("Institution1");
a.setLastModified(today);
a.setDescription("Desc");
a.setNumber("123456");
a.setAccountType(MyMoneyAccount::MoneyMarket);
QVERIFY(a.name() == "Account");
QVERIFY(a.institutionId() == "Institution1");
QVERIFY(a.lastModified() == today);
QVERIFY(a.description() == "Desc");
QVERIFY(a.number() == "123456");
QVERIFY(a.accountType() == MyMoneyAccount::MoneyMarket);
}
void MyMoneyQifWriter::writeCategoryEntry(QTextStream &s, const QString& accountId, const QString& leadIn)
{
MyMoneyAccount acc = MyMoneyFile::instance()->account(accountId);
QString name = acc.name();
s << "N" << leadIn << name << endl;
s << (MyMoneyAccount::accountGroup(acc.accountType()) == MyMoneyAccount::Expense ? "E" : "I") << endl;
s << "^" << endl;
QStringList list = acc.accountList();
QStringList::Iterator it;
name += ":";
for(it = list.begin(); it != list.end(); ++it) {
writeCategoryEntry(s, *it, name);
}
}
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);
}
}
QList<MyMoneyPrice> KForecastView::getAccountPrices(const MyMoneyAccount& acc)
{
MyMoneyFile* file = MyMoneyFile::instance();
QList<MyMoneyPrice> prices;
MyMoneySecurity security = file->baseCurrency();
try {
if (acc.isInvest()) {
security = file->security(acc.currencyId());
if (security.tradingCurrency() != file->baseCurrency().id()) {
MyMoneySecurity sec = file->security(security.tradingCurrency());
prices += file->price(sec.id(), file->baseCurrency().id());
}
} else if (acc.currencyId() != file->baseCurrency().id()) {
if (acc.currencyId() != file->baseCurrency().id()) {
security = file->security(acc.currencyId());
prices += file->price(acc.currencyId(), file->baseCurrency().id());
}
}
} catch (const MyMoneyException &e) {
qDebug() << Q_FUNC_INFO << " caught exception while adding " << acc.name() << "[" << acc.id() << "]: " << e.what();
}
return prices;
}
bool MyMoneyTemplate::addAccountStructure(QDomElement& parent, const MyMoneyAccount& acc)
{
QDomElement account = m_doc.createElement("account");
parent.appendChild(account);
if (MyMoneyFile::instance()->isStandardAccount(acc.id()))
account.setAttribute(QString("name"), QString());
else
account.setAttribute(QString("name"), acc.name());
account.setAttribute(QString("type"), acc.accountType());
// FIXME: add tax flag stuff
// any child accounts?
if (acc.accountList().count() > 0) {
QList<MyMoneyAccount> list;
MyMoneyFile::instance()->accountList(list, acc.accountList(), false);
QList<MyMoneyAccount>::Iterator it;
for (it = list.begin(); it != list.end(); ++it) {
addAccountStructure(account, *it);
}
}
return true;
}
void CsvUtil::createAccount(MyMoneyAccount& newAccount, MyMoneyAccount& parentAccount, MyMoneyAccount& brokerageAccount, MyMoneyMoney openingBal)
{
MyMoneyFile* file = MyMoneyFile::instance();
// make sure we have a currency. If none is assigned, we assume base currency
if (newAccount.currencyId().isEmpty())
newAccount.setCurrencyId(file->baseCurrency().id());
MyMoneyFileTransaction ft;
try {
int pos;
// check for ':' in the name and use it as separator for a hierarchy
while ((pos = newAccount.name().indexOf(MyMoneyFile::AccountSeperator)) != -1) {
QString part = newAccount.name().left(pos);
QString remainder = newAccount.name().mid(pos + 1);
const MyMoneyAccount& existingAccount = file->subAccountByName(parentAccount, part);
if (existingAccount.id().isEmpty()) {
newAccount.setName(part);
file->addAccount(newAccount, parentAccount);
parentAccount = newAccount;
} else {
parentAccount = existingAccount;
}
newAccount.setParentAccountId(QString()); // make sure, there's no parent
newAccount.clearId(); // and no id set for adding
newAccount.removeAccountIds(); // and no sub-account ids
newAccount.setName(remainder);
}
const MyMoneySecurity& sec = file->security(newAccount.currencyId());
// Check the opening balance
if (openingBal.isPositive() && newAccount.accountGroup() == MyMoneyAccount::Liability) {
QString message = i18n("This account is a liability and if the "
"opening balance represents money owed, then it should be negative. "
"Negate the amount?\n\n"
"Please click Yes to change the opening balance to %1,\n"
"Please click No to leave the amount as %2,\n"
"Please click Cancel to abort the account creation."
, MyMoneyUtils::formatMoney(-openingBal, newAccount, sec)
, MyMoneyUtils::formatMoney(openingBal, newAccount, sec));
int ans = KMessageBox::questionYesNoCancel(0, message);
if (ans == KMessageBox::Yes) {
openingBal = -openingBal;
} else if (ans == KMessageBox::Cancel)
return;
}
file->addAccount(newAccount, parentAccount);
if (newAccount.accountType() == MyMoneyAccount::Investment
&& !brokerageAccount.name().isEmpty()) {
file->addAccount(brokerageAccount, parentAccount);
// set a link from the investment account to the brokerage account
file->modifyAccount(newAccount);
file->createOpeningBalanceTransaction(brokerageAccount, openingBal);
} else
file->createOpeningBalanceTransaction(newAccount, openingBal);
ft.commit();
} catch (const MyMoneyException &e) {
KMessageBox::information(0, i18n("Unable to add account: %1", e.what()));
}
}
KNewAccountDlg::KNewAccountDlg(const MyMoneyAccount& account, bool isEditing, bool categoryEditor, QWidget *parent, const char *name, const QString& title)
: KNewAccountDlgDecl(parent,name,true),
m_account(account),
m_bSelectedParentAccount(false),
m_categoryEditor(categoryEditor),
m_isEditing(isEditing)
{
QString columnName = ( (categoryEditor) ? i18n("Categories") : i18n("Accounts") );
m_qlistviewParentAccounts->setRootIsDecorated(true);
m_qlistviewParentAccounts->setAllColumnsShowFocus(true);
m_qlistviewParentAccounts->setSectionHeader(columnName);
m_qlistviewParentAccounts->setMultiSelection(false);
m_qlistviewParentAccounts->header()->setResizeEnabled(true);
m_qlistviewParentAccounts->setColumnWidthMode(0, QListView::Maximum);
m_qlistviewParentAccounts->setEnabled(false);
// never show the horizontal scroll bar
m_qlistviewParentAccounts->setHScrollBarMode(QScrollView::AlwaysOff);
m_subAccountLabel->setText(i18n("Is a sub account"));
m_qlistviewParentAccounts->header()->setFont(KMyMoneyGlobalSettings::listHeaderFont());
accountNameEdit->setText(account.name());
descriptionEdit->setText(account.description());
typeCombo->setEnabled(true);
MyMoneyFile *file = MyMoneyFile::instance();
// load the price mode combo
m_priceMode->insertItem(i18n("default price mode", "<default>"), 0);
m_priceMode->insertItem(i18n("Price per share"), 1);
m_priceMode->insertItem(i18n("Total for all shares"), 2);
int priceMode = 0;
if(m_account.accountType() == MyMoneyAccount::Investment) {
m_priceMode->setEnabled(true);
if(!m_account.value("priceMode").isEmpty())
priceMode = m_account.value("priceMode").toInt();
}
m_priceMode->setCurrentItem(priceMode);
bool haveMinBalance = false;
bool haveMaxCredit = false;
if (categoryEditor)
{
// get rid of the tabs that are not used for categories
QWidget* tab = m_tab->page(m_tab->indexOf(m_institutionTab));
if(tab)
m_tab->removePage(tab);
tab = m_tab->page(m_tab->indexOf(m_limitsTab));
if(tab)
m_tab->removePage(tab);
//m_qlistviewParentAccounts->setEnabled(true);
startDateEdit->setEnabled(false);
accountNoEdit->setEnabled(false);
m_institutionBox->hide();
m_qcheckboxNoVat->hide();
typeCombo->insertItem(KMyMoneyUtils::accountTypeToString(MyMoneyAccount::Income));
typeCombo->insertItem(KMyMoneyUtils::accountTypeToString(MyMoneyAccount::Expense));
// Hardcoded but acceptable
switch (account.accountType())
{
case MyMoneyAccount::Income:
typeCombo->setCurrentItem(0);
break;
case MyMoneyAccount::Expense:
default:
typeCombo->setCurrentItem(1);
break;
}
m_currency->setEnabled(true);
if (m_isEditing)
{
typeCombo->setEnabled(false);
m_currency->setDisabled(MyMoneyFile::instance()->isReferenced(m_account));
}
m_qcheckboxPreferred->hide();
m_qcheckboxTax->setChecked(account.value("Tax") == "Yes");
loadVatAccounts();
}
else
{
// get rid of the tabs that are not used for accounts
QWidget* taxtab = m_tab->page(m_tab->indexOf(m_taxTab));
if (taxtab) {
if(m_account.isAssetLiability()) {
m_vatCategory->setText(i18n( "VAT account"));
m_vatAssignmentFrame->hide();
m_qcheckboxTax->setChecked(account.value("Tax") == "Yes");
} else {
m_tab->removePage(taxtab);
}
}
switch(m_account.accountType()) {
case MyMoneyAccount::Savings:
case MyMoneyAccount::Cash:
haveMinBalance = true;
break;
case MyMoneyAccount::Checkings:
haveMinBalance = true;
haveMaxCredit = true;
break;
case MyMoneyAccount::CreditCard:
haveMaxCredit = true;
break;
default:
// no limit available, so we might get rid of the tab
QWidget* tab = m_tab->page(m_tab->indexOf(m_limitsTab));
if(tab)
m_tab->removePage(tab);
// don't try to hide the widgets we just wiped
// in the next step
haveMaxCredit = haveMinBalance = true;
break;
}
if(!haveMaxCredit) {
m_maxCreditLabel->setEnabled(false);
m_maxCreditLabel->hide();
m_maxCreditEarlyEdit->hide();
m_maxCreditAbsoluteEdit->hide();
}
if(!haveMinBalance) {
m_minBalanceLabel->setEnabled(false);
m_minBalanceLabel->hide();
m_minBalanceEarlyEdit->hide();
m_minBalanceAbsoluteEdit->hide();
}
typeCombo->insertItem(KMyMoneyUtils::accountTypeToString(MyMoneyAccount::Checkings));
typeCombo->insertItem(KMyMoneyUtils::accountTypeToString(MyMoneyAccount::Savings));
typeCombo->insertItem(KMyMoneyUtils::accountTypeToString(MyMoneyAccount::Cash));
typeCombo->insertItem(KMyMoneyUtils::accountTypeToString(MyMoneyAccount::CreditCard));
typeCombo->insertItem(KMyMoneyUtils::accountTypeToString(MyMoneyAccount::Loan));
typeCombo->insertItem(KMyMoneyUtils::accountTypeToString(MyMoneyAccount::Investment));
typeCombo->insertItem(KMyMoneyUtils::accountTypeToString(MyMoneyAccount::Asset));
typeCombo->insertItem(KMyMoneyUtils::accountTypeToString(MyMoneyAccount::Liability));
typeCombo->insertItem(KMyMoneyUtils::accountTypeToString(MyMoneyAccount::Stock));
/*
typeCombo->insertItem(KMyMoneyUtils::accountTypeToString(MyMoneyAccount::CertificateDep));
typeCombo->insertItem(KMyMoneyUtils::accountTypeToString(MyMoneyAccount::MoneyMarket));
typeCombo->insertItem(KMyMoneyUtils::accountTypeToString(MyMoneyAccount::Currency));
*/
// Hardcoded but acceptable
switch (account.accountType())
{
default:
case MyMoneyAccount::Checkings:
typeCombo->setCurrentItem(0);
break;
case MyMoneyAccount::Savings:
typeCombo->setCurrentItem(1);
break;
case MyMoneyAccount::Cash:
typeCombo->setCurrentItem(2);
break;
case MyMoneyAccount::CreditCard:
typeCombo->setCurrentItem(3);
break;
case MyMoneyAccount::Loan:
typeCombo->setCurrentItem(4);
break;
case MyMoneyAccount::Investment:
typeCombo->setCurrentItem(5);
break;
case MyMoneyAccount::Asset:
typeCombo->setCurrentItem(6);
break;
case MyMoneyAccount::Liability:
typeCombo->setCurrentItem(7);
break;
case MyMoneyAccount::Stock:
m_institutionBox->hide();
typeCombo->setCurrentItem(8);
break;
/*
case MyMoneyAccount::CertificateDep:
typeCombo->setCurrentItem(5);
break;
case MyMoneyAccount::MoneyMarket:
typeCombo->setCurrentItem(7);
break;
case MyMoneyAccount::Currency:
typeCombo->setCurrentItem(8);
break;
*/
}
if(!m_account.openingDate().isValid())
m_account.setOpeningDate(QDate::currentDate());
startDateEdit->setDate(m_account.openingDate());
accountNoEdit->setText(account.number());
m_qcheckboxPreferred->setChecked(account.value("PreferredAccount") == "Yes");
m_qcheckboxNoVat->setChecked(account.value("NoVat") == "Yes");
loadKVP("iban", ibanEdit);
loadKVP("minBalanceAbsolute", m_minBalanceAbsoluteEdit);
loadKVP("minBalanceEarly", m_minBalanceEarlyEdit);
loadKVP("maxCreditAbsolute", m_maxCreditAbsoluteEdit);
loadKVP("maxCreditEarly", m_maxCreditEarlyEdit);
// reverse the sign for display purposes
if(!m_maxCreditAbsoluteEdit->lineedit()->text().isEmpty())
m_maxCreditAbsoluteEdit->setValue(m_maxCreditAbsoluteEdit->value()*MyMoneyMoney(-1,1));
if(!m_maxCreditEarlyEdit->lineedit()->text().isEmpty())
m_maxCreditEarlyEdit->setValue(m_maxCreditEarlyEdit->value()*MyMoneyMoney(-1,1));
loadKVP("lastNumberUsed", m_lastCheckNumberUsed);
// we do not allow to change the account type once an account
// was created. Same applies to currency if it is referenced.
if (m_isEditing)
{
typeCombo->setEnabled(false);
m_currency->setDisabled(MyMoneyFile::instance()->isReferenced(m_account));
}
if(m_account.isInvest()) {
typeCombo->setEnabled(false);
m_qcheckboxPreferred->hide();
m_currencyText->hide();
m_currency->hide();
} else {
// use the old field and override a possible new value
if(!MyMoneyMoney(account.value("minimumBalance")).isZero()) {
m_minBalanceAbsoluteEdit->setValue(MyMoneyMoney(account.value("minimumBalance")));
}
}
// m_qcheckboxTax->hide(); TODO should only be visible for VAT category/account
}
m_currency->setSecurity(file->currency(account.currencyId()));
// Load the institutions
// then the accounts
QString institutionName;
try
{
if (m_isEditing && !account.institutionId().isEmpty())
institutionName = file->institution(account.institutionId()).name();
else
institutionName = QString();
}
catch (MyMoneyException *e)
{
qDebug("exception in init for account dialog: %s", e->what().latin1());
delete e;
}
initParentWidget(account.parentAccountId(), account.id());
if(m_account.isInvest())
m_qlistviewParentAccounts->setEnabled(false);
if (!categoryEditor)
slotLoadInstitutions(institutionName);
accountNameEdit->setFocus();
if (title)
setCaption(title);
// load button icons
KIconLoader* il = KGlobal::iconLoader();
cancelButton->setGuiItem(KStdGuiItem::cancel());
createButton->setGuiItem(KStdGuiItem::ok());
connect(cancelButton, SIGNAL(clicked()), SLOT(reject()));
connect(createButton, SIGNAL(clicked()), this, SLOT(okClicked()));
connect(m_qlistviewParentAccounts, SIGNAL(selectionChanged(QListViewItem*)),
this, SLOT(slotSelectionChanged(QListViewItem*)));
connect(m_qbuttonNew, SIGNAL(clicked()), this, SLOT(slotNewClicked()));
connect(typeCombo, SIGNAL(activated(const QString&)),
this, SLOT(slotAccountTypeChanged(const QString&)));
connect(accountNameEdit, SIGNAL(textChanged(const QString&)), this, SLOT(slotCheckFinished()));
connect(m_vatCategory, SIGNAL(toggled(bool)), this, SLOT(slotVatChanged(bool)));
connect(m_vatAssignment, SIGNAL(toggled(bool)), this, SLOT(slotVatAssignmentChanged(bool)));
connect(m_vatCategory, SIGNAL(toggled(bool)), this, SLOT(slotCheckFinished()));
connect(m_vatAssignment, SIGNAL(toggled(bool)), this, SLOT(slotCheckFinished()));
connect(m_vatRate, SIGNAL(textChanged(const QString&)), this, SLOT(slotCheckFinished()));
connect(m_vatAccount, SIGNAL(stateChanged()), this, SLOT(slotCheckFinished()));
connect(m_minBalanceEarlyEdit, SIGNAL(valueChanged(const QString&)), this, SLOT(slotAdjustMinBalanceAbsoluteEdit(const QString&)));
connect(m_minBalanceAbsoluteEdit, SIGNAL(valueChanged(const QString&)), this, SLOT(slotAdjustMinBalanceEarlyEdit(const QString&)));
connect(m_maxCreditEarlyEdit, SIGNAL(valueChanged(const QString&)), this, SLOT(slotAdjustMaxCreditAbsoluteEdit(const QString&)));
connect(m_maxCreditAbsoluteEdit, SIGNAL(valueChanged(const QString&)), this, SLOT(slotAdjustMaxCreditEarlyEdit(const QString&)));
connect(m_qcomboboxInstitutions, SIGNAL(activated(const QString&)), this, SLOT(slotLoadInstitutions(const QString&)));
m_vatCategory->setChecked(false);
m_vatAssignment->setChecked(false);
// make sure our account does not have an id and no parent assigned
// and certainly no children in case we create a new account
if(!m_isEditing) {
m_account.clearId();
m_account.setParentAccountId(QString());
QStringList::ConstIterator it;
while((it = m_account.accountList().begin()) != m_account.accountList().end())
m_account.removeAccountId(*it);
if(m_parentItem == 0) {
// force loading of initial parent
m_account.setAccountType(MyMoneyAccount::UnknownAccountType);
MyMoneyAccount::_accountTypeE type = account.accountType();
if(type == MyMoneyAccount::UnknownAccountType)
type = MyMoneyAccount::Checkings;
slotAccountTypeChanged(KMyMoneyUtils::accountTypeToString(type));
}
} else {
if(!m_account.value("VatRate").isEmpty()) {
m_vatCategory->setChecked(true);
m_vatRate->setValue(MyMoneyMoney(m_account.value("VatRate"))*MyMoneyMoney(100,1));
} else {
if(!m_account.value("VatAccount").isEmpty()) {
QString accId = m_account.value("VatAccount").latin1();
try {
// make sure account exists
MyMoneyFile::instance()->account(accId);
m_vatAssignment->setChecked(true);
m_vatAccount->setSelected(accId);
m_grossAmount->setChecked(true);
if(m_account.value("VatAmount") == "Net")
m_netAmount->setChecked(true);
} catch(MyMoneyException *e) {
delete e;
}
}
}
}
slotVatChanged(m_vatCategory->isChecked());
slotVatAssignmentChanged(m_vatAssignment->isChecked());
slotCheckFinished();
kMandatoryFieldGroup* requiredFields = new kMandatoryFieldGroup (this);
requiredFields->setOkButton(createButton); // button to be enabled when all fields present
requiredFields->add(accountNameEdit);
// using a timeout is the only way, I got the 'ensureItemVisible'
// working when creating the dialog. I assume, this
// has something to do with the delayed update of the display somehow.
QTimer::singleShot(50, this, SLOT(timerDone()));
}
void KNewAccountDlg::okClicked()
{
MyMoneyFile* file = MyMoneyFile::instance();
QString accountNameText = accountNameEdit->text();
if (accountNameText.isEmpty())
{
KMessageBox::error(this, i18n("You have not specified a name.\nPlease fill in this field."));
accountNameEdit->setFocus();
return;
}
MyMoneyAccount parent = parentAccount();
if (parent.name().length() == 0)
{
KMessageBox::error(this, i18n("Please select a parent account."));
return;
}
if (!m_categoryEditor)
{
QString institutionNameText = m_qcomboboxInstitutions->currentText();
if (institutionNameText != i18n("<No Institution>"))
{
try
{
MyMoneyFile *file = MyMoneyFile::instance();
QValueList<MyMoneyInstitution> list = file->institutionList();
QValueList<MyMoneyInstitution>::ConstIterator institutionIterator;
for (institutionIterator = list.begin(); institutionIterator != list.end(); ++institutionIterator)
{
if ((*institutionIterator).name() == institutionNameText)
m_account.setInstitutionId((*institutionIterator).id());
}
}
catch (MyMoneyException *e)
{
qDebug("Exception in account institution set: %s", e->what().latin1());
delete e;
}
}
else
{
m_account.setInstitutionId(QString());
}
}
m_account.setName(accountNameText);
m_account.setNumber(accountNoEdit->text());
storeKVP("iban", ibanEdit);
storeKVP("minBalanceAbsolute", m_minBalanceAbsoluteEdit);
storeKVP("minBalanceEarly", m_minBalanceEarlyEdit);
// the figures for credit line with reversed sign
if(!m_maxCreditAbsoluteEdit->lineedit()->text().isEmpty())
m_maxCreditAbsoluteEdit->setValue(m_maxCreditAbsoluteEdit->value()*MyMoneyMoney(-1,1));
if(!m_maxCreditEarlyEdit->lineedit()->text().isEmpty())
m_maxCreditEarlyEdit->setValue(m_maxCreditEarlyEdit->value()*MyMoneyMoney(-1,1));
storeKVP("maxCreditAbsolute", m_maxCreditAbsoluteEdit);
storeKVP("maxCreditEarly", m_maxCreditEarlyEdit);
if(!m_maxCreditAbsoluteEdit->lineedit()->text().isEmpty())
m_maxCreditAbsoluteEdit->setValue(m_maxCreditAbsoluteEdit->value()*MyMoneyMoney(-1,1));
if(!m_maxCreditEarlyEdit->lineedit()->text().isEmpty())
m_maxCreditEarlyEdit->setValue(m_maxCreditEarlyEdit->value()*MyMoneyMoney(-1,1));
storeKVP("lastNumberUsed", m_lastCheckNumberUsed);
// delete a previous version of the minimumbalance information
storeKVP("minimumBalance", QString(), QString());
MyMoneyAccount::accountTypeE acctype;
if (!m_categoryEditor)
{
acctype = KMyMoneyUtils::stringToAccountType(typeCombo->currentText());
// If it's a loan, check if the parent is asset or liability. In
// case of asset, we change the account type to be AssetLoan
if(acctype == MyMoneyAccount::Loan
&& parent.accountGroup() == MyMoneyAccount::Asset)
acctype = MyMoneyAccount::AssetLoan;
#if 0
// we do allow the same name for different accounts, so
// we don't need this check anymore.
if(!file->nameToAccount(accountNameText).isEmpty()
&& (file->nameToAccount(accountNameText) != m_account.id())) {
KMessageBox::error(this, QString("<qt>")+i18n("An account named <b>%1</b> already exists. You cannot create a second account with the same name.").arg(accountNameText)+QString("</qt>"));
return;
}
#endif
}
else
{
acctype = parent.accountGroup();
QString newName;
if(!MyMoneyFile::instance()->isStandardAccount(parent.id())) {
newName = MyMoneyFile::instance()->accountToCategory(parent.id()) + MyMoneyFile::AccountSeperator;
}
newName += accountNameText;
if(!file->categoryToAccount(newName, acctype).isEmpty()
&& (file->categoryToAccount(newName, acctype) != m_account.id())) {
KMessageBox::error(this, QString("<qt>")+i18n("A category named <b>%1</b> already exists. You cannot create a second category with the same name.").arg(newName)+QString("</qt>"));
return;
}
}
m_account.setAccountType(acctype);
m_account.setDescription(descriptionEdit->text());
if (!m_categoryEditor)
{
m_account.setOpeningDate(startDateEdit->date());
m_account.setCurrencyId(m_currency->security().id());
if(m_qcheckboxPreferred->isChecked())
m_account.setValue("PreferredAccount", "Yes");
else
m_account.deletePair("PreferredAccount");
if(m_qcheckboxNoVat->isChecked())
m_account.setValue("NoVat", "Yes");
else
m_account.deletePair("NoVat");
if(m_minBalanceAbsoluteEdit->isVisible()) {
m_account.setValue("minimumBalance", m_minBalanceAbsoluteEdit->value().toString());
}
}
else
{
if(KMyMoneyGlobalSettings::hideUnusedCategory() && !m_isEditing) {
KMessageBox::information(this, i18n("You have selected to suppress the display of unused categories in the KMyMoney configuration dialog. The category you just created will therefore only be shown if it is used. Otherwise, it will be hidden in the accounts/categories view."), i18n("Hidden categories"), "NewHiddenCategory");
}
}
if ( m_qcheckboxTax->isChecked())
m_account.setValue("Tax", "Yes");
else
m_account.deletePair("Tax");
m_account.deletePair("VatAccount");
m_account.deletePair("VatAmount");
m_account.deletePair("VatRate");
if(m_vatCategory->isChecked()) {
m_account.setValue("VatRate", (m_vatRate->value().abs() / MyMoneyMoney(100,1)).toString());
} else {
if(m_vatAssignment->isChecked()) {
m_account.setValue("VatAccount", m_vatAccount->selectedItems().first());
if(m_netAmount->isChecked())
m_account.setValue("VatAmount", "Net");
}
}
accept();
}
void MyMoneyStorageDump::writeStream(QDataStream& _s, IMyMoneySerialize* _storage)
{
QTextStream s(_s.device());
IMyMoneyStorage* storage = dynamic_cast<IMyMoneyStorage *>(_storage);
MyMoneyPayee user = storage->user();
s << "File-Info\n";
s << "---------\n";
s << "user name = " << user.name() << "\n";
s << "user street = " << user.address() << "\n";
s << "user city = " << user.city() << "\n";
s << "user city = " << user.state() << "\n";
s << "user zip = " << user.postcode() << "\n";
s << "user telephone = " << user.telephone() << "\n";
s << "user e-mail = " << user.email() << "\n";
s << "creation date = " << storage->creationDate().toString(Qt::ISODate) << "\n";
s << "last modification date = " << storage->lastModificationDate().toString(Qt::ISODate) << "\n";
s << "base currency = " << storage->value("kmm-baseCurrency") << "\n";
s << "\n";
s << "Internal-Info\n";
s << "-------------\n";
QList<MyMoneyAccount> list_a;
storage->accountList(list_a);
s << "accounts = " << list_a.count() << ", next id = " << _storage->accountId() << "\n";
MyMoneyTransactionFilter filter;
filter.setReportAllSplits(false);
QList<MyMoneyTransaction> list_t;
storage->transactionList(list_t, filter);
QList<MyMoneyTransaction>::ConstIterator it_t;
s << "transactions = " << list_t.count() << ", next id = " << _storage->transactionId() << "\n";
QMap<int, int> xferCount;
for (it_t = list_t.constBegin(); it_t != list_t.constEnd(); ++it_t) {
QList<MyMoneySplit>::ConstIterator it_s;
int accountCount = 0;
for (it_s = (*it_t).splits().constBegin(); it_s != (*it_t).splits().constEnd(); ++it_s) {
MyMoneyAccount acc = storage->account((*it_s).accountId());
if (acc.accountGroup() != MyMoneyAccount::Expense
&& acc.accountGroup() != MyMoneyAccount::Income)
accountCount++;
}
if (accountCount > 1)
xferCount[accountCount] = xferCount[accountCount] + 1;
}
QMap<int, int>::ConstIterator it_cnt;
for (it_cnt = xferCount.constBegin(); it_cnt != xferCount.constEnd(); ++it_cnt) {
s << " " << *it_cnt << " of them references " << it_cnt.key() << " accounts\n";
}
s << "payees = " << _storage->payeeList().count() << ", next id = " << _storage->payeeId() << "\n";
s << "tags = " << _storage->tagList().count() << ", next id = " << _storage->tagId() << "\n";
s << "institutions = " << _storage->institutionList().count() << ", next id = " << _storage->institutionId() << "\n";
s << "schedules = " << _storage->scheduleList().count() << ", next id = " << _storage->scheduleId() << "\n";
s << "\n";
s << "Institutions\n";
s << "------------\n";
QList<MyMoneyInstitution> list_i = storage->institutionList();
QList<MyMoneyInstitution>::ConstIterator it_i;
for (it_i = list_i.constBegin(); it_i != list_i.constEnd(); ++it_i) {
s << " ID = " << (*it_i).id() << "\n";
s << " Name = " << (*it_i).name() << "\n";
s << "\n";
}
s << "\n";
s << "Payees" << "\n";
s << "------" << "\n";
QList<MyMoneyPayee> list_p = storage->payeeList();
QList<MyMoneyPayee>::ConstIterator it_p;
for (it_p = list_p.constBegin(); it_p != list_p.constEnd(); ++it_p) {
s << " ID = " << (*it_p).id() << "\n";
s << " Name = " << (*it_p).name() << "\n";
s << " Address = " << (*it_p).address() << "\n";
s << " City = " << (*it_p).city() << "\n";
s << " State = " << (*it_p).state() << "\n";
s << " Zip = " << (*it_p).postcode() << "\n";
s << " E-Mail = " << (*it_p).email() << "\n";
s << " Telephone = " << (*it_p).telephone() << "\n";
s << " Reference = " << (*it_p).reference() << "\n";
s << "\n";
}
s << "\n";
s << "Tags" << "\n";
s << "------" << "\n";
QList<MyMoneyTag> list_ta = storage->tagList();
QList<MyMoneyTag>::ConstIterator it_ta;
for (it_ta = list_ta.constBegin(); it_ta != list_ta.constEnd(); ++it_ta) {
s << " ID = " << (*it_ta).id() << "\n";
s << " Name = " << (*it_ta).name() << "\n";
s << " Closed = " << (*it_ta).isClosed() << "\n";
s << " TagColor = " << (*it_ta).tagColor().name() << "\n";
s << " Notes = " << (*it_ta).notes() << "\n";
s << "\n";
}
s << "\n";
s << "Accounts" << "\n";
s << "--------" << "\n";
list_a.push_front(storage->equity());
list_a.push_front(storage->expense());
list_a.push_front(storage->income());
list_a.push_front(storage->liability());
list_a.push_front(storage->asset());
QList<MyMoneyAccount>::ConstIterator it_a;
for (it_a = list_a.constBegin(); it_a != list_a.constEnd(); ++it_a) {
s << " ID = " << (*it_a).id() << "\n";
s << " Name = " << (*it_a).name() << "\n";
s << " Number = " << (*it_a).number() << "\n";
s << " Description = " << (*it_a).description() << "\n";
s << " Type = " << (*it_a).accountType() << "\n";
if ((*it_a).currencyId().isEmpty()) {
s << " Currency = unknown\n";
} else {
if ((*it_a).isInvest()) {
s << " Equity = " << storage->security((*it_a).currencyId()).name() << "\n";
} else {
s << " Currency = " << storage->currency((*it_a).currencyId()).name() << "\n";
}
}
s << " Parent = " << (*it_a).parentAccountId();
if (!(*it_a).parentAccountId().isEmpty()) {
MyMoneyAccount parent = storage->account((*it_a).parentAccountId());
s << " (" << parent.name() << ")";
} else {
s << "n/a";
}
s << "\n";
s << " Institution = " << (*it_a).institutionId();
if (!(*it_a).institutionId().isEmpty()) {
MyMoneyInstitution inst = storage->institution((*it_a).institutionId());
s << " (" << inst.name() << ")";
} else {
s << "n/a";
}
s << "\n";
s << " Opening date = " << (*it_a).openingDate().toString(Qt::ISODate) << "\n";
s << " Last modified = " << (*it_a).lastModified().toString(Qt::ISODate) << "\n";
s << " Last reconciled = " << (*it_a).lastReconciliationDate().toString(Qt::ISODate) << "\n";
s << " Balance = " << (*it_a).balance().formatMoney("", 2) << "\n";
dumpKVP(" KVP: ", s, *it_a);
dumpKVP(" OnlineBankingSettings: ", s, (*it_a).onlineBankingSettings());
QStringList list_s = (*it_a).accountList();
QStringList::ConstIterator it_s;
if (list_s.count() > 0) {
s << " Children =" << "\n";
}
for (it_s = list_s.constBegin(); it_s != list_s.constEnd(); ++it_s) {
MyMoneyAccount child = storage->account(*it_s);
s << " " << *it_s << " (" << child.name() << ")\n";
}
s << "\n";
}
s << "\n";
#if 0
s << "Currencies" << "\n";
s << "----------" << "\n";
QList<MyMoneyCurrency> list_c = storage->currencyList();
QList<MyMoneyCurrency>::ConstIterator it_c;
for (it_c = list_c.begin(); it_c != list_c.end(); ++it_c) {
s << " Name = " << (*it_c).name() << "\n";
s << " ID = " << (*it_c).id() << "\n";
s << " Symbol = " << (*it_c).tradingSymbol() << "\n";
s << " Parts/Unit = " << (*it_c).partsPerUnit() << "\n";
s << " smallest cash fraction = " << (*it_c).smallestCashFraction() << "\n";
s << " smallest account fraction = " << (*it_c).smallestAccountFraction() << "\n";
dumpPriceHistory(s, (*it_c).priceHistory());
s << "\n";
}
s << "\n";
#endif
s << "Securities" << "\n";
s << "----------" << "\n";
QList<MyMoneySecurity> list_e = storage->securityList();
QList<MyMoneySecurity>::ConstIterator it_e;
for (it_e = list_e.constBegin(); it_e != list_e.constEnd(); ++it_e) {
s << " Name = " << (*it_e).name() << "\n";
s << " ID = " << (*it_e).id() << "\n";
s << " Market = " << (*it_e).tradingMarket() << "\n";
s << " Symbol = " << (*it_e).tradingSymbol() << "\n";
s << " Currency = " << (*it_e).tradingCurrency() << " (";
if ((*it_e).tradingCurrency().isEmpty()) {
s << "unknown";
} else {
MyMoneySecurity tradingCurrency = storage->currency((*it_e).tradingCurrency());
if (!tradingCurrency.isCurrency()) {
s << "invalid currency: ";
}
s << tradingCurrency.name();
}
s << ")\n";
s << " Type = " << MyMoneySecurity::securityTypeToString((*it_e).securityType()) << "\n";
s << " smallest account fraction = " << (*it_e).smallestAccountFraction() << "\n";
s << " KVP: " << "\n";
QMap<QString, QString>kvp = (*it_e).pairs();
QMap<QString, QString>::Iterator it;
for (it = kvp.begin(); it != kvp.end(); ++it) {
s << " '" << it.key() << "' = '" << it.value() << "'\n";
}
s << "\n";
}
s << "\n";
s << "Prices" << "\n";
s << "--------" << "\n";
MyMoneyPriceList list_pr = _storage->priceList();
MyMoneyPriceList::ConstIterator it_pr;
for (it_pr = list_pr.constBegin(); it_pr != list_pr.constEnd(); ++it_pr) {
s << " From = " << it_pr.key().first << "\n";
s << " To = " << it_pr.key().second << "\n";
MyMoneyPriceEntries::ConstIterator it_pre;
for (it_pre = (*it_pr).constBegin(); it_pre != (*it_pr).constEnd(); ++it_pre) {
s << " Date = " << (*it_pre).date().toString() << "\n";
s << " Price = " << (*it_pre).rate(QString()).formatMoney("", 8) << "\n";
s << " Source = " << (*it_pre).source() << "\n";
s << " From = " << (*it_pre).from() << "\n";
s << " To = " << (*it_pre).to() << "\n";
}
s << "\n";
}
s << "\n";
s << "Transactions" << "\n";
s << "------------" << "\n";
for (it_t = list_t.constBegin(); it_t != list_t.constEnd(); ++it_t) {
dumpTransaction(s, storage, *it_t);
}
s << "\n";
s << "Schedules" << "\n";
s << "---------" << "\n";
QList<MyMoneySchedule> list_s = storage->scheduleList();
QList<MyMoneySchedule>::ConstIterator it_s;
for (it_s = list_s.constBegin(); it_s != list_s.constEnd(); ++it_s) {
s << " ID = " << (*it_s).id() << "\n";
s << " Name = " << (*it_s).name() << "\n";
s << " Startdate = " << (*it_s).startDate().toString(Qt::ISODate) << "\n";
if ((*it_s).willEnd())
s << " Enddate = " << (*it_s).endDate().toString(Qt::ISODate) << "\n";
else
s << " Enddate = not specified\n";
s << " Occurence = " << (*it_s).occurrenceToString() << "\n"; // krazy:exclude=spelling
s << " OccurenceMultiplier = " << (*it_s).occurrenceMultiplier() << "\n";
s << " Type = " << MyMoneySchedule::scheduleTypeToString((*it_s).type()) << "\n";
s << " Paymenttype = " << MyMoneySchedule::paymentMethodToString((*it_s).paymentType()) << "\n";
s << " Fixed = " << (*it_s).isFixed() << "\n";
s << " AutoEnter = " << (*it_s).autoEnter() << "\n";
if ((*it_s).lastPayment().isValid())
s << " Last payment = " << (*it_s).lastPayment().toString(Qt::ISODate) << "\n";
else
s << " Last payment = not defined" << "\n";
if ((*it_s).isFinished())
s << " Next payment = payment finished" << "\n";
else {
s << " Next payment = " << (*it_s).nextDueDate().toString(Qt::ISODate) << "\n";
if ((*it_s).isOverdue())
s << " = overdue!" << "\n";
}
QList<QDate> list_d;
QList<QDate>::ConstIterator it_d;
list_d = (*it_s).recordedPayments();
if (list_d.count() > 0) {
s << " Recorded payments" << "\n";
for (it_d = list_d.constBegin(); it_d != list_d.constEnd(); ++it_d) {
s << " " << (*it_d).toString(Qt::ISODate) << "\n";
}
}
s << " TRANSACTION\n";
dumpTransaction(s, storage, (*it_s).transaction());
}
s << "\n";
s << "Reports" << "\n";
s << "-------" << "\n";
QList<MyMoneyReport> list_r = storage->reportList();
QList<MyMoneyReport>::ConstIterator it_r;
for (it_r = list_r.constBegin(); it_r != list_r.constEnd(); ++it_r) {
s << " ID = " << (*it_r).id() << "\n";
s << " Name = " << (*it_r).name() << "\n";
}
s << "Budgets" << "\n";
s << "-------" << "\n";
QList<MyMoneyBudget> list_b = storage->budgetList();
QList<MyMoneyBudget>::ConstIterator it_b;
for (it_b = list_b.constBegin(); it_b != list_b.constEnd(); ++it_b) {
s << " ID = " << (*it_b).id() << "\n";
s << " Name = " << (*it_b).name() << "\n";
}
}
void MyMoneyForecast::addScheduledTransactions (void)
{
MyMoneyFile* file = MyMoneyFile::instance();
// now process all the schedules that may have an impact
QValueList<MyMoneySchedule> schedule;
schedule = file->scheduleList("", MyMoneySchedule::TYPE_ANY, MyMoneySchedule::OCCUR_ANY, MyMoneySchedule::STYPE_ANY,
QDate(), forecastEndDate());
if(schedule.count() > 0) {
QValueList<MyMoneySchedule>::Iterator it;
do {
qBubbleSort(schedule);
it = schedule.begin();
if(it == schedule.end())
break;
if((*it).isFinished()) {
schedule.erase(it);
continue;
}
QDate date = (*it).nextPayment((*it).lastPayment());
if(!date.isValid()) {
schedule.remove(it);
continue;
}
QDate nextDate =
(*it).adjustedNextPayment((*it).adjustedDate((*it).lastPayment(),
(*it).weekendOption()));
if (nextDate > forecastEndDate()) {
// We're done with this schedule, let's move on to the next
schedule.remove(it);
continue;
}
// found the next schedule. process it
MyMoneyAccount acc = (*it).account();
if(!acc.id().isEmpty()) {
try {
if(acc.accountType() != MyMoneyAccount::Investment) {
MyMoneyTransaction t = (*it).transaction();
// only process the entry, if it is still active
if(!(*it).isFinished() && nextDate != QDate()) {
// make sure we have all 'starting balances' so that the autocalc works
QValueList<MyMoneySplit>::const_iterator it_s;
QMap<QString, MyMoneyMoney> balanceMap;
for(it_s = t.splits().begin(); it_s != t.splits().end(); ++it_s ) {
MyMoneyAccount acc = file->account((*it_s).accountId());
if(isForecastAccount(acc)) {
// collect all overdues on the first day
QDate forecastDate = nextDate;
if(QDate::currentDate() >= nextDate)
forecastDate = QDate::currentDate().addDays(1);
dailyBalances balance;
balance = m_accountList[acc.id()];
for(QDate f_day = QDate::currentDate(); f_day < forecastDate; ) {
balanceMap[acc.id()] += m_accountList[acc.id()][f_day];
f_day = f_day.addDays(1);
}
}
}
// take care of the autoCalc stuff
calculateAutoLoan(*it, t, balanceMap);
// now add the splits to the balances
for(it_s = t.splits().begin(); it_s != t.splits().end(); ++it_s ) {
MyMoneyAccount acc = file->account((*it_s).accountId());
if(isForecastAccount(acc)) {
dailyBalances balance;
balance = m_accountList[acc.id()];
//int offset = QDate::currentDate().daysTo(nextDate);
//if(offset <= 0) { // collect all overdues on the first day
// offset = 1;
//}
// collect all overdues on the first day
QDate forecastDate = nextDate;
if(QDate::currentDate() >= nextDate)
forecastDate = QDate::currentDate().addDays(1);
if(acc.accountType() == MyMoneyAccount::Income) {
balance[forecastDate] += ((*it_s).shares() * MyMoneyMoney(-1, 1));
} else {
balance[forecastDate] += (*it_s).shares();
}
m_accountList[acc.id()] = balance;
}
}
}
}
(*it).setLastPayment(date);
} catch(MyMoneyException* e) {
kdDebug(2) << __func__ << " Schedule " << (*it).id() << " (" << (*it).name() << "): " << e->what() << endl;
schedule.remove(it);
delete e;
}
} else {
// remove schedule from list
schedule.remove(it);
}
}
while(1);
}
#if 0
{
s << "\n\nAdded scheduled transactions\n";
QMap<QString, dailyBalances>::Iterator it_a;
QMap<QString, QString>::ConstIterator it_n;
for(it_n = m_nameIdx.begin(); it_n != m_nameIdx.end(); ++it_n) {
MyMoneyAccount acc = file->account(*it_n);
it_a = m_accountList.find(*it_n);
s << "\"" << acc.name() << "\",";
for(int i = 0; i < 90; ++i) {
s << "\"" << (*it_a)[i].formatMoney("") << "\",";
}
s << "\n";
}
}
#endif
}
bool MyMoneyTemplate::setFlags(MyMoneyAccount& acc, QDomNode flags)
{
bool rc = true;
while (rc == true && !flags.isNull()) {
if (flags.isElement()) {
QDomElement flagElement = flags.toElement();
if (flagElement.tagName() == "flag") {
// make sure, we only store flags we know!
QString value = flagElement.attribute("name");
if (value == "Tax") {
acc.setValue(value.toLatin1(), "Yes");
} else {
KMessageBox::error(KMyMoneyUtils::mainWindow(), i18n("<p>Invalid flag type <b>%1</b> for account <b>%3</b> in template file <b>%2</b></p>", flagElement.attribute("name"), m_source.prettyUrl(), acc.name()));
rc = false;
}
}
}
flags = flags.nextSibling();
}
return rc;
}