lxaccount.cc

LxBank是一个基于Qt/X的家庭储蓄应用程序

  if (y < 100){
    if (y <= 80){
      y += 2000;
    }else{
      y += 1900;
    }
  }
  return y;
}

void LxRemittance::setNumberAndSortKey (int num, int digits)
{
  number = num;
  numberSortKey.sprintf("d%0*d", digits, num );

  switch (status){
  case current:
    dateSortKey.sprintf("%04d%02d%02d%0*d", date.year(), date.month(),
			 date.day(), digits, num );
  break;
  case processed:
    dateSortKey.sprintf("%04d%02d%02d%0*d", dateOfExecution.year(),
			 dateOfExecution.month(), dateOfExecution.day(), digits, num );
  }
}

// double LxRemittance::extractAmountValue ( QString &amountStr)
// {
//   // possible formats of amount string as read from the remittance file:
//   //   1.345.678,78
//   //     1345678,78

// //   cerr << "\nLxRemittance::extractAmountValue: BetragStr in  = " << amountStr << endl;

//   QString ams = amountStr.stripWhiteSpace ();

//   ams.replace ( QRegExp("\\."), "" );        // remove digit group seperators
//   ams.replace ( QRegExp(","), "." );	     // replace decimal comma by decimal point

//   double value = ams.toDouble ( ); 
// //   cerr << "\nLxAccountStmtt::extractAmountValue: BetragStr out = " << ams
// //        << "\n                                    Betrag        = " << value << endl;

//   return value;
// }

QTextStream& LxRemittance::write ( QTextStream& out )
{
  switch ( status ){
  case current:
    //10.05.2002:TANASK:Bernhard Ranner Bad Aibling:6280223725:71120077:48,45:EUR:M黮labfuhr:Mai - July 2002
    out << date.toString ( "dd.MM.yyyy" ) << ':'
	<< tan << ':'
	<< receiver << ':'
	<< receiverAccountNo << ':'
	<< receiverBLZ << ':'
	<< amountStr << ':'
	<< currency << ':'
	<< text[0] << ':'
	<< text[1] << '\n';
    break;
  case processed:
    //%20020401:30.03.2002:590711:Baur Versand Burgkunstadt:77007600:77000000:106,96:EUR:KD-Nr. 0001748412622:Anke Zimmermann

    out << '%' 
	<< dateOfExecution.toString ( "yyyyMMdd" ) << ':'
	<< date.toString ( "dd.MM.yyyy" ) << ':'
	<< tan << ':'
	<< receiver << ':'
	<< receiverAccountNo << ':'
	<< receiverBLZ << ':'
	<< amountStr << ':'
	<< currency << ':'
	<< text[0] << ':'
	<< text[1] << '\n';
    break;
  }
  return out;
}

LxAccount::LxAccount( int n, LxHbci *hbciapi, HBCI::Pointer<HBCI::Account> acc )
  : id(n), hbciApi(hbciapi), hbciAccount(acc), isOpen(false),
    startingBalanceIsSet(false), lastUpdatedIsSet(false),
    lastUpdatedStr("\0")
//    , remittanceListsRead(false)
{
  accountStmtList.setAutoDelete ( TRUE );
  currentRemittanceList.setAutoDelete ( TRUE );
  processedRemittanceList.setAutoDelete ( TRUE );

  initAccount();

//   remittanceFile = "rmtest.bbu";
//   remittanceFile = "SpkAibling2002.bbu";
//   remittanceFile = "SpkBadAibling2001.bbu";
//   remittanceFile = "StSpMue2002.bbu";
//   remittanceFile = "StSpMue2001.bbu";
//   remittanceFile = "StSpMueCash2002.bbu";
//   remittanceFile = "StSpMueCash2001.bbu";
}

