You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
kmymoney/kmymoney2/mymoney/mymoneyscheduled.cpp

1373 lines
40 KiB

/***************************************************************************
mymoneyscheduled.cpp
-------------------
copyright : (C) 2000-2002 by Michael Edwardes
(C) 2007 by Thomas Baumgart
email : mte@users.sourceforge.net
Thomas Baumgart <ipwizard@users.sourceforge.net>
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
// ----------------------------------------------------------------------------
// QT Includes
// ----------------------------------------------------------------------------
// KDE Includes
#include <klocale.h>
// ----------------------------------------------------------------------------
// Project Includes
#include "mymoneyscheduled.h"
#include "mymoneyexception.h"
#include "mymoneyfile.h"
MyMoneySchedule::MyMoneySchedule() :
MyMoneyObject()
{
// Set up the default values
m_occurence = OCCUR_ANY;
m_occurenceMultiplier = 1;
m_type = TYPE_ANY;
m_paymentType = STYPE_ANY;
m_fixed = false;
m_autoEnter = false;
m_startDate = TQDate();
m_endDate = TQDate();
m_lastPayment = TQDate();
m_weekendOption = MoveNothing;
}
MyMoneySchedule::MyMoneySchedule(const TQString& name, typeE type,
occurenceE occurence, int occurenceMultiplier,
paymentTypeE paymentType,
const TQDate& /* startDate */,
const TQDate& endDate,
bool fixed, bool autoEnter) :
MyMoneyObject()
{
// Set up the default values
m_name = name;
m_occurence = occurence;
m_occurenceMultiplier = occurenceMultiplier;
simpleToCompoundOccurence(m_occurenceMultiplier,m_occurence);
m_type = type;
m_paymentType = paymentType;
m_fixed = fixed;
m_autoEnter = autoEnter;
m_startDate = TQDate();
m_endDate = endDate;
m_lastPayment = TQDate();
m_weekendOption = MoveNothing;
}
MyMoneySchedule::MyMoneySchedule(const TQDomElement& node) :
MyMoneyObject(node)
{
if("SCHEDULED_TX" != node.tagName())
throw new MYMONEYEXCEPTION("Node was not SCHEDULED_TX");
m_name = node.attribute("name");
m_startDate = stringToDate(node.attribute("startDate"));
m_endDate = stringToDate(node.attribute("endDate"));
m_lastPayment = stringToDate(node.attribute("lastPayment"));
m_type = static_cast<MyMoneySchedule::typeE>(node.attribute("type").toInt());
m_paymentType = static_cast<MyMoneySchedule::paymentTypeE>(node.attribute("paymentType").toInt());
m_occurence = static_cast<MyMoneySchedule::occurenceE>(node.attribute("occurence").toInt());
m_occurenceMultiplier = node.attribute("occurenceMultiplier", "1").toInt();
// Convert to compound occurence
simpleToCompoundOccurence(m_occurenceMultiplier,m_occurence);
m_autoEnter = static_cast<bool>(node.attribute("autoEnter").toInt());
m_fixed = static_cast<bool>(node.attribute("fixed").toInt());
m_weekendOption = static_cast<MyMoneySchedule::weekendOptionE>(node.attribute("weekendOption").toInt());
// read in the associated transaction
TQDomNodeList nodeList = node.elementsByTagName("TRANSACTION");
if(nodeList.count() == 0)
throw new MYMONEYEXCEPTION("SCHEDULED_TX has no TRANSACTION node");
setTransaction(MyMoneyTransaction(nodeList.item(0).toElement(), false), true);
// some old versions did not remove the entry date and post date fields
// in the schedule. So if this is the case, we deal with a very old transaction
// and can't use the post date field as next due date. Hence, we wipe it out here
if(m_transaction.entryDate().isValid()) {
m_transaction.setPostDate(TQDate());
m_transaction.setEntryDate(TQDate());
}
// readin the recorded payments
nodeList = node.elementsByTagName("PAYMENTS");
if(nodeList.count() > 0) {
nodeList = nodeList.item(0).toElement().elementsByTagName("PAYMENT");
for(unsigned int i = 0; i < nodeList.count(); ++i) {
m_recordedPayments << stringToDate(nodeList.item(i).toElement().attribute("date"));
}
}
// if the next due date is not set (comes from old version)
// then set it up the old way
if(!nextDueDate().isValid() && !m_lastPayment.isValid()) {
m_transaction.setPostDate(m_startDate);
// clear it, because the schedule has never been used
m_startDate = TQDate();
}
// There are reports that lastPayment and nextDueDate are identical or
// that nextDueDate is older than lastPayment. This could
// be caused by older versions of the application. In this case, we just
// clear out the nextDueDate and let it calculate from the lastPayment.
if(nextDueDate().isValid() && nextDueDate() <= m_lastPayment) {
m_transaction.setPostDate(TQDate());
}
if(!nextDueDate().isValid()) {
m_transaction.setPostDate(m_startDate);
m_transaction.setPostDate(nextPayment(m_lastPayment.addDays(1)));
}
}
MyMoneySchedule::MyMoneySchedule(const TQString& id, const MyMoneySchedule& right) :
MyMoneyObject(id)
{
*this = right;
setId(id);
}
MyMoneySchedule::occurenceE MyMoneySchedule::occurence(void) const
{
MyMoneySchedule::occurenceE occ = m_occurence;
int mult = m_occurenceMultiplier;
compoundToSimpleOccurence(mult, occ);
return occ;
}
void MyMoneySchedule::setStartDate(const TQDate& date)
{
m_startDate = date;
}
void MyMoneySchedule::setPaymentType(paymentTypeE type)
{
m_paymentType = type;
}
void MyMoneySchedule::setFixed(bool fixed)
{
m_fixed = fixed;
}
void MyMoneySchedule::setTransaction(const MyMoneyTransaction& transaction)
{
setTransaction(transaction, false);
}
void MyMoneySchedule::setTransaction(const MyMoneyTransaction& transaction, bool noDateCheck)
{
MyMoneyTransaction t = transaction;
if(!noDateCheck) {
// don't allow a transaction that has no due date
// if we get something like that, then we use the
// the current next due date. If that is also invalid
// we can't help it.
if(!t.postDate().isValid()) {
t.setPostDate(m_transaction.postDate());
}
if(!t.postDate().isValid())
return;
}
// make sure to clear out some unused information in scheduled transactions
// we need to do this for the case that the transaction passed as argument
// is a matched or imported transaction.
TQValueList<MyMoneySplit> splits = t.splits();
if(splits.count() > 0) {
TQValueList<MyMoneySplit>::const_iterator it_s;
for(it_s = splits.begin(); it_s != splits.end(); ++it_s) {
MyMoneySplit s = *it_s;
// clear out the bankID
if(!(*it_s).bankID().isEmpty()) {
s.setBankID(TQString());
t.modifySplit(s);
}
// only clear payees from second split onwards
if(it_s == splits.begin())
continue;
if(!(*it_s).payeeId().isEmpty()) {
// but only if the split references an income/expense category
MyMoneyFile* file = MyMoneyFile::instance();
// some unit tests don't have a storage attached, so we
// simply skip the test
// Don't check for accounts with an id of 'Phony-ID' which is used
// internally for non-existing accounts (during creation of accounts)
if(file->storageAttached() && s.accountId() != TQString("Phony-ID")) {
MyMoneyAccount acc = file->account(s.accountId());
if(acc.isIncomeExpense()) {
s.setPayeeId(TQString());
t.modifySplit(s);
}
}
}
}
}
m_transaction = t;
// make sure that the transaction does not have an id so that we can enter
// it into the engine
m_transaction.clearId();
}
void MyMoneySchedule::setEndDate(const TQDate& date)
{
m_endDate = date;
}
void MyMoneySchedule::setAutoEnter(bool autoenter)
{
m_autoEnter = autoenter;
}
const TQDate& MyMoneySchedule::startDate(void) const
{
if(m_startDate.isValid())
return m_startDate;
return nextDueDate();
}
const TQDate& MyMoneySchedule::nextDueDate(void) const
{
return m_transaction.postDate();
}
TQDate MyMoneySchedule::adjustedNextDueDate(void) const
{
if(isFinished())
return TQDate();
return adjustedDate(nextDueDate(), weekendOption());
}
TQDate MyMoneySchedule::adjustedDate(TQDate date, weekendOptionE option) const
{
if (option == MyMoneySchedule::MoveNothing)
return date;
int step = 1;
if (option == MyMoneySchedule::MoveFriday)
step = -1;
while (date.dayOfWeek() > 5)
date = date.addDays(step);
return date;
}
void MyMoneySchedule::setNextDueDate(const TQDate& date)
{
if(date.isValid()) {
m_transaction.setPostDate(date);
m_startDate = date;
}
}
void MyMoneySchedule::setLastPayment(const TQDate& date)
{
// Delete all payments older than date
TQValueList<TQDate>::Iterator it;
TQValueList<TQDate> delList;
for (it=m_recordedPayments.begin(); it!=m_recordedPayments.end(); ++it)
{
if (*it < date || !date.isValid())
delList.append(*it);
}
for (it=delList.begin(); it!=delList.end(); ++it)
{
m_recordedPayments.remove(*it);
}
m_lastPayment = date;
if(!m_startDate.isValid())
m_startDate = date;
}
void MyMoneySchedule::setName(const TQString& nm)
{
m_name = nm;
}
void MyMoneySchedule::setOccurence(occurenceE occ)
{
MyMoneySchedule::occurenceE occ2 = occ;
int mult = 1;
simpleToCompoundOccurence(mult, occ2);
setOccurencePeriod( occ2 );
setOccurenceMultiplier( mult );
}
void MyMoneySchedule::setOccurencePeriod(occurenceE occ)
{
m_occurence = occ;
}
void MyMoneySchedule::setOccurenceMultiplier(int occmultiplier)
{
m_occurenceMultiplier = occmultiplier < 1 ? 1 : occmultiplier;
}
void MyMoneySchedule::setType(typeE type)
{
m_type = type;
}
void MyMoneySchedule::validate(bool id_check) const
{
/* Check the supplied instance is valid...
*
* To be valid it must not have the id set and have the following fields set:
*
* m_occurence
* m_type
* m_startDate
* m_paymentType
* m_transaction
* the transaction must contain at least one split (two is better ;-) )
*/
if (id_check && !m_id.isEmpty())
throw new MYMONEYEXCEPTION("ID for schedule not empty when required");
if(m_occurence == OCCUR_ANY)
throw new MYMONEYEXCEPTION("Invalid occurence type for schedule");
if(m_type == TYPE_ANY)
throw new MYMONEYEXCEPTION("Invalid type for schedule");
if(!nextDueDate().isValid())
throw new MYMONEYEXCEPTION("Invalid next due date for schedule");
if(m_paymentType == STYPE_ANY)
throw new MYMONEYEXCEPTION("Invalid payment type for schedule");
if(m_transaction.splitCount() == 0)
throw new MYMONEYEXCEPTION("Scheduled transaction does not contain splits");
// Check the payment types
switch (m_type)
{
case TYPE_BILL:
if (m_paymentType == STYPE_DIRECTDEPOSIT || m_paymentType == STYPE_MANUALDEPOSIT)
throw new MYMONEYEXCEPTION("Invalid payment type for bills");
break;
case TYPE_DEPOSIT:
if (m_paymentType == STYPE_DIRECTDEBIT || m_paymentType == STYPE_WRITECHETQUE)
throw new MYMONEYEXCEPTION("Invalid payment type for deposits");
break;
case TYPE_ANY:
throw new MYMONEYEXCEPTION("Invalid type ANY");
break;
case TYPE_TRANSFER:
// if (m_paymentType == STYPE_DIRECTDEPOSIT || m_paymentType == STYPE_MANUALDEPOSIT)
// return false;
break;
case TYPE_LOANPAYMENT:
break;
}
}
TQDate MyMoneySchedule::adjustedNextPayment(const TQDate& refDate) const
{
TQDate date(nextPayment(refDate));
return date.isValid() ? adjustedDate(date, weekendOption()) : date;
}
TQDate MyMoneySchedule::nextPayment(const TQDate& refDate) const
{
// if the enddate is valid and it is before the reference date,
// then there will be no more payments.
if(m_endDate.isValid() && m_endDate < refDate) {
return TQDate();
}
TQDate paymentDate(nextDueDate());
if(refDate >= paymentDate) {
switch (m_occurence)
{
case OCCUR_ONCE:
// if the lastPayment is already set, then there will be no more payments
// otherwise, the start date is the payment date
if(m_lastPayment.isValid())
return TQDate();
// if the only payment should have been prior to the reference date,
// then don't show it
if(paymentDate < refDate)
return TQDate();
break;
case OCCUR_DAILY:
paymentDate = refDate.addDays(m_occurenceMultiplier);
break;
case OCCUR_WEEKLY:
{
int step = 7*m_occurenceMultiplier;
do {
paymentDate = paymentDate.addDays(step);
}
while (paymentDate <= refDate);
}
break;
case OCCUR_EVERYHALFMONTH:
do
{
paymentDate = addHalfMonths(paymentDate,m_occurenceMultiplier);
}
while (paymentDate <= refDate);
break;
case OCCUR_MONTHLY:
do {
paymentDate = paymentDate.addMonths(m_occurenceMultiplier);
fixDate(paymentDate);
}
while (paymentDate <= refDate);
break;
case OCCUR_YEARLY:
do {
paymentDate = paymentDate.addYears(m_occurenceMultiplier);
fixDate(paymentDate);
}
while (paymentDate <= refDate);
break;
case OCCUR_ANY:
default:
paymentDate = TQDate();
break;
}
}
if(paymentDate.isValid()) {
if(m_endDate.isValid() && paymentDate > m_endDate)
paymentDate = TQDate();
}
if (paymentDate.isValid() && m_recordedPayments.contains(paymentDate))
paymentDate = nextPayment(paymentDate);
return paymentDate;
}
TQValueList<TQDate> MyMoneySchedule::paymentDates(const TQDate& _startDate, const TQDate& _endDate) const
{
TQDate paymentDate(nextDueDate());
TQValueList<TQDate> theDates;
TQDate endDate(_endDate);
if ( willEnd() && m_endDate < endDate )
endDate = m_endDate;
weekendOptionE option(weekendOption());
TQDate start_date(adjustedDate(startDate(), option));
// if the period specified by the parameters and the period
// defined for this schedule don't overlap, then the list remains empty
if ((willEnd() && m_endDate < _startDate)
|| start_date > endDate)
return theDates;
TQDate date(adjustedDate(paymentDate, option));
switch (m_occurence)
{
case OCCUR_ONCE:
if (start_date >= _startDate && start_date <= endDate)
theDates.append(start_date);
break;
case OCCUR_DAILY:
while (date.isValid() && (date <= endDate))
{
if (date >= _startDate)
theDates.append(date);
paymentDate = paymentDate.addDays(m_occurenceMultiplier);
date = adjustedDate(paymentDate, option);
}
break;
case OCCUR_WEEKLY:
{
int step = 7*m_occurenceMultiplier;
while (date.isValid() && (date <= endDate))
{
if (date >= _startDate)
theDates.append(date);
paymentDate = paymentDate.addDays(step);
date = adjustedDate(paymentDate, option);
}
}
break;
case OCCUR_EVERYHALFMONTH:
while (date.isValid() && (date <= endDate))
{
if (date >= _startDate)
theDates.append(date);
paymentDate = addHalfMonths(paymentDate,m_occurenceMultiplier);
date = adjustedDate(paymentDate, option);
}
break;
case OCCUR_MONTHLY:
while (date.isValid() && (date <= endDate))
{
if (date >= _startDate)
theDates.append(date);
paymentDate = paymentDate.addMonths(m_occurenceMultiplier);
fixDate(paymentDate);
date = adjustedDate(paymentDate, option);
}
break;
case OCCUR_YEARLY:
while (date.isValid() && (date <= endDate))
{
if (date >= _startDate)
theDates.append(date);
paymentDate = paymentDate.addYears(m_occurenceMultiplier);
fixDate(paymentDate);
date = adjustedDate(paymentDate, option);
}
break;
case OCCUR_ANY:
default:
break;
}
return theDates;
}
bool MyMoneySchedule::operator <(const MyMoneySchedule& right) const
{
return adjustedNextDueDate() < right.adjustedNextDueDate();
}
bool MyMoneySchedule::operator ==(const MyMoneySchedule& right) const
{
if ( MyMoneyObject::operator==(right) &&
m_occurence == right.m_occurence &&
m_occurenceMultiplier == right.m_occurenceMultiplier &&
m_type == right.m_type &&
m_startDate == right.m_startDate &&
m_paymentType == right.m_paymentType &&
m_fixed == right.m_fixed &&
m_transaction == right.m_transaction &&
m_endDate == right.m_endDate &&
m_autoEnter == right.m_autoEnter &&
m_lastPayment == right.m_lastPayment &&
((m_name.length() == 0 && right.m_name.length() == 0) || (m_name == right.m_name)))
return true;
return false;
}
int MyMoneySchedule::transactionsRemaining(void) const
{
int counter=0;
if (m_endDate.isValid())
{
TQValueList<TQDate> dates = paymentDates(m_lastPayment, m_endDate);
// Dont include the last payment so -1
counter = dates.count();
}
return counter;
}
MyMoneyAccount MyMoneySchedule::account(int cnt) const
{
TQValueList<MyMoneySplit> splits = m_transaction.splits();
TQValueList<MyMoneySplit>::ConstIterator it;
MyMoneyFile* file = MyMoneyFile::instance();
MyMoneyAccount acc;
// search the first asset or liability account
for(it = splits.begin(); it != splits.end() && (acc.id().isEmpty() || cnt); ++it) {
try {
acc = file->account((*it).accountId());
if(acc.isAssetLiability())
--cnt;
if(!cnt)
return acc;
} catch(MyMoneyException *e) {
qWarning("Schedule '%s' references unknown account '%s'", id().data(), (*it).accountId().data());
delete e;
return MyMoneyAccount();
}
}
return MyMoneyAccount();
}
TQDate MyMoneySchedule::dateAfter(int transactions) const
{
int counter=1;
TQDate paymentDate(startDate());
if (transactions<=0)
return paymentDate;
switch (m_occurence)
{
case OCCUR_ONCE:
break;
case OCCUR_DAILY:
while (counter++ < transactions)
paymentDate = paymentDate.addDays(m_occurenceMultiplier);
break;
case OCCUR_WEEKLY:
{
int step = 7 * m_occurenceMultiplier;
while (counter++ < transactions)
paymentDate = paymentDate.addDays(step);
}
break;
case OCCUR_EVERYHALFMONTH:
paymentDate = addHalfMonths(paymentDate,m_occurenceMultiplier*(transactions-1));
break;
case OCCUR_MONTHLY:
while (counter++ < transactions)
paymentDate = paymentDate.addMonths(m_occurenceMultiplier);
break;
case OCCUR_YEARLY:
while (counter++ < transactions)
paymentDate = paymentDate.addYears(m_occurenceMultiplier);
break;
case OCCUR_ANY:
default:
break;
}
return paymentDate;
}
bool MyMoneySchedule::isOverdue() const
{
if (isFinished())
return false;
if(adjustedNextDueDate() >= TQDate::currentDate())
return false;
return true;
}
bool MyMoneySchedule::isFinished() const
{
if(!m_lastPayment.isValid())
return false;
if (m_endDate.isValid()) {
if(m_lastPayment >= m_endDate
|| !nextDueDate().isValid()
|| nextDueDate() > m_endDate)
return true;
}
// Check to see if its a once off payment
if (m_occurence == MyMoneySchedule::OCCUR_ONCE)
return true;
return false;
}
bool MyMoneySchedule::hasRecordedPayment(const TQDate& date) const
{
// m_lastPayment should always be > recordedPayments()
if (m_lastPayment.isValid() && m_lastPayment >= date)
return true;
if (m_recordedPayments.contains(date))
return true;
return false;
}
void MyMoneySchedule::recordPayment(const TQDate& date)
{
m_recordedPayments.append(date);
}
void MyMoneySchedule::setWeekendOption(const weekendOptionE option)
{
// make sure only valid values are used. Invalid defaults to MoveNothing.
switch(option) {
case MoveFriday:
case MoveMonday:
m_weekendOption = option;
break;
default:
m_weekendOption = MoveNothing;
break;
}
}
void MyMoneySchedule::fixDate(TQDate& date) const
{
TQDate fixDate(m_startDate);
if(fixDate.isValid()
&& date.day() != fixDate.day()
&& TQDate::isValid(date.year(), date.month(), fixDate.day())) {
date.setYMD(date.year(), date.month(), fixDate.day());
}
}
void MyMoneySchedule::writeXML(TQDomDocument& document, TQDomElement& parent) const
{
TQDomElement el = document.createElement("SCHEDULED_TX");
writeBaseXML(document, el);
el.setAttribute("name", m_name);
el.setAttribute("type", m_type);
el.setAttribute("occurence", m_occurence);
el.setAttribute("occurenceMultiplier", m_occurenceMultiplier);
el.setAttribute("paymentType", m_paymentType);
el.setAttribute("startDate", dateToString(m_startDate));
el.setAttribute("endDate", dateToString(m_endDate));
el.setAttribute("fixed", m_fixed);
el.setAttribute("autoEnter", m_autoEnter);
el.setAttribute("lastPayment", dateToString(m_lastPayment));
el.setAttribute("weekendOption", m_weekendOption);
//store the payment history for this scheduled task.
TQValueList<TQDate> payments = recordedPayments();
TQValueList<TQDate>::ConstIterator it;
TQDomElement paymentsElement = document.createElement("PAYMENTS");
for (it=payments.begin(); it!=payments.end(); ++it) {
TQDomElement paymentEntry = document.createElement("PAYMENT");
paymentEntry.setAttribute("date", dateToString(*it));
paymentsElement.appendChild(paymentEntry);
}
el.appendChild(paymentsElement);
//store the transaction data for this task.
m_transaction.writeXML(document, el);
parent.appendChild(el);
}
bool MyMoneySchedule::hasReferenceTo(const TQString& id) const
{
return m_transaction.hasReferenceTo(id);
}
TQString MyMoneySchedule::occurenceToString() const
{
return occurenceToString( occurenceMultiplier(), occurencePeriod() );
}
TQString MyMoneySchedule::occurenceToString(occurenceE occurence)
{
TQString occurenceString = I18N_NOOP("Any");
if(occurence == MyMoneySchedule::OCCUR_ONCE)
occurenceString = I18N_NOOP("Once");
else if(occurence == MyMoneySchedule::OCCUR_DAILY)
occurenceString = I18N_NOOP("Daily");
else if(occurence == MyMoneySchedule::OCCUR_WEEKLY)
occurenceString = I18N_NOOP("Weekly");
else if(occurence == MyMoneySchedule::OCCUR_FORTNIGHTLY)
occurenceString = I18N_NOOP("Fortnightly");
else if(occurence == MyMoneySchedule::OCCUR_EVERYOTHERWEEK)
occurenceString = I18N_NOOP("Every other week");
else if(occurence == MyMoneySchedule::OCCUR_EVERYHALFMONTH)
occurenceString = I18N_NOOP("Every half month");
else if(occurence == MyMoneySchedule::OCCUR_EVERYTHREEWEEKS)
occurenceString = I18N_NOOP("Every three weeks");
else if(occurence == MyMoneySchedule::OCCUR_EVERYFOURWEEKS)
occurenceString = I18N_NOOP("Every four weeks");
else if(occurence == MyMoneySchedule::OCCUR_EVERYTHIRTYDAYS)
occurenceString = I18N_NOOP("Every thirty days");
else if(occurence == MyMoneySchedule::OCCUR_MONTHLY)
occurenceString = I18N_NOOP("Monthly");
else if(occurence == MyMoneySchedule::OCCUR_EVERYEIGHTWEEKS)
occurenceString = I18N_NOOP("Every eight weeks");
else if(occurence == MyMoneySchedule::OCCUR_EVERYOTHERMONTH)
occurenceString = I18N_NOOP("Every two months");
else if(occurence == MyMoneySchedule::OCCUR_EVERYTHREEMONTHS)
occurenceString = I18N_NOOP("Every three months");
else if(occurence == MyMoneySchedule::OCCUR_TQUARTERLY)
occurenceString = I18N_NOOP("Quarterly");
else if(occurence == MyMoneySchedule::OCCUR_EVERYFOURMONTHS)
occurenceString = I18N_NOOP("Every four months");
else if(occurence == MyMoneySchedule::OCCUR_TWICEYEARLY)
occurenceString = I18N_NOOP("Twice yearly");
else if(occurence == MyMoneySchedule::OCCUR_YEARLY)
occurenceString = I18N_NOOP("Yearly");
else if(occurence == MyMoneySchedule::OCCUR_EVERYOTHERYEAR)
occurenceString = I18N_NOOP("Every other year");
return occurenceString;
}
TQString MyMoneySchedule::occurenceToString(int mult, occurenceE type)
{
TQString occurenceString = I18N_NOOP("Any");
if (type == MyMoneySchedule::OCCUR_ONCE)
switch (mult)
{
case 1: occurenceString = I18N_NOOP("Once"); break;
default: occurenceString = I18N_NOOP(static_cast<TQString>("%1 times").arg(mult));
}
else if(type == MyMoneySchedule::OCCUR_DAILY)
switch (mult)
{
case 1: occurenceString = I18N_NOOP("Daily"); break;
case 30: occurenceString = I18N_NOOP("Every thirty days"); break;
default: occurenceString = I18N_NOOP(static_cast<TQString>("Every %1 days").arg(mult));
}
else if(type == MyMoneySchedule::OCCUR_WEEKLY)
switch (mult)
{
case 1: occurenceString = I18N_NOOP("Weekly"); break;
case 2: occurenceString = I18N_NOOP("Every other week"); break;
case 3: occurenceString = I18N_NOOP("Every three weeks"); break;
case 4: occurenceString = I18N_NOOP("Every four weeks"); break;
case 8: occurenceString = I18N_NOOP("Every eight weeks"); break;
default: occurenceString = I18N_NOOP(static_cast<TQString>("Every %1 weeks").arg(mult));
}
else if(type == MyMoneySchedule::OCCUR_EVERYHALFMONTH)
switch (mult)
{
case 1: occurenceString = I18N_NOOP("Every half month"); break;
default: occurenceString = I18N_NOOP(static_cast<TQString>("Every %1 half months").arg(mult));
}
else if(type == MyMoneySchedule::OCCUR_MONTHLY)
switch (mult)
{
case 1: occurenceString = I18N_NOOP("Monthly"); break;
case 2: occurenceString = I18N_NOOP("Every two months"); break;
case 3: occurenceString = I18N_NOOP("Every three months"); break;
case 4: occurenceString = I18N_NOOP("Every four months"); break;
case 6: occurenceString = I18N_NOOP("Twice yearly"); break;
default: occurenceString = I18N_NOOP(static_cast<TQString>("Every %1 months").arg(mult));
}
else if(type == MyMoneySchedule::OCCUR_YEARLY)
switch (mult)
{
case 1: occurenceString = I18N_NOOP("Yearly"); break;
case 2: occurenceString = I18N_NOOP("Every other year"); break;
default: occurenceString = I18N_NOOP(static_cast<TQString>("Every %1 years").arg(mult));
}
return occurenceString;
}
TQString MyMoneySchedule::occurencePeriodToString(MyMoneySchedule::occurenceE type)
{
TQString occurenceString = I18N_NOOP("Any");
if(type == MyMoneySchedule::OCCUR_ONCE)
occurenceString = I18N_NOOP("Once");
else if(type == MyMoneySchedule::OCCUR_DAILY)
occurenceString = I18N_NOOP("Day");
else if(type == MyMoneySchedule::OCCUR_WEEKLY)
occurenceString = I18N_NOOP("Week");
else if(type == MyMoneySchedule::OCCUR_EVERYHALFMONTH)
occurenceString = I18N_NOOP("Half-month");
else if(type == MyMoneySchedule::OCCUR_MONTHLY)
occurenceString = I18N_NOOP("Month");
else if(type == MyMoneySchedule::OCCUR_YEARLY)
occurenceString = I18N_NOOP("Year");
return occurenceString;
}
TQString MyMoneySchedule::scheduleTypeToString(MyMoneySchedule::typeE type)
{
TQString text;
switch (type) {
case MyMoneySchedule::TYPE_BILL:
text = I18N_NOOP("Bill");
break;
case MyMoneySchedule::TYPE_DEPOSIT:
text = I18N_NOOP("Deposit");
break;
case MyMoneySchedule::TYPE_TRANSFER:
text = I18N_NOOP("Transfer");
break;
case MyMoneySchedule::TYPE_LOANPAYMENT:
text = I18N_NOOP("Loan payment");
break;
case MyMoneySchedule::TYPE_ANY:
default:
text = I18N_NOOP("Unknown");
}
return text;
}
TQString MyMoneySchedule::paymentMethodToString(MyMoneySchedule::paymentTypeE paymentType)
{
TQString text;
switch (paymentType) {
case MyMoneySchedule::STYPE_DIRECTDEBIT:
text = I18N_NOOP("Direct debit");
break;
case MyMoneySchedule::STYPE_DIRECTDEPOSIT:
text = I18N_NOOP("Direct deposit");
break;
case MyMoneySchedule::STYPE_MANUALDEPOSIT:
text = I18N_NOOP("Manual deposit");
break;
case MyMoneySchedule::STYPE_OTHER:
text = I18N_NOOP("Other");
break;
case MyMoneySchedule::STYPE_WRITECHETQUE:
text = I18N_NOOP("Write check");
break;
case MyMoneySchedule::STYPE_STANDINGORDER:
text = I18N_NOOP("Standing order");
break;
case MyMoneySchedule::STYPE_BANKTRANSFER:
text = I18N_NOOP("Bank transfer");
break;
case MyMoneySchedule::STYPE_ANY:
text = I18N_NOOP("Any (Error)");
break;
}
return text;
}
TQString MyMoneySchedule::weekendOptionToString(MyMoneySchedule::weekendOptionE weekendOption)
{
TQString text;
switch (weekendOption) {
case MyMoneySchedule::MoveFriday:
text = I18N_NOOP("Change the date to the previous Friday");
break;
case MyMoneySchedule::MoveMonday:
text = I18N_NOOP("Change the date to the next Monday");
break;
case MyMoneySchedule::MoveNothing:
text = I18N_NOOP("Do Nothing");
break;
}
return text;
}
// until we don't have the means to store the value
// of the variation, we default to 10% in case this
// scheduled transaction is marked 'not fixed'.
//
// ipwizard 2009-04-18
int MyMoneySchedule::variation(void) const
{
int rc = 0;
if(!isFixed()) {
rc = 10;
#if 0
TQString var = value("kmm-variation");
if(!var.isEmpty())
rc = var.toInt();
#endif
}
return rc;
}
void MyMoneySchedule::setVariation(int var)
{
#if 0
deletePair("kmm-variation");
if(var != 0)
setValue("kmm-variation", TQString("%1").arg(var));
#endif
}
int MyMoneySchedule::eventsPerYear(MyMoneySchedule::occurenceE occurence)
{
int rc = 0;
switch(occurence) {
case MyMoneySchedule::OCCUR_DAILY:
rc = 365;
break;
case MyMoneySchedule::OCCUR_WEEKLY:
rc = 52;
break;
case MyMoneySchedule::OCCUR_FORTNIGHTLY:
rc = 26;
break;
case MyMoneySchedule::OCCUR_EVERYOTHERWEEK:
rc = 26;
break;
case MyMoneySchedule::OCCUR_EVERYHALFMONTH:
rc = 24;
break;
case MyMoneySchedule::OCCUR_EVERYTHREEWEEKS:
rc = 17;
break;
case MyMoneySchedule::OCCUR_EVERYFOURWEEKS:
rc = 13;
break;
case MyMoneySchedule::OCCUR_MONTHLY:
case MyMoneySchedule::OCCUR_EVERYTHIRTYDAYS:
rc = 12;
break;
case MyMoneySchedule::OCCUR_EVERYEIGHTWEEKS:
rc = 6;
break;
case MyMoneySchedule::OCCUR_EVERYOTHERMONTH:
rc = 6;
break;
case MyMoneySchedule::OCCUR_EVERYTHREEMONTHS:
case MyMoneySchedule::OCCUR_TQUARTERLY:
rc = 4;
break;
case MyMoneySchedule::OCCUR_EVERYFOURMONTHS:
rc = 3;
break;
case MyMoneySchedule::OCCUR_TWICEYEARLY:
rc = 2;
break;
case MyMoneySchedule::OCCUR_YEARLY:
rc = 1;
break;
default:
qWarning("Occurence not supported by financial calculator");
}
return rc;
}
int MyMoneySchedule::daysBetweenEvents(MyMoneySchedule::occurenceE occurence)
{
int rc = 0;
switch(occurence) {
case MyMoneySchedule::OCCUR_DAILY:
rc = 1;
break;
case MyMoneySchedule::OCCUR_WEEKLY:
rc = 7;
break;
case MyMoneySchedule::OCCUR_FORTNIGHTLY:
rc = 14;
break;
case MyMoneySchedule::OCCUR_EVERYOTHERWEEK:
rc = 14;
break;
case MyMoneySchedule::OCCUR_EVERYHALFMONTH:
rc = 15;
break;
case MyMoneySchedule::OCCUR_EVERYTHREEWEEKS:
rc = 21;
break;
case MyMoneySchedule::OCCUR_EVERYFOURWEEKS:
rc = 28;
break;
case MyMoneySchedule::OCCUR_EVERYTHIRTYDAYS:
rc = 30;
break;
case MyMoneySchedule::OCCUR_MONTHLY:
rc = 30;
break;
case MyMoneySchedule::OCCUR_EVERYEIGHTWEEKS:
rc = 56;
break;
case MyMoneySchedule::OCCUR_EVERYOTHERMONTH:
rc = 60;
break;
case MyMoneySchedule::OCCUR_EVERYTHREEMONTHS:
case MyMoneySchedule::OCCUR_TQUARTERLY:
rc = 90;
break;
case MyMoneySchedule::OCCUR_EVERYFOURMONTHS:
rc = 120;
break;
case MyMoneySchedule::OCCUR_TWICEYEARLY:
rc = 180;
break;
case MyMoneySchedule::OCCUR_YEARLY:
rc = 360;
break;
default:
qWarning("Occurence not supported by financial calculator");
}
return rc;
}
TQDate MyMoneySchedule::addHalfMonths( TQDate date, int mult ) const
{
TQDate newdate = date;
int d, dm;
if ( mult > 0 )
{
d = newdate.day();
if ( d <= 12 )
{
if ( mult % 2 == 0 )
newdate = newdate.addMonths(mult>>1);
else
newdate = newdate.addMonths(mult>>1).addDays(15);
}
else
for ( int i = 0; i < mult; i++ )
{
if ( d <= 13 )
newdate = newdate.addDays(15);
else
{
dm = newdate.daysInMonth();
if ( d == 14 )
newdate = newdate.addDays(( dm < 30 ) ? dm - d : 15);
else if ( d == 15 )
newdate = newdate.addDays(dm - d);
else if ( d == dm )
newdate = newdate.addDays(15 - d).addMonths(1);
else
newdate = newdate.addDays(-15).addMonths(1);
}
d = newdate.day();
}
}
else if ( mult < 0 ) // Go backwards
for ( int i = 0; i > mult; i-- )
{
d = newdate.day();
dm = newdate.daysInMonth();
if ( d > 15 )
{
dm = newdate.daysInMonth();
newdate = newdate.addDays( (d == dm) ? 15 - dm : -15);
}
else if ( d <= 13 )
newdate = newdate.addMonths(-1).addDays(15);
else if ( d == 15 )
newdate = newdate.addDays(-15);
else // 14
{
newdate = newdate.addMonths(-1);
dm = newdate.daysInMonth();
newdate = newdate.addDays(( dm < 30 ) ? dm - d : 15 );
}
}
return newdate;
}
MyMoneySchedule::occurenceE MyMoneySchedule::stringToOccurence(const TQString& text)
{
MyMoneySchedule::occurenceE occurence = MyMoneySchedule::OCCUR_ANY;
TQString tmp = text.lower();
if(tmp == i18n("Once").lower())
occurence = MyMoneySchedule::OCCUR_ONCE;
else if(tmp == i18n("Daily").lower())
occurence = MyMoneySchedule::OCCUR_DAILY;
else if(tmp == i18n("Weekly").lower())
occurence = MyMoneySchedule::OCCUR_WEEKLY;
else if(tmp == i18n("Fortnightly").lower())
occurence = MyMoneySchedule::OCCUR_FORTNIGHTLY;
else if(tmp == i18n("Every other week").lower())
occurence = MyMoneySchedule::OCCUR_EVERYOTHERWEEK;
else if(tmp == i18n("Every half month").lower())
occurence = MyMoneySchedule::OCCUR_EVERYHALFMONTH;
else if(tmp == i18n("Every three weeks").lower())
occurence = MyMoneySchedule::OCCUR_EVERYTHREEWEEKS;
else if(tmp == i18n("Every four weeks").lower())
occurence = MyMoneySchedule::OCCUR_EVERYFOURWEEKS;
else if(tmp == i18n("Every thirty days").lower())
occurence = MyMoneySchedule::OCCUR_EVERYTHIRTYDAYS;
else if(tmp == i18n("Monthly").lower())
occurence = MyMoneySchedule::OCCUR_MONTHLY;
else if(tmp == i18n("Every eight weeks").lower())
occurence = MyMoneySchedule::OCCUR_EVERYEIGHTWEEKS;
else if(tmp == i18n("Every two months").lower())
occurence = MyMoneySchedule::OCCUR_EVERYOTHERMONTH;
else if(tmp == i18n("Every three months").lower())
occurence = MyMoneySchedule::OCCUR_EVERYTHREEMONTHS;
else if(tmp == i18n("Quarterly").lower())
occurence = MyMoneySchedule::OCCUR_TQUARTERLY;
else if(tmp == i18n("Every four months").lower())
occurence = MyMoneySchedule::OCCUR_EVERYFOURMONTHS;
else if(tmp == i18n("Twice yearly").lower())
occurence = MyMoneySchedule::OCCUR_TWICEYEARLY;
else if(tmp == i18n("Yearly").lower())
occurence = MyMoneySchedule::OCCUR_YEARLY;
else if(tmp == i18n("Every other year").lower())
occurence = MyMoneySchedule::OCCUR_EVERYOTHERYEAR;
return occurence;
}
/**
* Helper method to convert simple occurence to compound occurence + multiplier
*
* @param multiplier Returned by reference. Adjusted multiplier
* @param occurence Returned by reference. Occurence type
*/
void MyMoneySchedule::simpleToCompoundOccurence(int& multiplier,occurenceE& occurence)
{
occurenceE newOcc = occurence;
int newMulti = 1;
if (occurence == MyMoneySchedule::OCCUR_ONCE ||
occurence == MyMoneySchedule::OCCUR_DAILY ||
occurence == MyMoneySchedule::OCCUR_WEEKLY ||
occurence == MyMoneySchedule::OCCUR_EVERYHALFMONTH ||
occurence == MyMoneySchedule::OCCUR_MONTHLY ||
occurence == MyMoneySchedule::OCCUR_YEARLY )
{ // Already a base occurence and multiplier
}
else if(occurence == MyMoneySchedule::OCCUR_FORTNIGHTLY ||
occurence == MyMoneySchedule::OCCUR_EVERYOTHERWEEK)
{
newOcc = MyMoneySchedule::OCCUR_WEEKLY;
newMulti = 2;
}
else if(occurence == MyMoneySchedule::OCCUR_EVERYTHREEWEEKS)
{
newOcc = MyMoneySchedule::OCCUR_WEEKLY;
newMulti = 3;
}
else if(occurence == MyMoneySchedule::OCCUR_EVERYFOURWEEKS)
{
newOcc = MyMoneySchedule::OCCUR_WEEKLY;
newMulti = 4;
}
else if(occurence == MyMoneySchedule::OCCUR_EVERYTHIRTYDAYS)
{
newOcc = MyMoneySchedule::OCCUR_DAILY;
newMulti = 30;
}
else if(occurence == MyMoneySchedule::OCCUR_EVERYEIGHTWEEKS)
{
newOcc = MyMoneySchedule::OCCUR_WEEKLY;
newMulti = 8;
}
else if(occurence == MyMoneySchedule::OCCUR_EVERYOTHERMONTH)
{
newOcc = MyMoneySchedule::OCCUR_MONTHLY;
newMulti = 2;
}
else if(occurence == MyMoneySchedule::OCCUR_EVERYTHREEMONTHS ||
occurence == MyMoneySchedule::OCCUR_TQUARTERLY )
{
newOcc = MyMoneySchedule::OCCUR_MONTHLY;
newMulti = 3;
}
else if(occurence == MyMoneySchedule::OCCUR_EVERYFOURMONTHS)
{
newOcc = MyMoneySchedule::OCCUR_MONTHLY;
newMulti = 4;
}
else if(occurence == MyMoneySchedule::OCCUR_TWICEYEARLY)
{
newOcc = MyMoneySchedule::OCCUR_MONTHLY;
newMulti = 6;
}
else if(occurence == MyMoneySchedule::OCCUR_EVERYOTHERYEAR)
{
newOcc = MyMoneySchedule::OCCUR_YEARLY;
newMulti = 2;
}
else // Unknown
{
newOcc = MyMoneySchedule::OCCUR_ANY;
newMulti = 1;
}
if (newOcc != occurence)
{
occurence = newOcc;
multiplier = newMulti == 1 ? multiplier : newMulti * multiplier;
}
}
/**
* Helper method to convert compound occurence + multiplier to simple occurence
*
* @param multiplier Returned by reference. Adjusted multiplier
* @param occurence Returned by reference. Occurence type
*/
void MyMoneySchedule::compoundToSimpleOccurence(int& multiplier,occurenceE& occurence)
{
occurenceE newOcc = occurence;
if(occurence == MyMoneySchedule::OCCUR_ONCE)
{ // Nothing to do
}
else if(occurence == MyMoneySchedule::OCCUR_DAILY)
{
switch (multiplier)
{
case 1: break;
case 30: newOcc = MyMoneySchedule::OCCUR_EVERYTHIRTYDAYS; break;
}
}
else if(newOcc == MyMoneySchedule::OCCUR_WEEKLY)
{
switch (multiplier)
{
case 1: break;
case 2: newOcc = MyMoneySchedule::OCCUR_EVERYOTHERWEEK; break;
case 3: newOcc = MyMoneySchedule::OCCUR_EVERYTHREEWEEKS; break;
case 4: newOcc = MyMoneySchedule::OCCUR_EVERYFOURWEEKS; break;
case 8: newOcc = MyMoneySchedule::OCCUR_EVERYEIGHTWEEKS; break;
}
}
else if(occurence == MyMoneySchedule::OCCUR_MONTHLY)
switch (multiplier)
{
case 1: break;
case 2: newOcc = MyMoneySchedule::OCCUR_EVERYOTHERMONTH; break;
case 3: newOcc = MyMoneySchedule::OCCUR_EVERYTHREEMONTHS; break;
case 4: newOcc = MyMoneySchedule::OCCUR_EVERYFOURMONTHS; break;
case 6: newOcc = MyMoneySchedule::OCCUR_TWICEYEARLY; break;
}
else if(occurence == MyMoneySchedule::OCCUR_EVERYHALFMONTH)
switch (multiplier)
{
case 1: break;
}
else if(occurence == MyMoneySchedule::OCCUR_YEARLY)
{
switch (multiplier)
{
case 1: break;
case 2: newOcc = MyMoneySchedule::OCCUR_EVERYOTHERYEAR; break;
}
}
if (occurence != newOcc ) // Changed to derived type
{
occurence = newOcc;
multiplier = 1;
}
}