void KInstitutionsView::loadSubAccounts(KMyMoneyAccountTreeItem* parent)
{
bool showClosedAccounts = kmymoney2->toggleAction("view_show_all_accounts")->isChecked()
|| !KMyMoneyGlobalSettings::hideClosedAccounts();
const MyMoneyAccount& account = dynamic_cast<const MyMoneyAccount&>(parent->itemObject());
QValueList<QString>::const_iterator it_a;
MyMoneyFile* file = MyMoneyFile::instance();
for(it_a = account.accountList().begin(); it_a != account.accountList().end(); ++it_a) {
MyMoneyAccount acc = m_accountMap[(*it_a)];
if(!acc.isInvest())
continue;
if(acc.isClosed() && !showClosedAccounts)
continue;
const MyMoneySecurity& security = m_securityMap[acc.currencyId()];
QValueList<MyMoneyPrice> prices;
prices += file->price(acc.currencyId(), security.tradingCurrency());
if(security.tradingCurrency() != file->baseCurrency().id()) {
MyMoneySecurity sec = m_securityMap[security.tradingCurrency()];
prices += file->price(sec.id(), file->baseCurrency().id());
}
KMyMoneyAccountTreeItem* item = new KMyMoneyAccountTreeItem(parent, acc, prices, security);
if(acc.id() == m_reconciliationAccount.id())
item->setReconciliation(true);
}
}
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 KForecastView::updateSummary(QTreeWidgetItem *item)
{
MyMoneyMoney amountMM;
int it_c = 1; // iterator for the columns of the listview
MyMoneyFile* file = MyMoneyFile::instance();
int daysToBeginDay;
MyMoneyForecast forecast = item->data(0, ForecastRole).value<MyMoneyForecast>();
if (QDate::currentDate() < forecast.beginForecastDate()) {
daysToBeginDay = QDate::currentDate().daysTo(forecast.beginForecastDate());
} else {
daysToBeginDay = forecast.accountsCycle();
}
MyMoneyAccount account = item->data(0, AccountRole).value<MyMoneyAccount>();
MyMoneySecurity currency;
if (account.isInvest()) {
MyMoneySecurity underSecurity = file->security(account.currencyId());
currency = file->security(underSecurity.tradingCurrency());
} else {
currency = file->security(account.currencyId());
}
//add current balance column
QDate summaryDate = QDate::currentDate();
amountMM = forecast.forecastBalance(account, summaryDate);
//calculate the balance in base currency for the total row
setAmount(item, it_c, amountMM);
setValue(item, it_c, amountMM, summaryDate);
showAmount(item, it_c, amountMM, currency);
it_c++;
//iterate through all other columns
for (QDate summaryDate = QDate::currentDate().addDays(daysToBeginDay); summaryDate <= forecast.forecastEndDate(); summaryDate = summaryDate.addDays(forecast.accountsCycle()), ++it_c) {
amountMM = forecast.forecastBalance(account, summaryDate);
//calculate the balance in base currency for the total row
setAmount(item, it_c, amountMM);
setValue(item, it_c, amountMM, summaryDate);
showAmount(item, it_c, amountMM, currency);
}
//calculate and add variation per cycle
setNegative(item, forecast.accountTotalVariation(account).isNegative());
setAmount(item, it_c, forecast.accountTotalVariation(account));
setValue(item, it_c, forecast.accountTotalVariation(account), forecast.forecastEndDate());
showAmount(item, it_c, forecast.accountTotalVariation(account), currency);
}
QString makeAccount( const QString& _name, MyMoneyAccount::accountTypeE _type, MyMoneyMoney _balance, const QDate& _open, const QString& _parent, QString _currency, bool _taxReport )
{
MyMoneyAccount info;
MyMoneyFileTransaction ft;
info.setName(_name);
info.setAccountType(_type);
info.setOpeningDate(_open);
if ( _currency != "" )
info.setCurrencyId(_currency);
else
info.setCurrencyId(MyMoneyFile::instance()->baseCurrency().id());
if(_taxReport)
info.setValue("Tax", "Yes");
MyMoneyAccount parent = MyMoneyFile::instance()->account(_parent);
MyMoneyFile::instance()->addAccount( info, parent );
// create the opening balance transaction if any
if(!_balance.isZero()) {
MyMoneySecurity sec = MyMoneyFile::instance()->currency(info.currencyId());
MyMoneyFile::instance()->openingBalanceAccount(sec);
MyMoneyFile::instance()->createOpeningBalanceTransaction(info, _balance);
}
ft.commit();
return info.id();
}
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::updateBudget(QTreeWidgetItem *item)
{
MyMoneySecurity currency;
MyMoneyMoney tAmountMM;
MyMoneyForecast forecast = item->data(0, ForecastRole).value<MyMoneyForecast>();
MyMoneyFile* file = MyMoneyFile::instance();
int it_c = 1; // iterator for the columns of the listview
QDate forecastDate = forecast.forecastStartDate();
MyMoneyAccount account = item->data(0, AccountRole).value<MyMoneyAccount>();
if (account.isInvest()) {
MyMoneySecurity underSecurity = file->security(account.currencyId());
currency = file->security(underSecurity.tradingCurrency());
} else {
currency = file->security(account.currencyId());
}
//iterate columns
for (; forecastDate <= forecast.forecastEndDate(); forecastDate = forecastDate.addMonths(1), ++it_c) {
MyMoneyMoney amountMM;
amountMM = forecast.forecastBalance(account, forecastDate);
if (account.accountType() == MyMoneyAccount::Expense)
amountMM = -amountMM;
tAmountMM += amountMM;
setAmount(item, it_c, amountMM);
setValue(item, it_c, amountMM, forecastDate);
showAmount(item, it_c, amountMM, currency);
}
//set total column
setAmount(item, it_c, tAmountMM);
setValue(item, it_c, tAmountMM, forecast.forecastEndDate());
showAmount(item, it_c, tAmountMM, currency);
}
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;
}
void KForecastView::updateDetailed(QTreeWidgetItem *item)
{
QString amount;
QString vAmount;
MyMoneyMoney vAmountMM;
MyMoneyFile* file = MyMoneyFile::instance();
MyMoneyAccount account = item->data(0, AccountRole).value<MyMoneyAccount>();
MyMoneySecurity currency;
if (account.isInvest()) {
MyMoneySecurity underSecurity = file->security(account.currencyId());
currency = file->security(underSecurity.tradingCurrency());
} else {
currency = file->security(account.currencyId());
}
int it_c = 1; // iterator for the columns of the listview
MyMoneyForecast forecast = item->data(0, ForecastRole).value<MyMoneyForecast>();
for (QDate forecastDate = QDate::currentDate(); forecastDate <= forecast.forecastEndDate(); ++it_c, forecastDate = forecastDate.addDays(1)) {
MyMoneyMoney amountMM = forecast.forecastBalance(account, forecastDate);
//calculate the balance in base currency for the total row
setAmount(item, it_c, amountMM);
setValue(item, it_c, amountMM, forecastDate);
showAmount(item, it_c, amountMM, currency);
}
//calculate and add variation per cycle
vAmountMM = forecast.accountTotalVariation(account);
setAmount(item, it_c, vAmountMM);
setValue(item, it_c, vAmountMM, forecast.forecastEndDate());
showAmount(item, it_c, vAmountMM, currency);
}
void KForecastView::setValue(QTreeWidgetItem* item, int column, const MyMoneyMoney& amount, const QDate& forecastDate)
{
MyMoneyAccount account = item->data(0, AccountRole).value<MyMoneyAccount>();
//calculate the balance in base currency for the total row
if (account.currencyId() != MyMoneyFile::instance()->baseCurrency().id()) {
ReportAccount repAcc = ReportAccount(account.id());
MyMoneyMoney curPrice = repAcc.baseCurrencyPrice(forecastDate);
MyMoneyMoney baseAmountMM = amount * curPrice;
MyMoneyMoney value = baseAmountMM.convert(MyMoneyFile::instance()->baseCurrency().smallestAccountFraction());
item->setData(column, ValueRole, QVariant::fromValue(value));
adjustParentValue(item->parent(), column, value);
} else {
item->setData(column, ValueRole, QVariant::fromValue(item->data(column, ValueRole).value<MyMoneyMoney>() + amount));
adjustParentValue(item->parent(), column, amount);
}
}
void MyMoneyForecast::doFutureScheduledForecast(void)
{
MyMoneyFile* file = MyMoneyFile::instance();
if(isIncludingFutureTransactions())
addFutureTransactions();
if(isIncludingScheduledTransactions())
addScheduledTransactions();
//do not show accounts with no transactions
if(!isIncludingUnusedAccounts())
purgeForecastAccountsList(m_accountList);
//adjust value of investments to deep currency
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 );
if ( acc.isInvest() ) {
//get the id of the security for that account
MyMoneySecurity undersecurity = file->security ( acc.currencyId() );
//only do it if the security is not an actual currency
if ( ! undersecurity.isCurrency() )
{
//set the default value
MyMoneyMoney rate = MyMoneyMoney ( 1, 1 );
MyMoneyPrice price;
for (QDate it_day = QDate::currentDate(); it_day <= forecastEndDate(); ) {
//get the price for the tradingCurrency that day
price = file->price ( undersecurity.id(), undersecurity.tradingCurrency(), it_day );
if ( price.isValid() )
{
rate = price.rate ( undersecurity.tradingCurrency() );
}
//value is the amount of shares multiplied by the rate of the deep currency
m_accountList[acc.id() ][it_day] = m_accountList[acc.id() ][it_day] * rate;
it_day = it_day.addDays(1);
}
}
}
}
}
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 &) {
}
}
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 CsvUtil::scanCategories(QString& id, const MyMoneyAccount& invAcc, const MyMoneyAccount& parentAccount, const QString& defaultName)
{
if (!m_scannedCategories) {
previouslyUsedCategories(invAcc.id(), m_feeId, m_interestId);
m_scannedCategories = true;
}
if (id.isEmpty()) {
MyMoneyFile* file = MyMoneyFile::instance();
MyMoneyAccount acc = file->accountByName(defaultName);
// if it does not exist, we have to create it
if (acc.id().isEmpty()) {
MyMoneyAccount parent = parentAccount;
acc.setName(defaultName);
acc.setAccountType(parent.accountType());
acc.setCurrencyId(parent.currencyId());
file->addAccount(acc, parent);
}
id = acc.id();
}
}
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;
}
void InvTransactionHelper::init( const QDate& _date, const QString& _action, MyMoneyMoney _shares, MyMoneyMoney _price, const QString& _stockaccountid, const QString& _transferid, const QString& _categoryid )
{
MyMoneyFile* file = MyMoneyFile::instance();
MyMoneyAccount stockaccount = file->account(_stockaccountid);
MyMoneyMoney value = _shares * _price;
setPostDate(_date);
setCommodity("USD");
MyMoneySplit s1;
s1.setValue(value);
s1.setAccountId(_stockaccountid);
if ( _action == MyMoneySplit::ActionReinvestDividend )
{
s1.setShares(_shares);
s1.setAction(MyMoneySplit::ActionReinvestDividend);
MyMoneySplit s2;
s2.setAccountId(_categoryid);
s2.setShares(-value);
s2.setValue(-value);
addSplit(s2);
}
else if ( _action == MyMoneySplit::ActionDividend || _action == MyMoneySplit::ActionYield )
{
s1.setAccountId(_categoryid);
s1.setShares(-value);
s1.setValue(-value);
// Split 2 will be the zero-amount investment split that serves to
// mark this transaction as a cash dividend and note which stock account
// it belongs to.
MyMoneySplit s2;
s2.setValue(0);
s2.setShares(0);
s2.setAction(_action);
s2.setAccountId(_stockaccountid);
addSplit(s2);
MyMoneySplit s3;
s3.setAccountId(_transferid);
s3.setShares(value);
s3.setValue(value);
addSplit(s3);
}
else if ( _action == MyMoneySplit::ActionBuyShares )
{
s1.setShares(_shares);
s1.setAction(MyMoneySplit::ActionBuyShares);
MyMoneySplit s3;
s3.setAccountId(_transferid);
s3.setShares(-value);
s3.setValue(-value);
addSplit(s3);
}
addSplit(s1);
//kdDebug(2) << "created transaction, now adding..." << endl;
MyMoneyFileTransaction ft;
file->addTransaction(*this);
//kdDebug(2) << "updating price..." << endl;
// update the price, while we're here
QString stockid = stockaccount.currencyId();
QString basecurrencyid = file->baseCurrency().id();
MyMoneyPrice price = file->price( stockid, basecurrencyid, _date, true );
if ( !price.isValid() )
{
MyMoneyPrice newprice( stockid, basecurrencyid, _date, _price, "test" );
file->addPrice(newprice);
}
ft.commit();
//kdDebug(2) << "successfully added " << id() << endl;
}
void MyMoneyForecast::setStartingBalance(const MyMoneyAccount &acc)
{
MyMoneyFile* file = MyMoneyFile::instance();
//Get current account balance
if ( acc.isInvest() ) { //investments require special treatment
//get the security id of that account
MyMoneySecurity undersecurity = file->security ( acc.currencyId() );
//only do it if the security is not an actual currency
if ( ! undersecurity.isCurrency() )
{
//set the default value
MyMoneyMoney rate = MyMoneyMoney ( 1, 1 );
//get te
MyMoneyPrice price = file->price ( undersecurity.id(), undersecurity.tradingCurrency(), QDate::currentDate() );
if ( price.isValid() )
{
rate = price.rate ( undersecurity.tradingCurrency() );
}
m_accountList[acc.id()][QDate::currentDate()] = file->balance(acc.id(), QDate::currentDate()) * rate;
}
} else {
m_accountList[acc.id()][QDate::currentDate()] = file->balance(acc.id(), QDate::currentDate());
}
//if the method is linear regression, we have to add the opening balance to m_accountListPast
if(forecastMethod() == eHistoric && historyMethod() == 2) {
//FIXME workaround for stock opening dates
QDate openingDate;
if(acc.accountType() == MyMoneyAccount::Stock) {
MyMoneyAccount parentAccount = file->account(acc.parentAccountId());
openingDate = parentAccount.openingDate();
} else {
openingDate = acc.openingDate();
}
//add opening balance only if it opened after the history start
if(openingDate >= historyStartDate()) {
MyMoneyMoney openingBalance;
openingBalance = file->balance(acc.id(), openingDate);
//calculate running sum
for(QDate it_date = openingDate; it_date <= historyEndDate(); it_date = it_date.addDays(1) ) {
//investments require special treatment
if ( acc.isInvest() ) {
//get the security id of that account
MyMoneySecurity undersecurity = file->security ( acc.currencyId() );
//only do it if the security is not an actual currency
if ( ! undersecurity.isCurrency() )
{
//set the default value
MyMoneyMoney rate = MyMoneyMoney ( 1, 1 );
//get the rate for that specific date
MyMoneyPrice price = file->price ( undersecurity.id(), undersecurity.tradingCurrency(), it_date );
if ( price.isValid() )
{
rate = price.rate ( undersecurity.tradingCurrency() );
}
m_accountListPast[acc.id()][it_date] += openingBalance * rate;
}
} else {
m_accountListPast[acc.id()][it_date] += openingBalance;
}
}
}
}
}
void MyMoneyForecast::pastTransactions()
{
MyMoneyFile* file = MyMoneyFile::instance();
MyMoneyTransactionFilter filter;
filter.setDateFilter(historyStartDate(), historyEndDate());
filter.setReportAllSplits(false);
QValueList<MyMoneyTransaction> transactions = file->transactionList(filter);
QValueList<MyMoneyTransaction>::const_iterator it_t = transactions.begin();
//Check past transactions
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());
//workaround for stock accounts which have faulty opening dates
QDate openingDate;
if(acc.accountType() == MyMoneyAccount::Stock) {
MyMoneyAccount parentAccount = file->account(acc.parentAccountId());
openingDate = parentAccount.openingDate();
} else {
openingDate = acc.openingDate();
}
if(isForecastAccount(acc) //If it is one of the accounts we are checking, add the amount of the transaction
&& ( (openingDate < (*it_t).postDate() && skipOpeningDate())
|| !skipOpeningDate() ) ){ //don't take the opening day of the account to calculate balance
dailyBalances balance;
//FIXME deal with leap years
balance = m_accountListPast[acc.id()];
if(acc.accountType() == MyMoneyAccount::Income) {//if it is income, the balance is stored as negative number
balance[(*it_t).postDate()] += ((*it_s).shares() * MyMoneyMoney(-1, 1));
} else {
balance[(*it_t).postDate()] += (*it_s).shares();
}
// check if this is a new account for us
m_accountListPast[acc.id()] = balance;
}
}
}
}
//purge those accounts with no transactions on the period
if(isIncludingUnusedAccounts() == false)
purgeForecastAccountsList(m_accountListPast);
//calculate running sum
QMap<QString, QString>::Iterator it_n;
for(it_n = m_nameIdx.begin(); it_n != m_nameIdx.end(); ++it_n) {
MyMoneyAccount acc = file->account(*it_n);
m_accountListPast[acc.id()][historyStartDate().addDays(-1)] = file->balance(acc.id(), historyStartDate().addDays(-1));
for(QDate it_date = historyStartDate(); it_date <= historyEndDate(); ) {
m_accountListPast[acc.id()][it_date] += m_accountListPast[acc.id()][it_date.addDays(-1)]; //Running sum
it_date = it_date.addDays(1);
}
}
//adjust value of investments to deep currency
for ( it_n = m_nameIdx.begin(); it_n != m_nameIdx.end(); ++it_n ) {
MyMoneyAccount acc = file->account ( *it_n );
if ( acc.isInvest() ) {
//get the id of the security for that account
MyMoneySecurity undersecurity = file->security ( acc.currencyId() );
if ( ! undersecurity.isCurrency() ) //only do it if the security is not an actual currency
{
MyMoneyMoney rate = MyMoneyMoney ( 1, 1 ); //set the default value
MyMoneyPrice price;
for ( QDate it_date = historyStartDate().addDays(-1) ; it_date <= historyEndDate();) {
//get the price for the tradingCurrency that day
price = file->price ( undersecurity.id(), undersecurity.tradingCurrency(), it_date );
if ( price.isValid() )
{
rate = price.rate ( undersecurity.tradingCurrency() );
}
//value is the amount of shares multiplied by the rate of the deep currency
m_accountListPast[acc.id() ][it_date] = m_accountListPast[acc.id() ][it_date] * rate;
it_date = it_date.addDays(1);
}
}
}
}
}
KEndingBalanceDlg::KEndingBalanceDlg(const MyMoneyAccount& account, QWidget *parent) :
KEndingBalanceDlgDecl(parent),
d(new Private(Page_InterestChargeCheckings + 1))
{
setModal(true);
QString value;
MyMoneyMoney endBalance, startBalance;
d->m_account = account;
MyMoneySecurity currency = MyMoneyFile::instance()->security(account.currencyId());
//FIXME: port
m_statementInfoPageCheckings->m_enterInformationLabel->setText(QString("<qt>") + i18n("Please enter the following fields with the information as you find them on your statement. Make sure to enter all values in <b>%1</b>.", currency.name()) + QString("</qt>"));
// If the previous reconciliation was postponed,
// we show a different first page
value = account.value("lastReconciledBalance");
if (value.isEmpty()) {
// if the last statement has been entered long enough ago (more than one month),
// then take the last statement date and add one month and use that as statement
// date.
QDate lastStatementDate = account.lastReconciliationDate();
if (lastStatementDate.addMonths(1) < QDate::currentDate()) {
setField("statementDate", lastStatementDate.addMonths(1));
}
slotUpdateBalances();
d->m_pages.clearBit(Page_PreviousPostpone);
} else {
d->m_pages.clearBit(Page_CheckingStart);
d->m_pages.clearBit(Page_InterestChargeCheckings);
//removePage(m_interestChargeCheckings);
// make sure, we show the correct start page
setStartId(Page_PreviousPostpone);
MyMoneyMoney factor(1, 1);
if (d->m_account.accountGroup() == MyMoneyAccount::Liability)
factor = -factor;
startBalance = MyMoneyMoney(value) * factor;
value = account.value("statementBalance");
endBalance = MyMoneyMoney(value) * factor;
//FIXME: port
m_statementInfoPageCheckings->m_previousBalance->setValue(startBalance);
m_statementInfoPageCheckings->m_endingBalance->setValue(endBalance);
}
// We don't need to add the default into the list (see ::help() why)
// m_helpAnchor[m_startPageCheckings] = QString("");
d->m_helpAnchor[m_interestChargeCheckings] = QString("details.reconcile.wizard.interest");
d->m_helpAnchor[m_statementInfoPageCheckings] = QString("details.reconcile.wizard.statement");
value = account.value("statementDate");
if (!value.isEmpty())
setField("statementDate", QDate::fromString(value, Qt::ISODate));
//FIXME: port
m_statementInfoPageCheckings->m_lastStatementDate->setText(QString());
if (account.lastReconciliationDate().isValid()) {
m_statementInfoPageCheckings->m_lastStatementDate->setText(i18n("Last reconciled statement: %1", QLocale().toString(account.lastReconciliationDate())));
}
// connect the signals with the slots
connect(MyMoneyFile::instance(), SIGNAL(dataChanged()), this, SLOT(slotReloadEditWidgets()));
connect(m_statementInfoPageCheckings->m_statementDate, SIGNAL(dateChanged(QDate)), this, SLOT(slotUpdateBalances()));
connect(m_interestChargeCheckings->m_interestCategoryEdit, SIGNAL(createItem(QString,QString&)), this, SLOT(slotCreateInterestCategory(QString,QString&)));
connect(m_interestChargeCheckings->m_chargesCategoryEdit, SIGNAL(createItem(QString,QString&)), this, SLOT(slotCreateChargesCategory(QString,QString&)));
connect(m_interestChargeCheckings->m_payeeEdit, SIGNAL(createItem(QString,QString&)), this, SIGNAL(createPayee(QString,QString&)));
KMyMoneyMVCCombo::setSubstringSearchForChildren(m_interestChargeCheckings, !KMyMoneySettings::stringMatchFromStart());
slotReloadEditWidgets();
// preset payee if possible
try {
// if we find a payee with the same name as the institution,
// than this is what we use as payee.
if (!d->m_account.institutionId().isEmpty()) {
MyMoneyInstitution inst = MyMoneyFile::instance()->institution(d->m_account.institutionId());
MyMoneyPayee payee = MyMoneyFile::instance()->payeeByName(inst.name());
setField("payeeEdit", payee.id());
}
} catch (const MyMoneyException &) {
}
KMyMoneyUtils::updateWizardButtons(this);
// setup different text and icon on finish button
setButtonText(QWizard::FinishButton, KStandardGuiItem::cont().text());
button(QWizard::FinishButton)->setIcon(KStandardGuiItem::cont().icon());
}
void KTagsView::showTransactions()
{
MyMoneyMoney balance;
MyMoneyFile *file = MyMoneyFile::instance();
MyMoneySecurity base = file->baseCurrency();
// setup sort order
m_register->setSortOrder(KMyMoneyGlobalSettings::sortSearchView());
// clear the register
m_register->clear();
if (m_tag.id().isEmpty() || !m_tabWidget->isEnabled()) {
m_balanceLabel->setText(i18n("Balance: %1", balance.formatMoney(file->baseCurrency().smallestAccountFraction())));
return;
}
// setup the list and the pointer vector
MyMoneyTransactionFilter filter;
filter.addTag(m_tag.id());
filter.setDateFilter(KMyMoneyGlobalSettings::startDate().date(), QDate());
// retrieve the list from the engine
file->transactionList(m_transactionList, filter);
// create the elements for the register
QList<QPair<MyMoneyTransaction, MyMoneySplit> >::const_iterator it;
QMap<QString, int> uniqueMap;
MyMoneyMoney deposit, payment;
int splitCount = 0;
bool balanceAccurate = true;
for (it = m_transactionList.constBegin(); it != m_transactionList.constEnd(); ++it) {
const MyMoneySplit& split = (*it).second;
MyMoneyAccount acc = file->account(split.accountId());
++splitCount;
uniqueMap[(*it).first.id()]++;
KMyMoneyRegister::Register::transactionFactory(m_register, (*it).first, (*it).second, uniqueMap[(*it).first.id()]);
// take care of foreign currencies
MyMoneyMoney val = split.shares().abs();
if (acc.currencyId() != base.id()) {
const MyMoneyPrice &price = file->price(acc.currencyId(), base.id());
// in case the price is valid, we use it. Otherwise, we keep
// a flag that tells us that the balance is somewhat inaccurate
if (price.isValid()) {
val *= price.rate(base.id());
} else {
balanceAccurate = false;
}
}
if (split.shares().isNegative()) {
payment += val;
} else {
deposit += val;
}
}
balance = deposit - payment;
// add the group markers
m_register->addGroupMarkers();
// sort the transactions according to the sort setting
m_register->sortItems();
// remove trailing and adjacent markers
m_register->removeUnwantedGroupMarkers();
m_register->updateRegister(true);
// we might end up here with updates disabled on the register so
// make sure that we enable updates here
m_register->setUpdatesEnabled(true);
m_balanceLabel->setText(i18n("Balance: %1%2",
balanceAccurate ? "" : "~",
balance.formatMoney(file->baseCurrency().smallestAccountFraction())));
}
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 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()));
}
}