LxAccount::~LxAccount( )
{
//   cerr << "LxAccount: Destructor called!" << endl;
  HBCI::Error err;
  err = saveAccountConfig ( );
//   cerr << "LxAccount::~LxAccount: err = " << err.errorString ();
  err = saveCurrentRemittances ( );
//   cerr << "LxAccount::~LxAccount: err = " << err.errorString ();
  err = saveProcessedRemittances ( );
//   cerr << "LxAccount::~LxAccount: err = " << err.errorString ();
}

void LxAccount::clearConfig (){
  startingBalanceIsSet = false;
}

HBCI::Error LxAccount::loadAccountConfig (){
  HBCI::Error err;
  HBCI::cfgPtr accGroup;
  HBCI::cfgPtr startBalGroup;
  HBCI::cfgPtr balGroup;
  HBCI::cfgPtr stmtDateGroup;
  HBCI::cfgPtr dateGroup;
  HBCI::cfgPtr lastAccStmtDate;
  HBCI::Loader loader ( hbciApi );

  HBCI::File acf ( accConfigFile );

  accConfig.clear();
  accConfig.setMode(LXBANK_CONFIG_MODE);

  if ( acf.accessFile(FILE_ACCESS_EXIST).isOk() ) {

    err = accConfig.readFile ( accConfigFile );
    if ( !err.isOk() ){
      return err;
    }
//   cerr << endl;
//   accConfig.dumpCfg ( accConfig.root(), 2 );

    accGroup = accConfig.findGroup( "account", accConfig.root(), false );
    if ( accGroup.isValid() ){

      // load starting balance
      startBalGroup = accConfig.findGroup( "starting_balance", accGroup, false );
      if ( startBalGroup.isValid() ){
	balGroup = accConfig.findGroup( "balance", startBalGroup, false );
	if ( balGroup.isValid() ){
	  err = loader.loadBalance ( startingBalance, accConfig, balGroup );
	  if ( !err.isOk() ){
	    return err;
	  }
	  startingBalanceIsSet = true;
	}
      }

      // load last account statement date
      stmtDateGroup = accConfig.findGroup( "last_account_statement_date", accGroup, false );
      if ( stmtDateGroup.isValid() ){
	dateGroup = accConfig.findGroup( "date", stmtDateGroup, false );
	if ( dateGroup.isValid() ){
	  string tmpStr;
	  tmpStr = accConfig.getVariable ( "lastupdated", "", dateGroup );	
	  HBCI::Date tmpDate ( tmpStr, 4 );
	  lastUpdated = tmpDate;

	  tmpStr = accConfig.getVariable ( "lasttransactiondate", "", dateGroup );	
	  HBCI::Date tmpDate2 ( tmpStr, 4 );
	  lastTransactionDate = tmpDate2;

	  lastUpdatedIsSet = true;
	}
      }

    } // if account group is valid
  } // if file exists

  return err;
}

HBCI::Error LxAccount::loadCurrentRemittances (){
  HBCI::Error err;
  HBCI::cfgPtr accGroup;
  HBCI::cfgPtr curRmGroup;
  HBCI::cfgPtr transactionGroup;
  HBCI::Loader loader ( hbciApi );
  LxRemittance *remittance;

  HBCI::File crmcf ( currRemConfigFile );

  currRemConfig.clear();
  currentRemittanceList.clear ();
  currRemConfig.setMode(LXBANK_CONFIG_MODE);

  if ( crmcf.accessFile(FILE_ACCESS_EXIST).isOk() ) {

    err = currRemConfig.readFile ( currRemConfigFile );
    if ( !err.isOk() ){
      return err;
    }
//   cerr << endl;
//   currRemConfig.dumpCfg ( currRemConfig.root(), 2 );

    accGroup = currRemConfig.findGroup( "account", currRemConfig.root(), false );
    if ( accGroup.isValid() ){

      // load actual remittances
      curRmGroup = currRemConfig.findGroup( "current_remittances", accGroup, false );
      if ( curRmGroup.isValid() ){

	transactionGroup = currRemConfig.findGroup( "transaction", curRmGroup, false );
	while ( transactionGroup.isValid() ){
	  HBCI::Transaction crm;
	  
	  err = loader.loadTransaction ( crm, currRemConfig, transactionGroup );
	  if ( !err.isOk() ){
	    return err;
	  }

	  remittance = new LxRemittance ( this, crm, LxRemittance::current );
	  currentRemittanceList.append(remittance);
	  ++transactionGroup;
	}
      }

    } // if account group is valid
  } // if file exists

  int digits, count;
  if ( !currentRemittanceList.isEmpty() ){
    digits = (int)(log10((double)currentRemittanceList.count()) + 2.0);
    for (remittance = currentRemittanceList.first(), count = 1;
	 remittance != 0; remittance = currentRemittanceList.next(), ++count){
      remittance->setNumberAndSortKey (count, digits);
    }
  }

  return err;
}

