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/converter/mymoneygncreader.cpp

2464 lines
97 KiB

/***************************************************************************
mymoneygncreader - description
-------------------
begin : Wed Mar 3 2004
copyright : (C) 2000-2004 by Michael Edwardes
email : mte@users.sourceforge.net
Javier Campos Morales <javi_c@users.sourceforge.net>
Felix Rodriguez <frodriguez@users.sourceforge.net>
John C <thetacoturtle@users.sourceforge.net>
Thomas Baumgart <ipwizard@users.sourceforge.net>
Kevin Tambascio <ktambascio@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
#include <tqfile.h>
#include <tqmap.h>
#include <tqobject.h>
#include <tqfiledialog.h>
#include <tqinputdialog.h>
#include <tqdatetime.h>
// ----------------------------------------------------------------------------
// KDE Includes
#ifndef _GNCFILEANON
#include <tdelocale.h>
#include <tdeconfig.h>
#include <tdemessagebox.h>
#endif
// ----------------------------------------------------------------------------
// Third party Includes
// ------------------------------------------------------------Box21----------------
// Project Includes
#include "mymoneygncreader.h"
#ifndef _GNCFILEANON
#include "config.h"
#include "../mymoney/storage/imymoneystorage.h"
#include "../kmymoneyutils.h"
#include "../mymoney/mymoneyfile.h"
#include "../mymoney/mymoneyprice.h"
#include "../dialogs/kgncimportoptionsdlg.h"
#include "../dialogs/kgncpricesourcedlg.h"
#include "../dialogs/keditscheduledlg.h"
#include "../widgets/kmymoneyedit.h"
#define TRY try {
#define CATCH } catch (MyMoneyException *e) {
#define PASS } catch (MyMoneyException *e) { throw e; }
#else
#include "mymoneymoney.h"
#include <tqtextedit.h>
#define i18n TQObject::tr
#define TRY
#define CATCH
#define PASS
#define MYMONEYEXCEPTION TQString
#define MyMoneyException TQString
#define PACKAGE "KMyMoney"
#endif // _GNCFILEANON
// init static variables
double MyMoneyGncReader::m_fileHideFactor = 0.0;
double GncObject::m_moneyHideFactor;
// user options
void MyMoneyGncReader::setOptions () {
#ifndef _GNCFILEANON
KGncImportOptionsDlg dlg; // display the dialog to allow the user to set own options
if (dlg.exec()) {
// set users input options
m_dropSuspectSchedules = dlg.scheduleOption();
m_investmentOption = dlg.investmentOption();
m_useFinanceQuote = dlg.quoteOption();
m_useTxNotes = dlg.txNotesOption();
m_decoder = dlg.decodeOption();
gncdebug = dlg.generalDebugOption();
xmldebug = dlg.xmlDebugOption();
bAnonymize = dlg.anonymizeOption();
} else {
// user declined, so set some sensible defaults
m_dropSuspectSchedules = false;
// investment option - 0, create investment a/c per stock a/c, 1 = single new investment account, 2 = prompt for each stock
// option 2 doesn't really work too well at present
m_investmentOption = 0;
m_useFinanceQuote = false;
m_useTxNotes = false;
m_decoder = 0;
gncdebug = false; // general debug messages
xmldebug = false; // xml trace
bAnonymize = false; // anonymize input
}
// no dialog option for the following; it will set base currency, and print actual XML data
developerDebug = false;
// set your fave currency here to save getting that enormous dialog each time you run a test
// especially if you have to scroll down to USD...
if (developerDebug) m_storage->setValue ("kmm-baseCurrency", "GBP");
#endif // _GNCFILEANON
}
GncObject::GncObject () {
m_v.setAutoDelete (true);
}
// Check that the current element is of a version we are coded for
void GncObject::checkVersion (const TQString& elName, const TQXmlAttributes& elAttrs, const map_elementVersions& map) {
TRY
if (map.contains(elName)) { // if it's not in the map, there's nothing to check
if (!map[elName].contains(elAttrs.value("version"))) {
TQString em = i18n("%1: Sorry. This importer cannot handle version %2 of element %3")
.arg(__func__).arg(elAttrs.value("version")).arg(elName);
throw new MYMONEYEXCEPTION (em);
}
}
return ;
PASS
}
// Check if this element is in the current object's sub element list
GncObject *GncObject::isSubElement (const TQString& elName, const TQXmlAttributes& elAttrs) {
TRY
uint i;
GncObject *next = 0;
for (i = 0; i < m_subElementListCount; i++) {
if (elName == m_subElementList[i]) {
m_state = i;
next = startSubEl(); // go create the sub object
if (next != 0) {
next->initiate(elName, elAttrs); // initialize it
next->m_elementName = elName; // save it's name so we can identify the end
}
break;
}
}
return (next);
PASS
}
// Check if this element is in the current object's data element list
bool GncObject::isDataElement (const TQString &elName, const TQXmlAttributes& elAttrs) {
TRY
uint i;
for (i = 0; i < m_dataElementListCount; i++) {
if (elName == m_dataElementList[i]) {
m_state = i;
dataEl(elAttrs); // go set the pointer so the data can be stored
return (true);
}
}
m_dataPtr = 0; // we don't need this, so make sure we don't store extraneous data
return (false);
PASS
}
// return the variable string, decoded if required
TQString GncObject::var (int i) const {
return (pMain->m_decoder == 0
? *(m_v.at(i))
: pMain->m_decoder->toUnicode (*(m_v.at(i))));
}
void GncObject::adjustHideFactor () {
m_moneyHideFactor = pMain->m_fileHideFactor * (1.0 + (int)(200.0 * rand()/(RAND_MAX+1.0))) / 100.0;
}
// data anonymizer
TQString GncObject::hide (TQString data, unsigned int anonClass) {
TRY
if (!pMain->bAnonymize) return (data); // no anonymizing required
// counters used to generate names for anonymizer
static int nextAccount;
static int nextEquity;
static int nextPayee;
static int nextSched;
static TQMap<TQString, TQString> anonPayees; // to check for duplicate payee names
static TQMap<TQString, TQString> anonStocks; // for reference to equities
TQString result (data);
TQMap<TQString, TQString>::Iterator it;
MyMoneyMoney in, mresult;
switch (anonClass) {
case ASIS: break; // this is not personal data
case SUPPRESS: result = ""; break; // this is personal and is not essential
case NXTACC: result = i18n("Account%1").arg(++nextAccount, -6); break; // generate account name
case NXTEQU: // generate/return an equity name
it = anonStocks.find (data);
if (it == anonStocks.end()) {
result = i18n("Stock%1").arg(++nextEquity, -6);
anonStocks.insert (data, result);
} else {
result = (*it);
}
break;
case NXTPAY: // genearet/return a payee name
it = anonPayees.find (data);
if (it == anonPayees.end()) {
result = i18n("Payee%1").arg(++nextPayee, -6);
anonPayees.insert (data, result);
} else {
result = (*it);
}
break;
case NXTSCHD: result = i18n("Schedule%1").arg(++nextSched, -6); break; // generate a schedule name
case MONEY1:
in = MyMoneyMoney(data);
if (data == "-1/0") in = MyMoneyMoney (0); // spurious gnucash data - causes a crash sometimes
mresult = MyMoneyMoney(m_moneyHideFactor) * in;
mresult.convert(10000);
result = mresult.toString();
break;
case MONEY2:
in = MyMoneyMoney(data);
if (data == "-1/0") in = MyMoneyMoney (0);
mresult = MyMoneyMoney(m_moneyHideFactor) * in;
mresult.convert(10000);
mresult.setThousandSeparator (' ');
result = mresult.formatMoney("", 2);
break;
}
return (result);
PASS
}
// dump current object data values // only called if gncdebug set
void GncObject::debugDump () {
uint i;
tqDebug ("Object %s", m_elementName.latin1());
for (i = 0; i < m_dataElementListCount; i++) {
tqDebug ("%s = %s", m_dataElementList[i].latin1(), m_v.at(i)->latin1());
}
}
//*****************************************************************
GncFile::GncFile () {
static const TQString subEls[] = {"gnc:book", "gnc:count-data", "gnc:commodity", "price",
"gnc:account", "gnc:transaction", "gnc:template-transactions",
"gnc:schedxaction"
};
m_subElementList = subEls;
m_subElementListCount = END_FILE_SELS;
m_dataElementListCount = 0;
m_processingTemplates = false;
m_bookFound = false;
}
GncFile::~GncFile () {}
GncObject *GncFile::startSubEl() {
TRY
if (pMain->xmldebug) tqDebug ("File start subel m_state %d", m_state);
GncObject *next = 0;
switch (m_state) {
case BOOK:
if (m_bookFound) throw new MYMONEYEXCEPTION (i18n("This version of the importer cannot handle multi-book files."));
m_bookFound = true;
break;
case COUNT: next = new GncCountData; break;
case CMDTY: next = new GncCommodity; break;
case PRICE: next = new GncPrice; break;
case ACCT:
// accounts within the template section are ignored
if (!m_processingTemplates) next = new GncAccount;
break;
case TX: next = new GncTransaction (m_processingTemplates); break;
case TEMPLATES: m_processingTemplates = true; break;
case SCHEDULES: m_processingTemplates = false; next = new GncSchedule; break;
default: throw new MYMONEYEXCEPTION ("GncFile rcvd invalid state");
}
return (next);
PASS
}
void GncFile::endSubEl(GncObject *subObj) {
if (pMain->xmldebug) tqDebug ("File end subel");
if (!m_processingTemplates) delete subObj; // template txs must be saved awaiting schedules
m_dataPtr = 0;
return ;
}
//****************************************** GncDate *********************************************
GncDate::GncDate () {
m_subElementListCount = 0;
static const TQString dEls[] = {"ts:date", "gdate"};
m_dataElementList = dEls;
m_dataElementListCount = END_Date_DELS;
static const unsigned int anonClasses[] = {ASIS, ASIS};
m_anonClassList = anonClasses;
for (uint i = 0; i < m_dataElementListCount; i++) m_v.append (new TQString (""));
}
GncDate::~GncDate() {}
//*************************************GncCmdtySpec***************************************
GncCmdtySpec::GncCmdtySpec () {
m_subElementListCount = 0;
static const TQString dEls[] = {"cmdty:space", "cmdty:id"};
m_dataElementList = dEls;
m_dataElementListCount = END_CmdtySpec_DELS;
static const unsigned int anonClasses[] = {ASIS, ASIS};
m_anonClassList = anonClasses;
for (uint i = 0; i < m_dataElementListCount; i++) m_v.append (new TQString (""));
}
GncCmdtySpec::~GncCmdtySpec () {}
TQString GncCmdtySpec::hide(TQString data, unsigned int) {
// hide equity names, but not currency names
unsigned int newClass = ASIS;
switch (m_state) {
case CMDTYID:
if (!isCurrency()) newClass = NXTEQU;
}
return (GncObject::hide (data, newClass));
}
//************* GncKvp********************************************
GncKvp::GncKvp () {
m_subElementListCount = END_Kvp_SELS;
static const TQString subEls[] = {"slot"}; // kvp's may be nested
m_subElementList = subEls;
m_dataElementListCount = END_Kvp_DELS;
static const TQString dataEls[] = {"slot:key", "slot:value"};
m_dataElementList = dataEls;
static const unsigned int anonClasses[] = {ASIS, ASIS};
m_anonClassList = anonClasses;
for (uint i = 0; i < m_dataElementListCount; i++) m_v.append (new TQString (""));
m_kvpList.setAutoDelete (true);
}
GncKvp::~GncKvp () {}
void GncKvp::dataEl (const TQXmlAttributes& elAttrs) {
switch (m_state) {
case VALUE:
m_kvpType = elAttrs.value("type");
}
m_dataPtr = m_v.at(m_state);
if (key().contains ("formula")) {
m_anonClass = MONEY2;
} else {
m_anonClass = ASIS;
}
return ;
}
GncObject *GncKvp::startSubEl() {
if (pMain->xmldebug) tqDebug ("Kvp start subel m_state %d", m_state);
TRY
GncObject *next = 0;
switch (m_state) {
case KVP: next = new GncKvp; break;
default: throw new MYMONEYEXCEPTION ("GncKvp rcvd invalid m_state ");
}
return (next);
PASS
}
void GncKvp::endSubEl(GncObject *subObj) {
if (pMain->xmldebug) tqDebug ("Kvp end subel");
m_kvpList.append (subObj);
m_dataPtr = 0;
return ;
}
//*********************************GncLot*********************************************
GncLot::GncLot() {
m_subElementListCount = 0;
m_dataElementListCount = 0;
}
GncLot::~GncLot() {}
//*********************************GncCountData***************************************
GncCountData::GncCountData() {
m_subElementListCount = 0;
m_dataElementListCount = 0;
m_v.append (new TQString ("")); // only 1 data item
}
GncCountData::~GncCountData () {}
void GncCountData::initiate (const TQString&, const TQXmlAttributes& elAttrs) {
m_countType = elAttrs.value ("cd:type");
m_dataPtr = m_v.at(0);
return ;
}
void GncCountData::terminate () {
int i = m_v.at(0)->toInt();
if (m_countType == "commodity") {
pMain->setGncCommodityCount(i); return ;
}
if (m_countType == "account") {
pMain->setGncAccountCount(i); return ;
}
if (m_countType == "transaction") {
pMain->setGncTransactionCount(i); return ;
}
if (m_countType == "schedxaction") {
pMain->setGncScheduleCount(i); return ;
}
if (i != 0) {
if (m_countType == "budget") pMain->setBudgetsFound(true);
else if (m_countType.left(7) == "gnc:Gnc") pMain->setSmallBusinessFound(true);
else if (pMain->xmldebug) tqDebug ("Unknown count type %s", m_countType.latin1());
}
return ;
}
//*********************************GncCommodity***************************************
GncCommodity::GncCommodity () {
m_subElementListCount = 0;
static const TQString dEls[] = {"cmdty:space", "cmdty:id", "cmdty:name", "cmdty:fraction"};
m_dataElementList = dEls;
m_dataElementListCount = END_Commodity_DELS;
static const unsigned int anonClasses[] = {ASIS, NXTEQU, SUPPRESS, ASIS};
m_anonClassList = anonClasses;
for (uint i = 0; i < m_dataElementListCount; i++) m_v.append (new TQString (""));
}
GncCommodity::~GncCommodity () {}
void GncCommodity::terminate() {
TRY
pMain->convertCommodity (this);
return ;
PASS
}
//************* GncPrice********************************************
GncPrice::GncPrice () {
static const TQString subEls[] = {"price:commodity", "price:currency", "price:time"};
m_subElementList = subEls;
m_subElementListCount = END_Price_SELS;
m_dataElementListCount = END_Price_DELS;
static const TQString dataEls[] = {"price:value"};
m_dataElementList = dataEls;
static const unsigned int anonClasses[] = {ASIS};
m_anonClassList = anonClasses;
for (uint i = 0; i < m_dataElementListCount; i++) m_v.append (new TQString (""));
m_vpCommodity = NULL;
m_vpCurrency = NULL;
m_vpPriceDate = NULL;
}
GncPrice::~GncPrice () {
delete m_vpCommodity; delete m_vpCurrency; delete m_vpPriceDate;
}
GncObject *GncPrice::startSubEl() {
TRY
GncObject *next = 0;
switch (m_state) {
case CMDTY: next = new GncCmdtySpec; break;
case CURR: next = new GncCmdtySpec; break;
case PRICEDATE: next = new GncDate; break;
default: throw new MYMONEYEXCEPTION ("GncPrice rcvd invalid m_state");
}
return (next);
PASS
}
void GncPrice::endSubEl(GncObject *subObj) {
TRY
switch (m_state) {
case CMDTY: m_vpCommodity = static_cast<GncCmdtySpec *>(subObj); break;
case CURR: m_vpCurrency = static_cast<GncCmdtySpec *>(subObj); break;
case PRICEDATE: m_vpPriceDate = static_cast<GncDate *>(subObj); break;
default: throw new MYMONEYEXCEPTION ("GncPrice rcvd invalid m_state");
}
return;
PASS
}
void GncPrice::terminate() {
TRY
pMain->convertPrice (this);
return ;
PASS
}
//************* GncAccount********************************************
GncAccount::GncAccount () {
m_subElementListCount = END_Account_SELS;
static const TQString subEls[] = {"act:commodity", "slot", "act:lots"};
m_subElementList = subEls;
m_dataElementListCount = END_Account_DELS;
static const TQString dataEls[] = {"act:id", "act:name", "act:description",
"act:type", "act:parent"};
m_dataElementList = dataEls;
static const unsigned int anonClasses[] = {ASIS, NXTACC, SUPPRESS, ASIS, ASIS};
m_anonClassList = anonClasses;
m_kvpList.setAutoDelete (true);
for (uint i = 0; i < m_dataElementListCount; i++) m_v.append (new TQString (""));
m_vpCommodity = NULL;
}
GncAccount::~GncAccount () {
delete m_vpCommodity;
}
GncObject *GncAccount::startSubEl() {
TRY
if (pMain->xmldebug) tqDebug ("Account start subel m_state %d", m_state);
GncObject *next = 0;
switch (m_state) {
case CMDTY: next = new GncCmdtySpec; break;
case KVP: next = new GncKvp; break;
case LOTS: next = new GncLot();
pMain->setLotsFound(true); // we don't handle lots; just set flag to report
break;
default: throw new MYMONEYEXCEPTION ("GncAccount rcvd invalid m_state");
}
return (next);
PASS
}
void GncAccount::endSubEl(GncObject *subObj) {
if (pMain->xmldebug) tqDebug ("Account end subel");
switch (m_state) {
case CMDTY: m_vpCommodity = static_cast<GncCmdtySpec *>(subObj); break;
case KVP: m_kvpList.append (subObj);
}
return ;
}
void GncAccount::terminate() {
TRY
pMain->convertAccount (this);
return ;
PASS
}
//************* GncTransaction********************************************
GncTransaction::GncTransaction (bool processingTemplates) {
m_subElementListCount = END_Transaction_SELS;
static const TQString subEls[] = {"trn:currency", "trn:date-posted", "trn:date-entered",
"trn:split", "slot"};
m_subElementList = subEls;
m_dataElementListCount = END_Transaction_DELS;
static const TQString dataEls[] = {"trn:id", "trn:num", "trn:description"};
m_dataElementList = dataEls;
static const unsigned int anonClasses[] = {ASIS, SUPPRESS, NXTPAY};
m_anonClassList = anonClasses;
adjustHideFactor();
m_template = processingTemplates;
m_splitList.setAutoDelete (true);
for (uint i = 0; i < m_dataElementListCount; i++) m_v.append (new TQString (""));
m_vpCurrency = NULL;
m_vpDateEntered = m_vpDatePosted = NULL;
}
GncTransaction::~GncTransaction () {
delete m_vpCurrency; delete m_vpDatePosted; delete m_vpDateEntered;
}
GncObject *GncTransaction::startSubEl() {
TRY
if (pMain->xmldebug) tqDebug ("Transaction start subel m_state %d", m_state);
GncObject *next = 0;
switch (m_state) {
case CURRCY: next = new GncCmdtySpec; break;
case POSTED:
case ENTERED:
next = new GncDate; break;
case SPLIT:
if (isTemplate()) {
next = new GncTemplateSplit;
} else {
next = new GncSplit;
}
break;
case KVP: next = new GncKvp; break;
default: throw new MYMONEYEXCEPTION ("GncTransaction rcvd invalid m_state");
}
return (next);
PASS
}
void GncTransaction::endSubEl(GncObject *subObj) {
if (pMain->xmldebug) tqDebug ("Transaction end subel");
switch (m_state) {
case CURRCY: m_vpCurrency = static_cast<GncCmdtySpec *>(subObj); break;
case POSTED: m_vpDatePosted = static_cast<GncDate *>(subObj); break;
case ENTERED: m_vpDateEntered = static_cast<GncDate *>(subObj); break;
case SPLIT: m_splitList.append (subObj); break;
case KVP: m_kvpList.append (subObj);
}
return ;
}
void GncTransaction::terminate() {
TRY
if (isTemplate()) {
pMain->saveTemplateTransaction(this);
} else {
pMain->convertTransaction (this);
}
return ;
PASS
}
//************* GncSplit********************************************
GncSplit::GncSplit () {
m_subElementListCount = END_Split_SELS;
static const TQString subEls[] = {"split:reconcile-date"};
m_subElementList = subEls;
m_dataElementListCount = END_Split_DELS;
static const TQString dataEls[] = {"split:id", "split:memo", "split:reconciled-state", "split:value",
"split:quantity", "split:account"};
m_dataElementList = dataEls;
static const unsigned int anonClasses[] = {ASIS, SUPPRESS, ASIS, MONEY1, MONEY1, ASIS};
m_anonClassList = anonClasses;
for (uint i = 0; i < m_dataElementListCount; i++) m_v.append (new TQString (""));
m_vpDateReconciled = NULL;
}
GncSplit::~GncSplit () {
delete m_vpDateReconciled;
}
GncObject *GncSplit::startSubEl () {
TRY
GncObject *next = 0;
switch (m_state) {
case RECDATE: next = new GncDate; break;
default: throw new MYMONEYEXCEPTION ("GncTemplateSplit rcvd invalid m_state ");
}
return (next);
PASS
}
void GncSplit::endSubEl(GncObject *subObj) {
if (pMain->xmldebug) tqDebug ("Split end subel");
switch (m_state) {
case RECDATE: m_vpDateReconciled = static_cast<GncDate *>(subObj); break;
}
return ;
}
//************* GncTemplateSplit********************************************
GncTemplateSplit::GncTemplateSplit () {
m_subElementListCount = END_TemplateSplit_SELS;
static const TQString subEls[] = {"slot"};
m_subElementList = subEls;
m_dataElementListCount = END_TemplateSplit_DELS;
static const TQString dataEls[] = {"split:id", "split:memo", "split:reconciled-state", "split:value",
"split:quantity", "split:account"};
m_dataElementList = dataEls;
static const unsigned int anonClasses[] = {ASIS, SUPPRESS, ASIS, MONEY1, MONEY1, ASIS};
m_anonClassList = anonClasses;
for (uint i = 0; i < m_dataElementListCount; i++) m_v.append (new TQString (""));
m_kvpList.setAutoDelete (true);
}
GncTemplateSplit::~GncTemplateSplit () {}
GncObject *GncTemplateSplit::startSubEl() {
if (pMain->xmldebug) tqDebug ("TemplateSplit start subel m_state %d", m_state);
TRY
GncObject *next = 0;
switch (m_state) {
case KVP: next = new GncKvp; break;
default: throw new MYMONEYEXCEPTION ("GncTemplateSplit rcvd invalid m_state");
}
return (next);
PASS
}
void GncTemplateSplit::endSubEl(GncObject *subObj) {
if (pMain->xmldebug) tqDebug ("TemplateSplit end subel");
m_kvpList.append (subObj);
m_dataPtr = 0;
return ;
}
//************* GncSchedule********************************************
GncSchedule::GncSchedule () {
m_subElementListCount = END_Schedule_SELS;
static const TQString subEls[] = {"sx:start", "sx:last", "sx:end", "gnc:freqspec", "gnc:recurrence","sx:deferredInstance"};
m_subElementList = subEls;
m_dataElementListCount = END_Schedule_DELS;
static const TQString dataEls[] = {"sx:name", "sx:enabled", "sx:autoCreate", "sx:autoCreateNotify",
"sx:autoCreateDays", "sx:advanceCreateDays", "sx:advanceRemindDays",
"sx:instanceCount", "sx:num-occur",
"sx:rem-occur", "sx:templ-acct"};
m_dataElementList = dataEls;
static const unsigned int anonClasses[] = {NXTSCHD, ASIS, ASIS, ASIS, ASIS, ASIS, ASIS, ASIS, ASIS, ASIS, ASIS};
m_anonClassList = anonClasses;
for (uint i = 0; i < m_dataElementListCount; i++) m_v.append (new TQString (""));
m_vpStartDate = m_vpLastDate = m_vpEndDate = NULL;
m_vpFreqSpec = NULL;
m_vpRecurrence.clear();
m_vpRecurrence.setAutoDelete(true);
m_vpSchedDef = NULL;
}
GncSchedule::~GncSchedule () {
delete m_vpStartDate; delete m_vpLastDate; delete m_vpEndDate; delete m_vpFreqSpec; delete m_vpSchedDef;
}
GncObject *GncSchedule::startSubEl() {
if (pMain->xmldebug) tqDebug ("Schedule start subel m_state %d", m_state);
TRY
GncObject *next = 0;
switch (m_state) {
case STARTDATE:
case LASTDATE:
case ENDDATE: next = new GncDate; break;
case FREQ: next = new GncFreqSpec; break;
case RECURRENCE: next = new GncRecurrence; break;
case DEFINST: next = new GncSchedDef; break;
default: throw new MYMONEYEXCEPTION ("GncSchedule rcvd invalid m_state");
}
return (next);
PASS
}
void GncSchedule::endSubEl(GncObject *subObj) {
if (pMain->xmldebug) tqDebug ("Schedule end subel");
switch (m_state) {
case STARTDATE: m_vpStartDate = static_cast<GncDate *>(subObj); break;
case LASTDATE: m_vpLastDate = static_cast<GncDate *>(subObj); break;
case ENDDATE: m_vpEndDate = static_cast<GncDate *>(subObj); break;
case FREQ: m_vpFreqSpec = static_cast<GncFreqSpec *>(subObj); break;
case RECURRENCE: m_vpRecurrence.append(static_cast<GncRecurrence *>(subObj)); break;
case DEFINST: m_vpSchedDef = static_cast<GncSchedDef *>(subObj); break;
}
return ;
}
void GncSchedule::terminate() {
TRY
pMain->convertSchedule (this);
return ;
PASS
}
//************* GncFreqSpec********************************************
GncFreqSpec::GncFreqSpec () {
m_subElementListCount = END_FreqSpec_SELS;
static const TQString subEls[] = {"gnc:freqspec"};
m_subElementList = subEls;
m_dataElementListCount = END_FreqSpec_DELS;
static const TQString dataEls[] = {"fs:ui_type", "fs:monthly", "fs:daily", "fs:weekly", "fs:interval",
"fs:offset", "fs:day"};
m_dataElementList = dataEls;
static const unsigned int anonClasses[] = {ASIS, ASIS, ASIS, ASIS, ASIS, ASIS, ASIS };
m_anonClassList = anonClasses;
for (uint i = 0; i < m_dataElementListCount; i++) m_v.append (new TQString (""));
m_fsList.setAutoDelete (true);
}
GncFreqSpec::~GncFreqSpec () {}
GncObject *GncFreqSpec::startSubEl() {
TRY
if (pMain->xmldebug) tqDebug ("FreqSpec start subel m_state %d", m_state);
GncObject *next = 0;
switch (m_state) {
case COMPO: next = new GncFreqSpec; break;
default: throw new MYMONEYEXCEPTION ("GncFreqSpec rcvd invalid m_state");
}
return (next);
PASS
}
void GncFreqSpec::endSubEl(GncObject *subObj) {
if (pMain->xmldebug) tqDebug ("FreqSpec end subel");
switch (m_state) {
case COMPO: m_fsList.append (subObj); break;
}
m_dataPtr = 0;
return ;
}
void GncFreqSpec::terminate() {
pMain->convertFreqSpec (this);
return ;
}
//************* GncRecurrence********************************************
GncRecurrence::GncRecurrence () {
m_subElementListCount = END_Recurrence_SELS;
static const TQString subEls[] = {"recurrence:start"};
m_subElementList = subEls;
m_dataElementListCount = END_Recurrence_DELS;
static const TQString dataEls[] = {"recurrence:mult", "recurrence:period_type"};
m_dataElementList = dataEls;
static const unsigned int anonClasses[] = {ASIS, ASIS};
m_anonClassList = anonClasses;
for (uint i = 0; i < m_dataElementListCount; i++) m_v.append (new TQString (""));
}
GncRecurrence::~GncRecurrence () {
delete m_vpStartDate;
}
GncObject *GncRecurrence::startSubEl() {
TRY
if (pMain->xmldebug) tqDebug ("Recurrence start subel m_state %d", m_state);
GncObject *next = 0;
switch (m_state) {
case STARTDATE: next = new GncDate; break;
default: throw new MYMONEYEXCEPTION ("GncRecurrence rcvd invalid m_state");
}
return (next);
PASS
}
void GncRecurrence::endSubEl(GncObject *subObj) {
if (pMain->xmldebug) tqDebug ("Recurrence end subel");
switch (m_state) {
case STARTDATE: m_vpStartDate = static_cast<GncDate *>(subObj); break;
}
m_dataPtr = 0;
return ;
}
void GncRecurrence::terminate() {
pMain->convertRecurrence (this);
return ;
}
TQString GncRecurrence::getFrequency() const {
// This function converts a gnucash 2.2 recurrence specification into it's previous equivalent
// This will all need re-writing when MTE finishes the schedule re-write
if (periodType() == "once") return("once");
if ((periodType() == "day") and (mult() == "1")) return("daily");
if (periodType() == "week") {
if (mult() == "1") return ("weekly");
if (mult() == "2") return ("bi_weekly");
if (mult() == "4") return ("four-weekly");
}
if (periodType() == "month") {
if (mult() == "1") return ("monthly");
if (mult() == "2") return ("two-monthly");
if (mult() == "3") return ("quarterly");
if (mult() == "4") return ("tri_annually");
if (mult() == "6") return ("semi_yearly");
if (mult() == "12") return ("yearly");
if (mult() == "24") return ("two-yearly");
}
return ("unknown");
}
//************* GncSchedDef********************************************
GncSchedDef::GncSchedDef () {
// process ing for this sub-object is undefined at the present time
m_subElementListCount = 0;
m_dataElementListCount = 0;
}
GncSchedDef::~GncSchedDef () {}
/************************************************************************************************
XML Reader
************************************************************************************************/
void XmlReader::processFile (TQIODevice* pDevice) {
m_source = new TQXmlInputSource (pDevice); // set up the TQt XML reader
m_reader = new TQXmlSimpleReader;
m_reader->setContentHandler (this);
// go read the file
if (!m_reader->parse (m_source)) {
throw new MYMONEYEXCEPTION (i18n("Input file cannot be parsed; may be corrupt\n%s", errorString().latin1()));
}
delete m_reader;
delete m_source;
return ;
}
// XML handling routines
bool XmlReader::startDocument() {
m_os.setAutoDelete (true);
m_co = new GncFile; // create initial object, push to stack , pass it the 'main' pointer
m_os.push (m_co);
m_co->setPm (pMain);
m_headerFound = false;
#ifdef _GNCFILEANON
pMain->oStream << "<?xml version=\"1.0\"?>";
lastType = -1;
indentCount = 0;
#endif // _GNCFILEANON
return (true);
}
bool XmlReader::startElement (const TQString&, const TQString&, const TQString& elName ,
const TQXmlAttributes& elAttrs) {
try {
if (pMain->gncdebug) tqDebug ("XML start - %s", elName.latin1());
#ifdef _GNCFILEANON
int i;
TQString spaces;
// anonymizer - write data
if (elName == "gnc:book" || elName == "gnc:count-data" || elName == "book:id") lastType = -1;
pMain->oStream << endl;
switch (lastType) {
case 0:
indentCount += 2;
// tricky fall through here
case 2:
spaces.fill (' ', indentCount);
pMain->oStream << spaces.latin1();
break;
}
pMain->oStream << '<' << elName;
for (i = 0; i < elAttrs.count(); i++) {
pMain->oStream << ' ' << elAttrs.qName(i) << '=' << '"' << elAttrs.value(i) << '"';
}
pMain->oStream << '>';
lastType = 0;
#else
if ((!m_headerFound) && (elName != "gnc-v2"))
throw new MYMONEYEXCEPTION (i18n("Invalid header for file. Should be 'gnc-v2'"));
m_headerFound = true;
#endif // _GNCFILEANON
m_co->checkVersion (elName, elAttrs, pMain->m_versionList);
// check if this is a sub object element; if so, push stack and initialize
GncObject *temp = m_co->isSubElement (elName, elAttrs);
if (temp != 0) {
m_os.push (temp);
m_co = m_os.top();
m_co->setVersion(elAttrs.value("version"));
m_co->setPm (pMain); // pass the 'main' pointer to the sub object
// return true; // removed, as we hit a return true anyway
}
#if 0
// check for a data element
if (m_co->isDataElement (elName, elAttrs))
return (true);
#endif
else {
// reduced the above to
m_co->isDataElement(elName, elAttrs);
}
} catch (MyMoneyException *e) {
#ifndef _GNCFILEANON
// we can't pass on exceptions here coz the XML reader won't catch them and we just abort
KMessageBox::error(0, i18n("Import failed:\n\n%1").arg(e->what()), PACKAGE);
tqFatal ("%s", e->what().latin1());
#else
tqFatal ("%s", e->latin1());
#endif // _GNCFILEANON
}
return true; // to keep compiler happy
}
bool XmlReader::endElement( const TQString&, const TQString&, const TQString&elName ) {
try {
if (pMain->xmldebug) tqDebug ("XML end - %s", elName.latin1());
#ifdef _GNCFILEANON
TQString spaces;
switch (lastType) {
case 2:
indentCount -= 2; spaces.fill (' ', indentCount); pMain->oStream << endl << spaces.latin1(); break;
}
pMain->oStream << "</" << elName << '>' ;
lastType = 2;
#endif // _GNCFILEANON
m_co->resetDataPtr(); // so we don't get extraneous data loaded into the variables
if (elName == m_co->getElName()) { // check if this is the end of the current object
if (pMain->gncdebug) m_co->debugDump(); // dump the object data (temp)
// call the terminate routine, pop the stack, and advise the parent that it's done
m_co->terminate();
GncObject *temp = m_co;
m_os.pop();
m_co = m_os.top();
m_co->endSubEl (temp);
}
return (true);
} catch (MyMoneyException *e) {
#ifndef _GNCFILEANON
// we can't pass on exceptions here coz the XML reader won't catch them and we just abort
KMessageBox::error(0, i18n("Import failed:\n\n%1").arg(e->what()), PACKAGE);
tqFatal ("%s", e->what().latin1());
#else
tqFatal ("%s", e->latin1());
#endif // _GNCFILEANON
}
return (true); // to keep compiler happy
}
bool XmlReader::characters (const TQString &data) {
if (pMain->xmldebug) tqDebug ("XML Data received - %d bytes", data.length());
TQString pData = data.stripWhiteSpace(); // data may contain line feeds and indentation spaces
if (!pData.isEmpty()) {
if (pMain->developerDebug) tqDebug ("XML Data - %s", pData.latin1());
m_co->storeData (pData); //go store it
#ifdef _GNCFILEANON
TQString anonData = m_co->getData ();
if (anonData.isEmpty()) anonData = pData;
// there must be a TQt standard way of doing the following but I can't ... find it
anonData.replace ('<', "&lt;");
anonData.replace ('>', "&gt;");
anonData.replace ('&', "&amp;");
pMain->oStream << anonData; // write original data
lastType = 1;
#endif // _GNCFILEANON
}
return (true);
}
bool XmlReader::endDocument() {
#ifdef _GNCFILEANON
pMain->oStream << endl << endl;
pMain->oStream << "<!-- Local variables: -->" << endl;
pMain->oStream << "<!-- mode: xml -->" << endl;
pMain->oStream << "<!-- End: -->" << endl;
#endif // _GNCFILEANON
return (true);
}
/*******************************************************************************************
Main class for this module
Controls overall operation of the importer
********************************************************************************************/
//***************** Constructor ***********************
MyMoneyGncReader::MyMoneyGncReader() {
#ifndef _GNCFILEANON
m_storage = NULL;
m_messageList.setAutoDelete (true);
m_templateList.setAutoDelete (true);
#endif // _GNCFILEANON
// to hold gnucash count data (only used for progress bar)
m_gncCommodityCount = m_gncAccountCount = m_gncTransactionCount = m_gncScheduleCount = 0;
m_smallBusinessFound = m_budgetsFound = m_lotsFound = false;
m_commodityCount = m_priceCount = m_accountCount = m_transactionCount = m_templateCount = m_scheduleCount = 0;
m_decoder = 0;
// build a list of valid versions
static const TQString versionList[] = {"gnc:book 2.0.0", "gnc:commodity 2.0.0", "gnc:pricedb 1",
"gnc:account 2.0.0", "gnc:transaction 2.0.0", "gnc:schedxaction 1.0.0",
"gnc:schedxaction 2.0.0", // for gnucash 2.2 onward
"gnc:freqspec 1.0.0", "zzz" // zzz = stopper
};
unsigned int i;
for (i = 0; versionList[i] != "zzz"; ++i)
m_versionList[versionList[i].section (' ', 0, 0)].append(versionList[i].section (' ', 1, 1));
}
//***************** Destructor *************************
MyMoneyGncReader::~MyMoneyGncReader() {}
//**************************** Main Entry Point ************************************
#ifndef _GNCFILEANON
void MyMoneyGncReader::readFile(TQIODevice* pDevice, IMyMoneySerialize* storage) {
TQ_CHECK_PTR (pDevice);
TQ_CHECK_PTR (storage);
m_storage = dynamic_cast<IMyMoneyStorage *>(storage);
tqDebug ("Entering gnucash importer");
setOptions ();
// get a file anonymization factor from the user
if (bAnonymize) setFileHideFactor ();
//m_defaultPayee = createPayee (i18n("Unknown payee"));
MyMoneyFileTransaction ft;
m_xr = new XmlReader (this);
try {
m_xr->processFile (pDevice);
terminate (); // do all the wind-up things
ft.commit();
} catch (MyMoneyException *e) {
KMessageBox::error(0, i18n("Import failed:\n\n%1").arg(e->what()), PACKAGE);
tqFatal ("%s", e->what().latin1());
} // end catch
signalProgress (0, 1, i18n("Import complete")); // switch off progress bar
delete m_xr;
tqDebug ("Exiting gnucash importer");
return ;
}
#else
// Control code for the file anonymizer
void MyMoneyGncReader::readFile(TQString in, TQString out) {
TQFile pDevice (in);
if (!pDevice.open (IO_ReadOnly)) tqFatal ("Can't open input file");
TQFile outFile (out);
if (!outFile.open (IO_WriteOnly)) tqFatal ("Can't open output file");
oStream.setDevice (&outFile);
bAnonymize = true;
// get a file anonymization factor from the user
setFileHideFactor ();
m_xr = new XmlReader (this);
try {
m_xr->processFile (&pDevice);
} catch (MyMoneyException *e) {
tqFatal ("%s", e->latin1());
} // end catch
delete m_xr;
pDevice.close();
outFile.close();
return ;
}
#include <tqapplication.h>
int main (int argc, char ** argv) {
TQApplication a (argc, argv);
MyMoneyGncReader m;
TQString inFile, outFile;
if (argc > 0) inFile = a.argv()[1];
if (argc > 1) outFile = a.argv()[2];
if (inFile.isEmpty()) {
inFile = TQFileDialog::getOpenFileName("",
"Gnucash files(*.nc *)",
0);
}
if (inFile.isEmpty()) tqFatal ("Input file required");
if (outFile.isEmpty()) outFile = inFile + ".anon";
m.readFile (inFile, outFile);
exit (0);
}
#endif // _GNCFILEANON
void MyMoneyGncReader::setFileHideFactor () {
#define MINFILEHIDEF 0.01
#define MAXFILEHIDEF 99.99
srand (TQTime::currentTime().second()); // seed randomizer for anonymize
m_fileHideFactor = 0.0;
while (m_fileHideFactor == 0.0) {
m_fileHideFactor = TQInputDialog::getDouble (
i18n ("Disguise your wealth"),
i18n ("Each monetary value on your file will be multiplied by a random number between 0.01 and 1.99\n"
"with a different value used for each transaction. In addition, to further disguise the true\n"
"values, you may enter a number between %1 and %2 which will be applied to all values.\n"
"These numbers will not be stored in the file.").arg(MINFILEHIDEF).arg(MAXFILEHIDEF),
(1.0 + (int)(1000.0 * rand() / (RAND_MAX + 1.0))) / 100.0,
MINFILEHIDEF, MAXFILEHIDEF, 2);
}
}
#ifndef _GNCFILEANON
//********************************* convertCommodity *******************************************
void MyMoneyGncReader::convertCommodity (const GncCommodity *gcm) {
TQ_CHECK_PTR (gcm);
MyMoneySecurity equ;
if (m_commodityCount == 0) signalProgress (0, m_gncCommodityCount, i18n("Loading commodities..."));
if (!gcm->isCurrency()) { // currencies should not be present here but...
equ.setName (gcm->name());
equ.setTradingSymbol (gcm->id());
equ.setTradingMarket (gcm->space()); // the 'space' may be market or quote source, dep on what the user did
// don't set the source here since he may not want quotes
//equ.setValue ("kmm-online-source", gcm->space()); // we don't know, so use it as both
equ.setTradingCurrency (""); // not available here, will set from pricedb or transaction
equ.setSecurityType (MyMoneySecurity::SECURITY_STOCK); // default to it being a stock
//tell the storage objects we have a new equity object.
equ.setSmallestAccountFraction(gcm->fraction().toInt());
m_storage->addSecurity(equ);
//assign the gnucash id as the key into the map to find our id
if (gncdebug) tqDebug ("mapping, key = %s, id = %s", gcm->id().latin1(), equ.id().data());
m_mapEquities[gcm->id().utf8()] = equ.id();
}
signalProgress (++m_commodityCount, 0);
return ;
}
//******************************* convertPrice ************************************************
void MyMoneyGncReader::convertPrice (const GncPrice *gpr) {
TQ_CHECK_PTR (gpr);
// add this to our price history
if (m_priceCount == 0) signalProgress (0, 1, i18n("Loading prices..."));
MyMoneyMoney rate = convBadValue (gpr->value());
if (gpr->commodity()->isCurrency()) {
MyMoneyPrice exchangeRate (gpr->commodity()->id().utf8(), gpr->currency()->id().utf8(),
gpr->priceDate(), rate, i18n("Imported History"));
m_storage->addPrice (exchangeRate);
} else {
MyMoneySecurity e = m_storage->security(m_mapEquities[gpr->commodity()->id().utf8()]);
if (gncdebug) tqDebug ("Searching map, key = %s, found id = %s",
gpr->commodity()->id().latin1(), e.id().data());
e.setTradingCurrency (gpr->currency()->id().utf8());
MyMoneyPrice stockPrice(e.id(), gpr->currency()->id().utf8(), gpr->priceDate(), rate, i18n("Imported History"));
m_storage->addPrice (stockPrice);
m_storage->modifySecurity(e);
}
signalProgress (++m_priceCount, 0);
return ;
}
//*********************************convertAccount ****************************************
void MyMoneyGncReader::convertAccount (const GncAccount* gac) {
TQ_CHECK_PTR (gac);
TRY
// we don't care about the GNC root account
if("ROOT" == gac->type()) {
m_rootId = gac->id().utf8();
return;
}
MyMoneyAccount acc;
if (m_accountCount == 0) signalProgress (0, m_gncAccountCount, i18n("Loading accounts..."));
acc.setName(gac->name());
acc.setDescription(gac->desc());
TQDate currentDate = TQDate::currentDate();
acc.setOpeningDate(currentDate);
acc.setLastModified(currentDate);
acc.setLastReconciliationDate(currentDate);
if (gac->commodity()->isCurrency()) {
acc.setCurrencyId (gac->commodity()->id().utf8());
m_currencyCount[gac->commodity()->id()]++;
}
acc.setParentAccountId (gac->parent().utf8());
// now determine the account type and its parent id
/* This list taken from
# Feb 2006: A RELAX NG Compact schema for gnucash "v2" XML files.
# Copyright (C) 2006 Joshua Sled <jsled@asynchronous.org>
"NO_TYPE" "BANK" "CASH" "CREDIT" "ASSET" "LIABILITY" "STOCK" "MUTUAL" "CURRENCY"
"INCOME" "EXPENSE" "EQUITY" "RECEIVABLE" "PAYABLE" "CHECKING" "SAVINGS" "MONEYMRKT" "CREDITLINE"
Some don't seem to be used in practice. Not sure what CREDITLINE s/be converted as.
*/
if ("BANK" == gac->type() || "CHECKING" == gac->type()) {
acc.setAccountType(MyMoneyAccount::Checkings);
} else if ("SAVINGS" == gac->type()) {
acc.setAccountType(MyMoneyAccount::Savings);
} else if ("ASSET" == gac->type()) {
acc.setAccountType(MyMoneyAccount::Asset);
} else if ("CASH" == gac->type()) {
acc.setAccountType(MyMoneyAccount::Cash);
} else if ("CURRENCY" == gac->type()) {
acc.setAccountType(MyMoneyAccount::Cash);
} else if ("STOCK" == gac->type() || "MUTUAL" == gac->type() ) {
// gnucash allows a 'broker' account to be denominated as type STOCK, but with
// a currency balance. We do not need to create a stock account for this
// actually, the latest version of gnc (1.8.8) doesn't seem to allow you to do
// this any more, though I do have one in my own account...
if (gac->commodity()->isCurrency()) {
acc.setAccountType(MyMoneyAccount::Investment);
} else {
acc.setAccountType(MyMoneyAccount::Stock);
}
} else if ("EQUITY" == gac->type()) {
acc.setAccountType(MyMoneyAccount::Equity);
} else if ("LIABILITY" == gac->type()) {
acc.setAccountType(MyMoneyAccount::Liability);
} else if ("CREDIT" == gac->type()) {
acc.setAccountType(MyMoneyAccount::CreditCard);
} else if ("INCOME" == gac->type()) {
acc.setAccountType(MyMoneyAccount::Income);
} else if ("EXPENSE" == gac->type()) {
acc.setAccountType(MyMoneyAccount::Expense);
} else if ("RECEIVABLE" == gac->type()) {
acc.setAccountType(MyMoneyAccount::Asset);
} else if ("PAYABLE" == gac->type()) {
acc.setAccountType(MyMoneyAccount::Liability);
} else if ("MONEYMRKT" == gac->type()) {
acc.setAccountType(MyMoneyAccount::MoneyMarket);
} else { // we have here an account type we can't currently handle
TQString em =
i18n("Current importer does not recognize GnuCash account type %1").arg(gac->type());
throw new MYMONEYEXCEPTION (em);
}
// if no parent account is present, assign to one of our standard accounts
if ((acc.parentAccountId().isEmpty()) || (acc.parentAccountId() == m_rootId)) {
switch (acc.accountGroup()) {
case MyMoneyAccount::Asset: acc.setParentAccountId (m_storage->asset().id()); break;
case MyMoneyAccount::Liability: acc.setParentAccountId (m_storage->liability().id()); break;
case MyMoneyAccount::Income: acc.setParentAccountId (m_storage->income().id()); break;
case MyMoneyAccount::Expense: acc.setParentAccountId (m_storage->expense().id()); break;
case MyMoneyAccount::Equity: acc.setParentAccountId (m_storage->equity().id()); break;
default: break; // not necessary but avoids compiler warnings
}
}
// extra processing for a stock account
if (acc.accountType() == MyMoneyAccount::Stock) {
// save the id for later linking to investment account
m_stockList.append (gac->id());
// set the equity type
MyMoneySecurity e = m_storage->security (m_mapEquities[gac->commodity()->id().utf8()]);
if (gncdebug) tqDebug ("Acct equity search, key = %s, found id = %s",
gac->commodity()->id().latin1(), e.id().data());
acc.setCurrencyId (e.id()); // actually, the security id
if ("MUTUAL" == gac->type()) {
e.setSecurityType (MyMoneySecurity::SECURITY_MUTUALFUND);
if (gncdebug) tqDebug ("Setting %s to mutual", e.name().latin1());
m_storage->modifySecurity (e);
}
// See if he wants online quotes for this account
// NB: In gnc, this selection is per account, in KMM, per security
// This is unlikely to cause problems in practice. If it does,
// we probably need to introduce a 'pricing basis' in the account class
TQPtrListIterator<GncObject> kvpi (gac->m_kvpList);
GncKvp *k;
while ((k = static_cast<GncKvp *>(kvpi.current())) != 0) {
if (k->key().contains("price-source") && k->type() == "string") {
getPriceSource (e, k->value());
break;
} else {
++kvpi;
}
}
}
// check for tax-related status
TQPtrListIterator<GncObject> kvpi (gac->m_kvpList);
GncKvp *k;
while ((k = static_cast<GncKvp *>(kvpi.current())) != 0) {
if (k->key().contains("tax-related") && k->type() == "integer" && k->value() == "1") {
acc.setValue ("Tax", "Yes");
break;
} else {
++kvpi;
}
}
// all the details from the file about the account should be known by now.
// calling addAccount will automatically fill in the account ID.
m_storage->addAccount(acc);
m_mapIds[gac->id().utf8()] = acc.id(); // to link gnucash id to ours for tx posting
if (gncdebug) tqDebug("Gnucash account %s has id of %s, type of %s, parent is %s",
gac->id().latin1(), acc.id().data(),
KMyMoneyUtils::accountTypeToString(acc.accountType()).latin1(), acc.parentAccountId().data());
signalProgress (++m_accountCount, 0);
return ;
PASS
}
//********************************************** convertTransaction *****************************
void MyMoneyGncReader::convertTransaction (const GncTransaction *gtx) {
TQ_CHECK_PTR (gtx);
MyMoneyTransaction tx;
MyMoneySplit split;
unsigned int i;
if (m_transactionCount == 0) signalProgress (0, m_gncTransactionCount, i18n("Loading transactions..."));
// initialize class variables related to transactions
m_txCommodity = "";
m_txPayeeId = "";
m_potentialTransfer = true;
m_splitList.clear(); m_liabilitySplitList.clear(); m_otherSplitList.clear();
// payee, dates, commodity
if (!gtx->desc().isEmpty()) m_txPayeeId = createPayee (gtx->desc());
tx.setEntryDate (gtx->dateEntered());
tx.setPostDate (gtx->datePosted());
m_txDatePosted = tx.postDate(); // save for use in splits
m_txChequeNo = gtx->no(); // ditto
tx.setCommodity (gtx->currency().utf8());
m_txCommodity = tx.commodity(); // save in storage, maybe needed for Orphan accounts
// process splits
for (i = 0; i < gtx->splitCount(); i++) {
convertSplit (static_cast<const GncSplit *>(gtx->getSplit (i)));
}
// handle the odd case of just one split, which gnc allows,
// by just duplicating the split
// of course, we should change the sign but this case has only ever been seen
// when the balance is zero, and can cause kmm to crash, so...
if (gtx->splitCount() == 1) {
convertSplit (static_cast<const GncSplit *>(gtx->getSplit (0)));
}
m_splitList += m_liabilitySplitList += m_otherSplitList;
// the splits are in order in splitList. Link them to the tx. also, determine the
// action type, and fill in some fields which gnc holds at transaction level
// first off, is it a transfer (can only have 2 splits?)
// also, a tx with just 2 splits is shown by GnuCash as non-split
bool nonSplitTx = true;
if (m_splitList.count() != 2) {
m_potentialTransfer = false;
nonSplitTx = false;
}
for (i = 0; i < gtx->kvpCount(); i++ ) {
const GncKvp *slot = gtx->getKvp(i);
if (slot->key() == "notes") tx.setMemo(slot->value());
}
TQValueList<MyMoneySplit>::iterator it = m_splitList.begin();
while (!m_splitList.isEmpty()) {
split = *it;
// at this point, if m_potentialTransfer is still true, it is actually one!
if (m_potentialTransfer) split.setAction(MyMoneySplit::ActionTransfer);
if ((m_useTxNotes) // if use txnotes option is set
&& (nonSplitTx) // and it's a (GnuCash) non-split transaction
&& (!tx.memo().isEmpty())) // and tx notes are present
split.setMemo(tx.memo()); // use the tx notes as memo
tx.addSplit(split);
it = m_splitList.remove(it);
}
// memo - set from split - not any more
//tx.setMemo(txMemo);
m_storage->addTransaction(tx, true); // all done, add the transaction to storage
signalProgress (++m_transactionCount, 0);
return ;
}
//******************************************convertSplit********************************
void MyMoneyGncReader::convertSplit (const GncSplit *gsp) {
TQ_CHECK_PTR (gsp);
MyMoneySplit split;
MyMoneyAccount splitAccount;
// find the kmm account id coresponding to the gnc id
TQString kmmAccountId;
map_accountIds::Iterator id = m_mapIds.find(gsp->acct().utf8());
if (id != m_mapIds.end()) {
kmmAccountId = id.data();
} else { // for the case where the acs not found (which shouldn't happen?), create an account with gnc name
kmmAccountId = createOrphanAccount (gsp->acct());
}
// find the account pointer and save for later
splitAccount = m_storage->account (kmmAccountId);
// print some data so we can maybe identify this split later
// TODO : prints personal data
//if (gncdebug) tqDebug ("Split data - gncid %s, kmmid %s, memo %s, value %s, recon state %s",
// gsp->acct().latin1(), kmmAccountId.data(), gsp->memo().latin1(), gsp->value().latin1(),
// gsp->recon().latin1());
// payee id
split.setPayeeId (m_txPayeeId.utf8());
// reconciled state and date
switch (gsp->recon().at(0).latin1()) {
case 'n':
split.setReconcileFlag(MyMoneySplit::NotReconciled); break;
case 'c':
split.setReconcileFlag(MyMoneySplit::Cleared); break;
case 'y':
split.setReconcileFlag(MyMoneySplit::Reconciled); break;
}
split.setReconcileDate(gsp->reconDate());
// memo
split.setMemo(gsp->memo());
// accountId
split.setAccountId (kmmAccountId);
// cheque no
split.setNumber (m_txChequeNo);
// value and quantity
MyMoneyMoney splitValue (convBadValue (gsp->value()));
if (gsp->value() == "-1/0") { // treat gnc invalid value as zero
// it's not quite a consistency check, but easier to treat it as such
postMessage ("CC", 4, splitAccount.name().latin1(), TQString(m_txDatePosted.toString(Qt::ISODate)).latin1());
}
MyMoneyMoney splitQuantity(convBadValue(gsp->qty()));
split.setValue (splitValue);
// if split currency = tx currency, set shares = value (14/10/05)
if (splitAccount.currencyId() == m_txCommodity) {
split.setShares (splitValue);
} else {
split.setShares (splitQuantity);
}
// in kmm, the first split is important. in this routine we will
// save the splits in our split list with the priority:
// 1. assets
// 2. liabilities
// 3. others (categories)
// but keeping each in same order as gnucash
MyMoneySecurity e;
MyMoneyMoney price, newPrice(0);
switch (splitAccount.accountGroup()) {
case MyMoneyAccount::Asset:
if (splitAccount.accountType() == MyMoneyAccount::Stock) {
split.value() == MyMoneyMoney(0) ?
split.setAction (MyMoneySplit::ActionAddShares) : // free shares?
split.setAction (MyMoneySplit::ActionBuyShares);
m_potentialTransfer = false; // ?
// add a price history entry
e = m_storage->security(splitAccount.currencyId());
// newPrice fix supplied by Phil Longstaff
price = split.value() / split.shares();
#define NEW_DENOM 10000
if (!split.shares().isZero()) // patch to fix divide by zero?
newPrice = MyMoneyMoney ( price.toDouble(), (signed64)NEW_DENOM );
if (!newPrice.isZero()) {
TRY
// we can't use m_storage->security coz security list is not built yet
m_storage->currency(m_txCommodity); // will throw exception if not currency
e.setTradingCurrency (m_txCommodity);
if (gncdebug) tqDebug ("added price for %s, %s date %s",
e.name().latin1(), newPrice.toString().latin1(),
TQString(m_txDatePosted.toString(Qt::ISODate)).latin1());
m_storage->modifySecurity(e);
MyMoneyPrice dealPrice (e.id(), m_txCommodity, m_txDatePosted, newPrice, i18n("Imported Transaction"));
m_storage->addPrice (dealPrice);
CATCH // stock transfer; treat like free shares?
split.setAction (MyMoneySplit::ActionAddShares);
delete e;
}
}
} else { // not stock
if (split.value().isNegative()) {
bool isNumeric = false;
if (!split.number().isEmpty()) {
split.number().toLong(&isNumeric); // No TQString.isNumeric()??
}
if (isNumeric) {
split.setAction (MyMoneySplit::ActionCheck);
} else {
split.setAction (MyMoneySplit::ActionWithdrawal);
}
} else {
split.setAction (MyMoneySplit::ActionDeposit);
}
}
m_splitList.append(split);
break;
case MyMoneyAccount::Liability:
split.value().isNegative() ?
split.setAction (MyMoneySplit::ActionWithdrawal) :
split.setAction (MyMoneySplit::ActionDeposit);
m_liabilitySplitList.append(split);
break;
default:
m_potentialTransfer = false;
m_otherSplitList.append (split);
}
// backdate the account opening date if necessary
if (m_txDatePosted < splitAccount.openingDate()) {
splitAccount.setOpeningDate(m_txDatePosted);
m_storage->modifyAccount(splitAccount);
}
return ;
}
//********************************* convertTemplateTransaction **********************************************
MyMoneyTransaction MyMoneyGncReader::convertTemplateTransaction (const TQString& schedName, const GncTransaction *gtx) {
TQ_CHECK_PTR (gtx);
MyMoneyTransaction tx;
MyMoneySplit split;
unsigned int i;
if (m_templateCount == 0) signalProgress (0, 1, i18n("Loading templates..."));
// initialize class variables related to transactions
m_txCommodity = "";
m_txPayeeId = "";
m_potentialTransfer = true;
m_splitList.clear(); m_liabilitySplitList.clear(); m_otherSplitList.clear();
// payee, dates, commodity
if (!gtx->desc().isEmpty()) {
m_txPayeeId = createPayee (gtx->desc());
} else {
m_txPayeeId = createPayee (i18n("Unknown payee")); // schedules require a payee tho normal tx's don't. not sure why...
}
tx.setEntryDate(gtx->dateEntered());
tx.setPostDate(gtx->datePosted());
m_txDatePosted = tx.postDate();
tx.setCommodity (gtx->currency().utf8());
m_txCommodity = tx.commodity(); // save for possible use in orphan account
// process splits
for (i = 0; i < gtx->splitCount(); i++) {
convertTemplateSplit (schedName, static_cast<const GncTemplateSplit *>(gtx->getSplit (i)));
}
// determine the action type for the splits and link them to the template tx
/*TQString negativeActionType, positiveActionType;
if (!m_splitList.isEmpty()) { // if there are asset splits
positiveActionType = MyMoneySplit::ActionDeposit;
negativeActionType = MyMoneySplit::ActionWithdrawal;
} else { // if there are liability splits
positiveActionType = MyMoneySplit::ActionWithdrawal;
negativeActionType = MyMoneySplit::ActionDeposit;
} */
if (!m_otherSplitList.isEmpty()) m_potentialTransfer = false; // tfrs can occur only between assets and asset/liabilities
m_splitList += m_liabilitySplitList += m_otherSplitList;
// the splits are in order in splitList. Transfer them to the tx
// also, determine the action type. first off, is it a transfer (can only have 2 splits?)
if (m_splitList.count() != 2) m_potentialTransfer = false;
// at this point, if m_potentialTransfer is still true, it is actually one!
TQString txMemo = "";
TQValueList<MyMoneySplit>::iterator it = m_splitList.begin();
while (!m_splitList.isEmpty()) {
split = *it;
if (m_potentialTransfer) {
split.setAction(MyMoneySplit::ActionTransfer);
} else {
if (split.value().isNegative()) {
//split.setAction (negativeActionType);
split.setAction (MyMoneySplit::ActionWithdrawal);
} else {
//split.setAction (positiveActionType);
split.setAction (MyMoneySplit::ActionDeposit);
}
}
split.setNumber(gtx->no()); // set cheque no (or equivalent description)
// Arbitrarily, save the first non-null split memo as the memo for the whole tx
// I think this is necessary because txs with just 2 splits (the majority)
// are not viewable as split transactions in kmm so the split memo is not seen
if ((txMemo.isEmpty()) && (!split.memo().isEmpty())) txMemo = split.memo();
tx.addSplit(split);
it = m_splitList.remove(it);
}
// memo - set from split
tx.setMemo (txMemo);
signalProgress (++m_templateCount, 0);
return (tx);
}
//********************************* convertTemplateSplit ****************************************************
void MyMoneyGncReader::convertTemplateSplit (const TQString& schedName, const GncTemplateSplit *gsp) {
TQ_CHECK_PTR (gsp);
// convertTemplateSplit
MyMoneySplit split;
MyMoneyAccount splitAccount;
unsigned int i, j;
bool nonNumericFormula = false;
// action, value and account will be set from slots
// reconcile state, always Not since it hasn't even been posted yet (?)
split.setReconcileFlag(MyMoneySplit::NotReconciled);
// memo
split.setMemo(gsp->memo());
// payee id
split.setPayeeId (m_txPayeeId.utf8());
// read split slots (KVPs)
int xactionCount = 0;
int validSlotCount = 0;
TQString gncAccountId;
for (i = 0; i < gsp->kvpCount(); i++ ) {
const GncKvp *slot = gsp->getKvp(i);
if ((slot->key() == "sched-xaction") && (slot->type() == "frame")) {
bool bFoundStringCreditFormula = false;
bool bFoundStringDebitFormula = false;
bool bFoundGuidAccountId = false;
TQString gncCreditFormula, gncDebitFormula;
for (j = 0; j < slot->kvpCount(); j++) {
const GncKvp *subSlot = slot->getKvp (j);
// again, see comments above. when we have a full specification
// of all the options available to us, we can no doubt improve on this
if ((subSlot->key() == "credit-formula") && (subSlot->type() == "string")) {
gncCreditFormula = subSlot->value();
bFoundStringCreditFormula = true;
}
if ((subSlot->key() == "debit-formula") && (subSlot->type() == "string")) {
gncDebitFormula = subSlot->value();
bFoundStringDebitFormula = true;
}
if ((subSlot->key() == "account") && (subSlot->type() == "guid")) {
gncAccountId = subSlot->value();
bFoundGuidAccountId = true;
}
}
// all data read, now check we have everything
if ((bFoundStringCreditFormula) && (bFoundStringDebitFormula) && (bFoundGuidAccountId)) {
if (gncdebug) tqDebug ("Found valid slot; credit %s, debit %s, acct %s",
gncCreditFormula.latin1(), gncDebitFormula.latin1(), gncAccountId.latin1());
validSlotCount++;
}
// validate numeric, work out sign
MyMoneyMoney exFormula (0);
exFormula.setNegativeMonetarySignPosition (MyMoneyMoney::BeforeQuantityMoney);
TQString numericTest;
char crdr=0 ;
if (!gncCreditFormula.isEmpty()) {
crdr = 'C';
numericTest = gncCreditFormula;
} else if (!gncDebitFormula.isEmpty()) {
crdr = 'D';
numericTest = gncDebitFormula;
}
kMyMoneyMoneyValidator v (0);
int pos; // useless, but required for validator
if (v.validate (numericTest, pos) == TQValidator::Acceptable) {
switch (crdr) {
case 'C':
exFormula = TQString ("-" + numericTest); break;
case 'D':
exFormula = numericTest;
}
} else {
if (gncdebug) tqDebug ("%s is not numeric", numericTest.latin1());
nonNumericFormula = true;
}
split.setValue (exFormula);
xactionCount++;
} else {
postMessage ("SC", 3, schedName.latin1(), slot->key().latin1(), slot->type().latin1());
m_suspectSchedule = true;
}
}
// report this as untranslatable tx
if (xactionCount > 1) {
postMessage ("SC", 4, schedName.latin1());
m_suspectSchedule = true;
}
if (validSlotCount == 0) {
postMessage ("SC", 5, schedName.latin1());
m_suspectSchedule = true;
}
if (nonNumericFormula) {
postMessage ("SC", 6, schedName.latin1());
m_suspectSchedule = true;
}
// find the kmm account id coresponding to the gnc id
TQString kmmAccountId;
map_accountIds::Iterator id = m_mapIds.find(gncAccountId.utf8());
if (id != m_mapIds.end()) {
kmmAccountId = id.data();
} else { // for the case where the acs not found (which shouldn't happen?), create an account with gnc name
kmmAccountId = createOrphanAccount (gncAccountId);
}
splitAccount = m_storage->account (kmmAccountId);
split.setAccountId (kmmAccountId);
// if split currency = tx currency, set shares = value (14/10/05)
if (splitAccount.currencyId() == m_txCommodity) {
split.setShares (split.value());
} /* else { //FIXME: scheduled currency or investment tx needs to be investigated
split.setShares (splitQuantity);
} */
// add the split to one of the lists
switch (splitAccount.accountGroup()) {
case MyMoneyAccount::Asset:
m_splitList.append (split); break;
case MyMoneyAccount::Liability:
m_liabilitySplitList.append (split); break;
default:
m_otherSplitList.append (split);
}
// backdate the account opening date if necessary
if (m_txDatePosted < splitAccount.openingDate()) {
splitAccount.setOpeningDate(m_txDatePosted);
m_storage->modifyAccount(splitAccount);
}
return ;
}
//********************************* convertSchedule ********************************************************
void MyMoneyGncReader::convertSchedule (const GncSchedule *gsc) {
TRY
TQ_CHECK_PTR (gsc);
MyMoneySchedule sc;
MyMoneyTransaction tx;
m_suspectSchedule = false;
TQDate startDate, nextDate, lastDate, endDate; // for date calculations
TQDate today = TQDate::currentDate();
int numOccurs, remOccurs;
if (m_scheduleCount == 0) signalProgress (0, m_gncScheduleCount, i18n("Loading schedules..."));
// schedule name
sc.setName(gsc->name());
// find the transaction template as stored earlier
TQPtrListIterator<GncTransaction> itt (m_templateList);
GncTransaction *ttx;
while ((ttx = itt.current()) != 0) {
// the id to match against is the split:account value in the splits
if (static_cast<const GncTemplateSplit *>(ttx->getSplit(0))->acct() == gsc->templId()) break;
++itt;
}
if (itt == 0) {
throw new MYMONEYEXCEPTION (i18n("Can't find template transaction for schedule %1").arg(sc.name()));
} else {
tx = convertTemplateTransaction (sc.name(), *itt);
}
tx.clearId();
// define the conversion table for intervals
struct convIntvl {
TQString gncType; // the gnucash name
unsigned char interval; // for date calculation
unsigned int intervalCount;
MyMoneySchedule::occurenceE occ; // equivalent occurence code
MyMoneySchedule::weekendOptionE wo;
};
/* other intervals supported by gnc according to Josh Sled's schema (see above)
"none" "semi_monthly"
*/
/* some of these type names do not appear in gnucash and are difficult to generate for
pre 2.2 files.They can be generated for 2.2 however, by GncRecurrence::getFrequency() */
static convIntvl vi [] = {
{"once", 'o', 1, MyMoneySchedule::OCCUR_ONCE, MyMoneySchedule::MoveNothing },
{"daily" , 'd', 1, MyMoneySchedule::OCCUR_DAILY, MyMoneySchedule::MoveNothing },
//{"daily_mf", 'd', 1, MyMoneySchedule::OCCUR_DAILY, MyMoneySchedule::MoveMonday }, doesn't work, need new freq in kmm
{"30-days" , 'd', 30, MyMoneySchedule::OCCUR_EVERYTHIRTYDAYS, MyMoneySchedule::MoveNothing },
{"weekly", 'w', 1, MyMoneySchedule::OCCUR_WEEKLY, MyMoneySchedule::MoveNothing },
{"bi_weekly", 'w', 2, MyMoneySchedule::OCCUR_EVERYOTHERWEEK, MyMoneySchedule::MoveNothing },
{"three-weekly", 'w', 3, MyMoneySchedule::OCCUR_EVERYTHREEWEEKS, MyMoneySchedule::MoveNothing },
{"four-weekly", 'w', 4, MyMoneySchedule::OCCUR_EVERYFOURWEEKS,
MyMoneySchedule::MoveNothing },
{"eight-weekly", 'w', 8, MyMoneySchedule::OCCUR_EVERYEIGHTWEEKS, MyMoneySchedule::MoveNothing },
{"monthly", 'm', 1, MyMoneySchedule::OCCUR_MONTHLY, MyMoneySchedule::MoveNothing },
{"two-monthly", 'm', 2, MyMoneySchedule::OCCUR_EVERYOTHERMONTH,
MyMoneySchedule::MoveNothing },
{"quarterly", 'm', 3, MyMoneySchedule::OCCUR_QUARTERLY, MyMoneySchedule::MoveNothing },
{"tri_annually", 'm', 4, MyMoneySchedule::OCCUR_EVERYFOURMONTHS, MyMoneySchedule::MoveNothing },
{"semi_yearly", 'm', 6, MyMoneySchedule::OCCUR_TWICEYEARLY, MyMoneySchedule::MoveNothing },
{"yearly", 'y', 1, MyMoneySchedule::OCCUR_YEARLY, MyMoneySchedule::MoveNothing },
{"two-yearly", 'y', 2, MyMoneySchedule::OCCUR_EVERYOTHERYEAR,
MyMoneySchedule::MoveNothing },
{"zzz", 'y', 1, MyMoneySchedule::OCCUR_YEARLY, MyMoneySchedule::MoveNothing}
// zzz = stopper, may cause problems. what else can we do?
};
TQString frequency = "unknown"; // set default to unknown frequency
bool unknownOccurs = false; // may have zero, or more than one frequency/recurrence spec
TQString schedEnabled;
if (gsc->version() == "2.0.0") {
if (gsc->m_vpRecurrence.count() != 1) {
unknownOccurs = true;
} else {
const GncRecurrence *gre = gsc->m_vpRecurrence.first();
//tqDebug (TQString("Sched %1, pt %2, mu %3, sd %4").arg(gsc->name()).arg(gre->periodType())
// .arg(gre->mult()).arg(gre->startDate().toString(Qt::ISODate)));
frequency = gre->getFrequency();
schedEnabled = gsc->enabled();
}
sc.setOccurence(MyMoneySchedule::OCCUR_ONCE); // FIXME - how to convert
} else {
// find this interval
const GncFreqSpec *fs = gsc->getFreqSpec();
if (fs == NULL) {
unknownOccurs = true;
} else {
frequency = fs->intervalType();
if (!fs->m_fsList.isEmpty()) unknownOccurs = true; // nested freqspec
}
schedEnabled = "y"; // earlier versions did not have an enable flag
}
int i;
for (i = 0; vi[i].gncType != "zzz"; i++) {
if (frequency == vi[i].gncType) break;
}
if (vi[i].gncType == "zzz") {
postMessage ("SC", 1, sc.name().latin1(), frequency.latin1());
i = 0; // treat as single occurrence
m_suspectSchedule = true;
}
if (unknownOccurs) {
postMessage ("SC", 7, sc.name().latin1());
m_suspectSchedule = true;
}
// set the occurrence interval, weekend option, start date
sc.setOccurence (vi[i].occ);
sc.setWeekendOption (vi[i].wo);
sc.setStartDate (gsc->startDate());
// if a last date was specified, use it, otherwise try to work out the last date
sc.setLastPayment(gsc->lastDate());
numOccurs = gsc->numOccurs().toInt();
if (sc.lastPayment() == TQDate()) {
nextDate = lastDate = gsc->startDate();
while ((nextDate < today) && (numOccurs-- != 0)) {
lastDate = nextDate;
nextDate = incrDate (lastDate, vi[i].interval, vi[i].intervalCount);
}
sc.setLastPayment(lastDate);
}
// under Tom's new regime, the tx dates are the next due date (I think)
tx.setPostDate(incrDate(sc.lastPayment(), vi[i].interval, vi[i].intervalCount));
tx.setEntryDate(incrDate(sc.lastPayment(), vi[i].interval, vi[i].intervalCount));
// if an end date was specified, use it, otherwise if the input file had a number
// of occurs remaining, work out the end date
sc.setEndDate(gsc->endDate());
numOccurs = gsc->numOccurs().toInt();
remOccurs = gsc->remOccurs().toInt();
if ((sc.endDate() == TQDate()) && (remOccurs > 0)) {
endDate = sc.lastPayment();
while (remOccurs-- > 0) {
endDate = incrDate (endDate, vi[i].interval, vi[i].intervalCount);
}
sc.setEndDate(endDate);
}
// Check for sched deferred interval. Don't know how/if we can handle it, or even what it means...
if (gsc->getSchedDef() != NULL) {
postMessage ("SC", 8, sc.name().latin1());
m_suspectSchedule = true;
}
// payment type, options
sc.setPaymentType((MyMoneySchedule::paymentTypeE)MyMoneySchedule::STYPE_OTHER);
sc.setFixed (!m_suspectSchedule); // if any probs were found, set it as variable so user will always be prompted
// we don't currently have a 'disable' option, but just make sure auto-enter is off if not enabled
//tqDebug(TQString("%1 and %2").arg(gsc->autoCreate()).arg(schedEnabled));
sc.setAutoEnter ((gsc->autoCreate() == "y") && (schedEnabled == "y"));
//tqDebug(TQString("autoEnter set to %1").arg(sc.autoEnter()));
// type
TQString actionType = tx.splits().first().action();
if (actionType == MyMoneySplit::ActionDeposit) {
sc.setType((MyMoneySchedule::typeE)MyMoneySchedule::TYPE_DEPOSIT);
} else if (actionType == MyMoneySplit::ActionTransfer) {
sc.setType((MyMoneySchedule::typeE)MyMoneySchedule::TYPE_TRANSFER);
} else {
sc.setType((MyMoneySchedule::typeE)MyMoneySchedule::TYPE_BILL);
}
// finally, set the transaction pointer
sc.setTransaction(tx);
//tell the storage objects we have a new schedule object.
if (m_suspectSchedule && m_dropSuspectSchedules) {
postMessage ("SC", 2, sc.name().latin1());
} else {
m_storage->addSchedule(sc);
if (m_suspectSchedule)
m_suspectList.append (sc.id());
}
signalProgress (++m_scheduleCount, 0);
return ;
PASS
}
//********************************* convertFreqSpec ********************************************************
void MyMoneyGncReader::convertFreqSpec (const GncFreqSpec *) {
// Nowt to do here at the moment, convertSched only retrieves the interval type
// but we will probably need to look into the nested freqspec when we properly implement semi-monthly and stuff
return ;
}
//********************************* convertRecurrence ********************************************************
void MyMoneyGncReader::convertRecurrence (const GncRecurrence *) {
return ;
}
//**********************************************************************************************************
//************************************* terminate **********************************************************
void MyMoneyGncReader::terminate () {
TRY
// All data has been converted and added to storage
// this code is just temporary to show us what is in the file.
if (gncdebug) tqDebug("%d accounts found in the GnuCash file", (unsigned int)m_mapIds.count());
for (map_accountIds::Iterator it = m_mapIds.begin(); it != m_mapIds.end(); ++it) {
if (gncdebug) tqDebug("key = %s, value = %s", it.key().data(), it.data().data());
}
// first step is to implement the users investment option, now we
// have all the accounts available
TQValueList<TQString>::iterator stocks;
for (stocks = m_stockList.begin(); stocks != m_stockList.end(); ++stocks) {
checkInvestmentOption (*stocks);
}
// Next step is to walk the list and assign the parent/child relationship between the objects.
unsigned int i = 0;
signalProgress (0, m_accountCount, i18n ("Reorganizing accounts..."));
TQValueList<MyMoneyAccount> list;
TQValueList<MyMoneyAccount>::Iterator acc;
m_storage->accountList(list);
for (acc = list.begin(); acc != list.end(); ++acc) {
if ((*acc).parentAccountId() == m_storage->asset().id()) {
MyMoneyAccount assets = m_storage->asset();
m_storage->addAccount(assets, (*acc));
if (gncdebug) tqDebug("Account id %s is a child of the main asset account", (*acc).id().data());
} else if ((*acc).parentAccountId() == m_storage->liability().id()) {
MyMoneyAccount liabilities = m_storage->liability();
m_storage->addAccount(liabilities, (*acc));
if (gncdebug) tqDebug("Account id %s is a child of the main liability account", (*acc).id().data());
} else if ((*acc).parentAccountId() == m_storage->income().id()) {
MyMoneyAccount incomes = m_storage->income();
m_storage->addAccount(incomes, (*acc));
if (gncdebug) tqDebug("Account id %s is a child of the main income account", (*acc).id().data());
} else if ((*acc).parentAccountId() == m_storage->expense().id()) {
MyMoneyAccount expenses = m_storage->expense();
m_storage->addAccount(expenses, (*acc));
if (gncdebug) tqDebug("Account id %s is a child of the main expense account", (*acc).id().data());
} else if ((*acc).parentAccountId() == m_storage->equity().id()) {
MyMoneyAccount equity = m_storage->equity();
m_storage->addAccount(equity, (*acc));
if (gncdebug) tqDebug("Account id %s is a child of the main equity account", (*acc).id().data());
} else if ((*acc).parentAccountId() == m_rootId) {
if (gncdebug) tqDebug("Account id %s is a child of root", (*acc).id().data());
} else {
// it is not under one of the main accounts, so find gnucash parent
TQString parentKey = (*acc).parentAccountId();
if (gncdebug) tqDebug ("acc %s, parent %s", (*acc).id().data(),
(*acc).parentAccountId().data());
map_accountIds::Iterator id = m_mapIds.find(parentKey);
if (id != m_mapIds.end()) {
if (gncdebug) tqDebug("Setting account id %s's parent account id to %s",
(*acc).id().data(), id.data().data());
MyMoneyAccount parent = m_storage->account(id.data());
parent = checkConsistency (parent, (*acc));
m_storage->addAccount (parent, (*acc));
} else {
throw new MYMONEYEXCEPTION ("terminate() could not find account id");
}
}
signalProgress (++i, 0);
} // end for account
signalProgress (0, 1, (".")); // debug - get rid of reorg message
// offer the most common account currency as a default
TQString mainCurrency = "";
unsigned int maxCount = 0;
TQMap<TQString, unsigned int>::ConstIterator it;
for (it = m_currencyCount.begin(); it != m_currencyCount.end(); ++it) {
if (it.data() > maxCount) {
maxCount = it.data();
mainCurrency = it.key();
}
}
if (mainCurrency != "") {
/* fix for qt3.3.4?. According to TQt docs, this should return the enum id of the button pressed, and
indeed it used to do so. However now it seems to return the index of the button. In this case it doesn't matter,
since for Yes, the id is 3 and the index is 0, whereas the No button will return 4 or 1. So we test for either Yes case */
/* and now it seems to have changed again, returning 259 for a Yes??? so use KMessagebox */
TQString question = i18n("Your main currency seems to be %1 (%2); do you want to set this as your base currency?")
.arg(mainCurrency).arg(m_storage->currency(mainCurrency.utf8()).name());
if(KMessageBox::questionYesNo(0, question, PACKAGE) == KMessageBox::Yes) {
m_storage->setValue ("kmm-baseCurrency", mainCurrency);
}
}
// now produce the end of job reports - first, work out which ones are required
m_ccCount = 0, m_orCount = 0, m_scCount = 0;
for (i = 0; i < m_messageList.count(); i++) {
if ((*m_messageList.at(i)).source == "CC") m_ccCount++;
if ((*m_messageList.at(i)).source == "OR") m_orCount++;
if ((*m_messageList.at(i)).source == "SC") m_scCount++;
}
TQValueList<TQString> sectionsToReport; // list of sections needing report
sectionsToReport.append ("MN"); // always build the main section
if (m_ccCount > 0) sectionsToReport.append ("CC");
if (m_orCount > 0) sectionsToReport.append ("OR");
if (m_scCount > 0) sectionsToReport.append ("SC");
// produce the sections in message boxes
bool exit = false;
for (i = 0; (i < sectionsToReport.count()) && !exit; i++) {
TQString button0Text = i18n("More");
if (i + 1 == sectionsToReport.count())
button0Text = i18n("Done"); // last section
KGuiItem yesItem(button0Text, TQIconSet(), "", "");
KGuiItem noItem(i18n("Save Report"), TQIconSet(), "", "");
switch(KMessageBox::questionYesNoCancel(0,
buildReportSection (*sectionsToReport.at(i)),
PACKAGE,
yesItem, noItem)) {
case KMessageBox::Yes:
break;
case KMessageBox::No:
exit = writeReportToFile (sectionsToReport);
break;
default:
exit = true;
break;
}
}
for (i = 0; i < m_suspectList.count(); i++) {
MyMoneySchedule sc = m_storage->schedule(m_suspectList[i]);
KEditScheduleDlg *s;
switch(KMessageBox::warningYesNo(0, i18n("Problems were encountered in converting schedule '%1'.\nDo you want to review or edit it now?").arg(sc.name()), PACKAGE)) {
case KMessageBox::Yes:
s = new KEditScheduleDlg (sc);
// FIXME: connect newCategory to something useful, so that we
// can create categories from within the dialog
if (s->exec())
m_storage->modifySchedule (s->schedule());
delete s;
break;
default:
break;
}
}
PASS
}
//************************************ buildReportSection************************************
TQString MyMoneyGncReader::buildReportSection (const TQString& source) {
TRY
TQString s = "";
bool more = false;
if (source == "MN") {
s.append (i18n("Found:\n\n"));
s.append (TQString::number(m_commodityCount) + i18n(" commodities (equities)\n"));
s.append (TQString::number(m_priceCount) + i18n(" prices\n"));
s.append (TQString::number(m_accountCount) + i18n(" accounts\n"));
s.append (TQString::number(m_transactionCount) + i18n(" transactions\n"));
s.append (TQString::number(m_scheduleCount) + i18n(" schedules\n"));
s.append ("\n\n");
if (m_ccCount == 0) {
s.append (i18n("No inconsistencies were detected"));
} else {
s.append (TQString::number(m_ccCount) + i18n(" inconsistencies were detected and corrected\n"));
more = true;
}
if (m_orCount > 0) {
s.append ("\n\n");
s.append (TQString::number(m_orCount) + i18n(" orphan accounts were created\n"));
more = true;
}
if (m_scCount > 0) {
s.append ("\n\n");
s.append (TQString::number(m_scCount) + i18n(" possible schedule problems were noted\n"));
more = true;
}
TQString unsupported ("");
TQString lineSep ("\n - ");
if (m_smallBusinessFound) unsupported.append(lineSep + i18n("Small Business Features (Customers, Invoices, etc.)"));
if (m_budgetsFound) unsupported.append(lineSep + i18n("Budgets"));
if (m_lotsFound) unsupported.append(lineSep + i18n("Lots"));
if (!unsupported.isEmpty()) {
unsupported.prepend(i18n("The following features found in your file are not currently supported:"));
s.append(unsupported);
}
if (more) s.append (i18n("\n\nPress More for further information"));
} else { // we need to retrieve the posted messages for this source
if (gncdebug) tqDebug("Building messages for source %s", source.latin1());
unsigned int i, j;
for (i = 0; i < m_messageList.count(); i++) {
GncMessageArgs *m = m_messageList.at(i);
if (m->source == source) {
if (gncdebug) tqDebug("%s", TQString("build text source %1, code %2, argcount %3")
.arg(m->source).arg(m->code).arg(m->args.count()).data());
TQString ss = GncMessages::text (m->source, m->code);
// add variable args. the .arg function seems always to replace the
// lowest numbered placeholder it finds, so translating messages
// with variables in a different order should still work okay (I think...)
for (j = 0; j < m->args.count(); j++) ss = ss.arg (*m->args.at(j));
s.append (ss + "\n");
}
}
}
if (gncdebug) tqDebug ("%s", s.latin1());
return (static_cast<const TQString>(s));
PASS
}
//************************ writeReportToFile*********************************
bool MyMoneyGncReader::writeReportToFile (const TQValueList<TQString>& sectionsToReport) {
TRY
unsigned int i;
TQFileDialog* fd = new TQFileDialog (0, "Save report as", TRUE);
fd->setMode (TQFileDialog::AnyFile);
if (fd->exec() != TQDialog::Accepted) {
delete fd;
return (false);
}
TQFile reportFile(fd->selectedFile());
TQFileInfo fi (reportFile);
if (!reportFile.open (IO_WriteOnly)) {
delete fd;
return (false);
}
TQTextStream stream (&reportFile);
for (i = 0; i < sectionsToReport.count(); i++) {
stream << buildReportSection (*sectionsToReport.at(i)).latin1() << endl;
}
reportFile.close();
delete fd;
return (true);
PASS
}
/****************************************************************************
Utility routines
*****************************************************************************/
//************************ createPayee ***************************
TQString MyMoneyGncReader::createPayee (const TQString& gncDescription) {
MyMoneyPayee payee;
try {
payee = m_storage->payeeByName (gncDescription);
} catch (MyMoneyException *e) { // payee not found, create one
delete e;
payee.setName (gncDescription);
m_storage->addPayee (payee);
}
return (payee.id());
}
//************************************** createOrphanAccount *******************************
TQString MyMoneyGncReader::createOrphanAccount (const TQString& gncName) {
MyMoneyAccount acc;
acc.setName ("orphan_" + gncName);
acc.setDescription (i18n("Orphan created from unknown gnucash account"));
TQDate today = TQDate::currentDate();
acc.setOpeningDate (today);
acc.setLastModified (today);
acc.setLastReconciliationDate (today);
acc.setCurrencyId (m_txCommodity);
acc.setAccountType (MyMoneyAccount::Asset);
acc.setParentAccountId (m_storage->asset().id());
m_storage->addAccount (acc);
// assign the gnucash id as the key into the map to find our id
m_mapIds[gncName.utf8()] = acc.id();
postMessage (TQString("OR"), 1, acc.name().ascii());
return (acc.id());
}
//****************************** incrDate *********************************************
TQDate MyMoneyGncReader::incrDate (TQDate lastDate, unsigned char interval, unsigned int intervalCount) {
TRY
switch (interval) {
case 'd':
return (lastDate.addDays(intervalCount));
case 'w':
return (lastDate.addDays(intervalCount * 7));
case 'm':
return (lastDate.addMonths(intervalCount));
case 'y':
return (lastDate.addYears(intervalCount));
case 'o': // once-only
return (lastDate);
}
throw new MYMONEYEXCEPTION (i18n("Internal error - invalid interval char in incrDate"));
TQDate r = TQDate(); return (r); // to keep compiler happy
PASS
}
//********************************* checkConsistency **********************************
MyMoneyAccount MyMoneyGncReader::checkConsistency (MyMoneyAccount& parent, MyMoneyAccount& child) {
TRY
// gnucash is flexible/weird enough to allow various inconsistencies
// these are a couple I found in my file, no doubt more will be discovered
if ((child.accountType() == MyMoneyAccount::Investment) &&
(parent.accountType() != MyMoneyAccount::Asset)) {
postMessage ("CC", 1, child.name().latin1());
return m_storage->asset();
}
if ((child.accountType() == MyMoneyAccount::Income) &&
(parent.accountType() != MyMoneyAccount::Income)) {
postMessage ("CC", 2, child.name().latin1());
return m_storage->income();
}
if ((child.accountType() == MyMoneyAccount::Expense) &&
(parent.accountType() != MyMoneyAccount::Expense)) {
postMessage ("CC", 3, child.name().latin1());
return m_storage->expense();
}
return (parent);
PASS
}
//*********************************** checkInvestmentOption *************************
void MyMoneyGncReader::checkInvestmentOption (TQString stockId) {
// implement the investment option for stock accounts
// first check whether the parent account (gnucash id) is actually an
// investment account. if it is, no further action is needed
MyMoneyAccount stockAcc = m_storage->account (m_mapIds[stockId.utf8()]);
MyMoneyAccount parent;
TQString parentKey = stockAcc.parentAccountId();
map_accountIds::Iterator id = m_mapIds.find (parentKey);
if (id != m_mapIds.end()) {
parent = m_storage->account (id.data());
if (parent.accountType() == MyMoneyAccount::Investment) return ;
}
// so now, check the investment option requested by the user
// option 0 creates a separate investment account for each stock account
if (m_investmentOption == 0) {
MyMoneyAccount invAcc (stockAcc);
invAcc.setAccountType (MyMoneyAccount::Investment);
invAcc.setCurrencyId (TQString("")); // we don't know what currency it is!!
invAcc.setParentAccountId (parentKey); // intersperse it between old parent and child stock acct
m_storage->addAccount (invAcc);
m_mapIds [invAcc.id()] = invAcc.id(); // so stock account gets parented (again) to investment account later
if (gncdebug) tqDebug ("Created investment account %s as id %s, parent %s", invAcc.name().data(), invAcc.id().data(),
invAcc.parentAccountId().data());
if (gncdebug) tqDebug ("Setting stock %s, id %s, as child of %s", stockAcc.name().data(), stockAcc.id().data(), invAcc.id().data());
stockAcc.setParentAccountId (invAcc.id());
m_storage->addAccount(invAcc, stockAcc);
// investment option 1 creates a single investment account for all stocks
} else if (m_investmentOption == 1) {
static TQString singleInvAccId = "";
MyMoneyAccount singleInvAcc;
bool ok = false;
if (singleInvAccId.isEmpty()) { // if the account has not yet been created
TQString invAccName;
while (!ok) {
invAccName = TQInputDialog::getText (PACKAGE,
i18n("Enter the investment account name "), TQLineEdit::Normal,
i18n("My Investments"), &ok);
}
singleInvAcc.setName (invAccName);
singleInvAcc.setAccountType (MyMoneyAccount::Investment);
singleInvAcc.setCurrencyId (TQString(""));
singleInvAcc.setParentAccountId (m_storage->asset().id());
m_storage->addAccount (singleInvAcc);
m_mapIds [singleInvAcc.id()] = singleInvAcc.id(); // so stock account gets parented (again) to investment account later
if (gncdebug) tqDebug ("Created investment account %s as id %s, parent %s, reparenting stock",
singleInvAcc.name().data(), singleInvAcc.id().data(), singleInvAcc.parentAccountId().data());
singleInvAccId = singleInvAcc.id();
} else { // the account has already been created
singleInvAcc = m_storage->account (singleInvAccId);
}
m_storage->addAccount(singleInvAcc, stockAcc); // add stock as child
// the original intention of option 2 was to allow any asset account to be converted to an investment (broker) account
// however, since we have already stored the accounts as asset, we have no way at present of changing their type
// the only alternative would be to hold all the gnucash data in memory, then implement this option, then convert all the data
// that would mean a major overhaul of the code. Perhaps I'll think of another way...
} else if (m_investmentOption == 2) {
static int lastSelected = 0;
MyMoneyAccount invAcc (stockAcc);
TQStringList accList;
TQValueList<MyMoneyAccount> list;
TQValueList<MyMoneyAccount>::Iterator acc;
m_storage->accountList(list);
// build a list of candidates for the input box
for (acc = list.begin(); acc != list.end(); ++acc) {
// if (((*acc).accountGroup() == MyMoneyAccount::Asset) && ((*acc).accountType() != MyMoneyAccount::Stock)) accList.append ((*acc).name());
if ((*acc).accountType() == MyMoneyAccount::Investment) accList.append ((*acc).name());
}
//if (accList.isEmpty()) tqFatal ("No available accounts");
bool ok = false;
while (!ok) { // keep going till we have a valid investment parent
TQString invAccName = TQInputDialog::getItem (
PACKAGE, i18n("Select parent investment account or enter new name. Stock %1").arg(stockAcc.name ()),
accList, lastSelected, true, &ok);
if (ok) {
lastSelected = accList.findIndex (invAccName); // preserve selection for next time
for (acc = list.begin(); acc != list.end(); ++acc) {
if ((*acc).name() == invAccName) break;
}
if (acc != list.end()) { // an account was selected
invAcc = *acc;
} else { // a new account name was entered
invAcc.setAccountType (MyMoneyAccount::Investment);
invAcc.setName (invAccName);
invAcc.setCurrencyId (TQString(""));
invAcc.setParentAccountId (m_storage->asset().id());
m_storage->addAccount (invAcc);
ok = true;
}
if (invAcc.accountType() == MyMoneyAccount::Investment) {
ok = true;
} else {
// this code is probably not going to be implemented coz we can't change account types (??)
#if 0
TQMessageBox mb (PACKAGE,
i18n ("%1 is not an Investment Account. Do you wish to make it one?").arg(invAcc.name()),
TQMessageBox::Question,
TQMessageBox::Yes | TQMessageBox::Default,
TQMessageBox::No | TQMessageBox::Escape,
TQMessageBox::NoButton);
switch (mb.exec()) {
case TQMessageBox::No :
ok = false; break;
default:
// convert it - but what if it has splits???
tqFatal ("Not yet implemented");
ok = true;
break;
}
#endif
switch(KMessageBox::questionYesNo(0, i18n ("%1 is not an Investment Account. Do you wish to make it one?").arg(invAcc.name(), PACKAGE))) {
case KMessageBox::Yes:
// convert it - but what if it has splits???
tqFatal ("Not yet implemented");
ok = true;
break;
default:
ok = false;
break;
}
}
} // end if ok - user pressed Cancel
} // end while !ok
m_mapIds [invAcc.id()] = invAcc.id(); // so stock account gets parented (again) to investment account later
m_storage->addAccount(invAcc, stockAcc);
} else { // investment option != 0, 1, 2
tqFatal ("Invalid investment option %d", m_investmentOption);
}
}
// get the price source for a stock (gnc account) where online quotes are requested
void MyMoneyGncReader::getPriceSource (MyMoneySecurity stock, TQString gncSource) {
// if he wants to use Finance::Quote, no conversion of source name is needed
if (m_useFinanceQuote) {
stock.setValue ("kmm-online-quote-system", "Finance::Quote");
stock.setValue ("kmm-online-source", gncSource.lower());
m_storage->modifySecurity(stock);
return;
}
// first check if we have already asked about this source
// (mapSources is initialy empty. We may be able to pre-fill it with some equivalent
// sources, if such things do exist. User feedback may help here.)
TQMap<TQString, TQString>::Iterator it;
for (it = m_mapSources.begin(); it != m_mapSources.end(); it++) {
if (it.key() == gncSource) {
stock.setValue("kmm-online-source", it.data());
m_storage->modifySecurity(stock);
return;
}
}
// not found in map, so ask the user
KGncPriceSourceDlg *dlg = new KGncPriceSourceDlg (stock.name(), gncSource);
dlg->exec();
TQString s = dlg->selectedSource();
if (!s.isEmpty()) {
stock.setValue("kmm-online-source", s);
m_storage->modifySecurity(stock);
}
if (dlg->alwaysUse()) m_mapSources[gncSource] = s;
delete dlg;
return;
}
// functions to control the progress bar
//*********************** setProgressCallback *****************************
void MyMoneyGncReader::setProgressCallback(void(*callback)(int, int, const TQString&)) {
m_progressCallback = callback; return ;
}
//************************** signalProgress *******************************
void MyMoneyGncReader::signalProgress(int current, int total, const TQString& msg) {
if (m_progressCallback != 0)
(*m_progressCallback)(current, total, msg);
return ;
}
// error and information reporting
//***************************** Information and error messages *********************
void MyMoneyGncReader::postMessage (const TQString& source, const unsigned int code, const char* arg1) {
postMessage (source, code, TQStringList(arg1));
}
void MyMoneyGncReader::postMessage (const TQString& source, const unsigned int code, const char* arg1, const char* arg2) {
TQStringList argList(arg1);
argList.append(arg2);
postMessage(source, code, argList);
}
void MyMoneyGncReader::postMessage (const TQString& source, const unsigned int code, const char* arg1, const char* arg2, const char* arg3) {
TQStringList argList(arg1);
argList.append(arg2);
argList.append(arg3);
postMessage(source, code, argList);
}
void MyMoneyGncReader::postMessage (const TQString& source, const unsigned int code, const TQStringList& argList) {
unsigned int i;
GncMessageArgs *m = new GncMessageArgs;
m->source = source;
m->code = code;
// get the number of args this message requires
const unsigned int argCount = GncMessages::argCount (source, code);
if ((gncdebug) && (argCount != argList.count()))
tqDebug("%s", TQString("MyMoneyGncReader::postMessage debug: Message %1, code %2, requires %3 arguments, got %4")
.arg(source).arg(code).arg(argCount).arg(argList.count()).data());
// store the arguments
for (i = 0; i < argCount; i++) {
if (i > argList.count()) m->args.append(TQString());
else m->args.append (argList[i]); //Adds the next argument to the list
}
m_messageList.append (m);
return ;
}
//********************************** Message texts **********************************************
GncMessages::messText GncMessages::texts [] = {
{"CC", 1, i18n("An Investment account must be a child of an Asset account\n"
"Account %1 will be stored under the main Asset account")},
{"CC", 2, i18n("An Income account must be a child of an Income account\n"
"Account %1 will be stored under the main Income account")},
{"CC", 3, i18n("An Expense account must be a child of an Expense account\n"
"Account %1 will be stored under the main Expense account")},
{"OR", 1, i18n("One or more transactions contain a reference to an otherwise unknown account\n"
"An asset account with the name %1 has been created to hold the data")},
{"SC", 1, i18n("Schedule %1 has interval of %2 which is not currently available")},
{"SC", 2, i18n("Schedule %1 dropped at user request")},
{"SC", 3, i18n("Schedule %1 contains unknown action (key = %2, type = %3)")},
{"SC", 4, i18n("Schedule %1 contains multiple actions; only one has been imported")},
{"SC", 5, i18n("Schedule %1 contains no valid splits")},
{"SC", 6, i18n("Schedule %1 appears to contain a formula. GnuCash formulae are not convertible")},
{"SC", 7, i18n("Schedule %1 contains unknown interval specification; please check for correct operation")},
{"SC", 8, i18n("Schedule %1 contains a deferred interval specification; please check for correct operation")},
{"CC", 4, i18n("Account or Category %1, transaction date %2; split contains invalid value; please check")},
{"ZZ", 0, ""} // stopper
};
//
TQString GncMessages::text (const TQString source, const unsigned int code) {
TRY
unsigned int i;
for (i = 0; texts[i].source != "ZZ"; i++) {
if ((source == texts[i].source) && (code == texts[i].code)) break;
}
if (texts[i].source == "ZZ") {
TQString mess = TQString().sprintf("Internal error - unknown message - source %s, code %d", source.latin1(), code);
throw new MYMONEYEXCEPTION (mess);
}
return (texts[i].text);
PASS
}
//
unsigned int GncMessages::argCount (const TQString source, const unsigned int code) {
TRY
unsigned int i;
for (i = 0; texts[i].source != "ZZ"; i++) {
if ((source == texts[i].source) && (code == texts[i].code)) break;
}
if (texts[i].source == "ZZ") {
TQString mess = TQString().sprintf("Internal error - unknown message - source %s, code %d", source.latin1(), code);
throw new MYMONEYEXCEPTION (mess);
}
TQRegExp argConst ("%\\d");
int offset = 0;
unsigned int argCount = 0;
while ((offset = argConst.search (texts[i].text, offset)) != -1) {
argCount++;
offset += 2;
}
return (argCount);
PASS
}
#endif // _GNCFILEANON