HBCI::Error LxAccount::loadProcessedRemittances (){
  HBCI::Error err;
  HBCI::cfgPtr accGroup;
  HBCI::cfgPtr procRmGroup;
  HBCI::cfgPtr transactionGroup;
  LxRemittance *remittance;
  HBCI::Loader loader ( hbciApi );

  HBCI::File prmcf ( procRemConfigFile );

  procRemConfig.clear();
  processedRemittanceList.clear ();
  procRemConfig.setMode(LXBANK_CONFIG_MODE);

  if ( prmcf.accessFile(FILE_ACCESS_EXIST).isOk() ) {

    err = procRemConfig.readFile ( procRemConfigFile );
    if ( !err.isOk() ){
      return err;
    }
//   cerr << endl;
//   procRemConfig.dumpCfg ( procRemConfig.root(), 2 );

    accGroup = procRemConfig.findGroup( "account", procRemConfig.root(), false );
    if ( accGroup.isValid() ){

      // load processed remittances
      procRmGroup = procRemConfig.findGroup( "processed_remittances", accGroup, false );
      if ( procRmGroup.isValid() ){

	transactionGroup = procRemConfig.findGroup( "transaction", procRmGroup, false );
	while ( transactionGroup.isValid() ){
	  HBCI::Transaction prm;
	  
	  err = loader.loadTransaction ( prm, procRemConfig, transactionGroup );
	  if ( !err.isOk() ){
	    return err;
	  }

	  remittance = new LxRemittance ( this, prm, LxRemittance::processed );
	  processedRemittanceList.append(remittance);
	  ++transactionGroup;
	}
      }

    } // if account group is valid
  } // if file exists

  int digits, count;
  if ( !processedRemittanceList.isEmpty() ){
    digits = (int)(log10((double)processedRemittanceList.count()) + 2.0);
    for (remittance = processedRemittanceList.first(), count = 1;
	 remittance != 0; remittance = processedRemittanceList.next(), ++count){
      remittance->setNumberAndSortKey (count, digits);
    }
  }

  return err;
}

HBCI::Error LxAccount::saveAccountConfig (){
  HBCI::Error  err;
  HBCI::cfgPtr accGroup;
  HBCI::cfgPtr startBalGroup;
  HBCI::cfgPtr balGroup;
  HBCI::cfgPtr stmtDateGroup;
  HBCI::cfgPtr dateGroup;
  HBCI::cfgPtr lastAccStmtDate;
  HBCI::Loader loader ( hbciApi );

  accConfig.setMode(LXBANK_CONFIG_MODE);
  accGroup = accConfig.findGroup( "account", accConfig.root(), true );

//   cerr << "saveAccountConfig: before clearing:" << endl;
//   accConfig.dumpCfg ( accConfig.root(), 2 );

  // clear starting balance
  startBalGroup = accConfig.findGroup( "starting_balance", accGroup, false );
  if ( startBalGroup.isValid() ){
//     cerr << "saveAccountConfig: clearing group starting_balance!" << endl;
    if ( !startBalGroup.clearBranch() ){
      return HBCI::Error( "LxAccount::saveAccountConfig",
			  ERROR_LEVEL_INTERNAL,
			  0,
			  ERROR_ADVISE_ABORT,
			  "Could not clear group",
			  "starting_balance" );
    }
  }

  // clear last account statement date
  stmtDateGroup = accConfig.findGroup( "last_account_statement_date", accGroup, false );
  if ( stmtDateGroup.isValid() ){
//     cerr << "saveAccountConfig: clearing group last_account_statement_date!" << endl;
    if ( !stmtDateGroup.clearBranch() ){
      return HBCI::Error( "LxAccount::saveAccountConfig",
			  ERROR_LEVEL_INTERNAL,
			  0,
			  ERROR_ADVISE_ABORT,
			  "Could not clear group",
			  "last_account_statement_date" );
    }
  }

//   cerr << "saveAccountConfig: after clearing:" << endl;
//   accConfig.dumpCfg ( accConfig.root(), 2 );

  if ( startingBalanceIsSet ){
    // save starting balance
    startBalGroup = accConfig.findGroup( "starting_balance", accGroup, true );
    if ( !startBalGroup.isValid() ){
      return HBCI::Error( "LxAccount::saveAccountConfig",
			  ERROR_LEVEL_INTERNAL,
			  0,
			  ERROR_ADVISE_ABORT,
			  "Could not create group",
			  "starting_balance" );
    }
    balGroup = accConfig.createGroup( "balance", startBalGroup );
    if ( !balGroup.isValid() ){
      return HBCI::Error( "LxAccount::saveAccountConfig",
			  ERROR_LEVEL_INTERNAL,
			  0,
			  ERROR_ADVISE_ABORT,
			  "Could not create group",
			  "balance" );
    }
    err = loader.saveBalance ( startingBalance, accConfig, balGroup );
    if ( !err.isOk() ){
      return err;
    }
  } // if startingBalance

  if ( lastUpdatedIsSet ){
    // save last account statement date
    stmtDateGroup = accConfig.findGroup( "last_account_statement_date", accGroup, true );
    if ( !stmtDateGroup.isValid() ){
      return HBCI::Error( "LxAccount::saveAccountConfig",
			  ERROR_LEVEL_INTERNAL,
			  0,
			  ERROR_ADVISE_ABORT,
			  "Could not create group",
			  "last_account_statement_date" );
    }
    dateGroup = accConfig.createGroup( "date", stmtDateGroup );
    if ( !dateGroup.isValid() ){
      return HBCI::Error( "LxAccount::saveAccountConfig",
			  ERROR_LEVEL_INTERNAL,
			  0,
			  ERROR_ADVISE_ABORT,
			  "Could not create group",
			  "date" );
    }
    string tmpStr ( lastUpdated.toString() );
    lastAccStmtDate = accConfig.createVar ( "lastupdated", dateGroup );
    accConfig.setVariable ( "lastupdated", tmpStr , dateGroup );

    tmpStr = lastTransactionDate.toString();
    lastAccStmtDate = accConfig.createVar ( "lasttransactiondate", dateGroup );
    accConfig.setVariable ( "lasttransactiondate", tmpStr , dateGroup );
  } // if lastUpdatedIsSet

//   cerr << "saveAccountConfig: config after save start balance and last account stmt date:" << endl;
//   accConfig.dumpCfg ( accConfig.root(), 2 );
//   cerr << endl;

  // write config file
  err = accConfig.writeFile ( accConfigFile );
  if ( !err.isOk() ){
    return err;
  }

  return err;
}

HBCI::Error LxAccount::saveCurrentRemittances (){
  HBCI::Error  err;
  HBCI::cfgPtr accGroup;
  HBCI::cfgPtr curRmGroup;
  HBCI::cfgPtr transactionGroup;
  HBCI::Loader loader ( hbciApi );
  LxRemittance *remittance;

  currRemConfig.setMode(LXBANK_CONFIG_MODE);
  accGroup = currRemConfig.findGroup( "account", currRemConfig.root(), true );