lxaccount.cc

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

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

  // clear actual remittances
  curRmGroup = currRemConfig.findGroup( "current_remittances", accGroup, false );
  if ( curRmGroup.isValid() ){
//     cerr << "saveCurrentRemittances: clearing group current_remittances!" << endl;
    if ( !curRmGroup.clearBranch() ){
      return HBCI::Error( "LxAccount::saveCurrentRemittances",
			  ERROR_LEVEL_INTERNAL,
			  0,
			  ERROR_ADVISE_ABORT,
			  "Could not clear group",
			  "current_remittances" );
    }
  }

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

  // save actual remittances
  curRmGroup = currRemConfig.findGroup( "current_remittances", accGroup, true );
  if ( !curRmGroup.isValid() ){
    return HBCI::Error( "LxAccount::saveCurrentRemittances",
			ERROR_LEVEL_INTERNAL,
			0,
			ERROR_ADVISE_ABORT,
			"Could not create group",
			"current_remittances" );
  }
  for (remittance = currentRemittanceList.first();
       remittance != 0; remittance = currentRemittanceList.next() ){
    transactionGroup = currRemConfig.createGroup( "transaction", curRmGroup );
    if ( !transactionGroup.isValid() ){
      return HBCI::Error( "LxAccount::saveCurrentRemittances",
			  ERROR_LEVEL_INTERNAL,
			  0,
			  ERROR_ADVISE_ABORT,
			  "Could not create group",
			  "transaction" );
    }
    const HBCI::Transaction &crm = remittance->HBCItransaction();
    err = loader.saveTransaction ( crm, currRemConfig, transactionGroup );
    if ( !err.isOk() ){
      return err;
    }
  }
//   cerr << "saveCurrentRemittances: config after saving current remittances:" << endl;
//   currRemConfig.dumpCfg ( currRemConfig.root(), 2 );

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

  return err;
}

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

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

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

  // clear processed remittances
  procRmGroup = procRemConfig.findGroup( "processed_remittances", accGroup, false );
  if ( procRmGroup.isValid() ){
//     cerr << "saveProcessedRemittances: clearing group processed_remittances!" << endl;
    if ( !procRmGroup.clearBranch() ){
      return HBCI::Error( "LxAccount::saveProcessedRemittances",
			  ERROR_LEVEL_INTERNAL,
			  0,
			  ERROR_ADVISE_ABORT,
			  "Could not clear group",
			  "processed_remittances" );
    }
  }

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

  // save processed remittances
  procRmGroup = procRemConfig.findGroup( "processed_remittances", accGroup, true );
  if ( !procRmGroup.isValid() ){
    return HBCI::Error( "LxAccount::saveProcessedRemittances",
			ERROR_LEVEL_INTERNAL,
			0,
			ERROR_ADVISE_ABORT,
			"Could not create group",
			"processed_remittances" );
  }
  for (remittance = processedRemittanceList.first();
       remittance != 0; remittance = processedRemittanceList.next() ){
    transactionGroup = procRemConfig.createGroup( "transaction", procRmGroup );
    if ( !transactionGroup.isValid() ){
      return HBCI::Error( "LxAccount::saveProcessedRemittances",
			  ERROR_LEVEL_INTERNAL,
			  0,
			  ERROR_ADVISE_ABORT,
			  "Could not create group",
			  "transaction" );
    }
    const HBCI::Transaction &prm = remittance->HBCItransaction();
    err = loader.saveTransaction ( prm, procRemConfig, transactionGroup );
    if ( !err.isOk() ){
      return err;
    }
  }
//   cerr << "saveProcessedRemittances: config after saving processed remittances:" << endl;
//   procRemConfig.dumpCfg ( procRemConfig.root(), 2 );

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

  return err;
}

double LxAccount::computeBalance ()
{
  if ( !(hbciAccount.isValid()) ){
    return 0.0;
  }
  // obtain transactions
  const list<HBCI::Transaction> &transactions = (*hbciAccount).transactions();
  list<HBCI::Transaction>::const_iterator trIt;
  double saldo;

  for (trIt = transactions.begin(), saldo = 0.0; trIt != transactions.end(); ++trIt){
    HBCI::Value value = trIt->value ();
    saldo += value.getValue ();
  }
  return saldo;
}

void LxAccount::setupStartingBalance ()
{
  // compute balance of transactions
  double balanceOfTransactions, startingBalanceValue;
  balanceOfTransactions = computeBalance();

  // optain account balance
  HBCI::AccountBalance accBal    = (*hbciAccount).balance();
  HBCI::Balance        bal       = accBal.bookedBalance();
  HBCI::Value          accBalVal = bal.value();
  double               accbalval = accBalVal.getValue();

  // compute starting value
  if ( bal.isDebit() ){
//     cerr << "LxAccount::setupStartingBalance: isDebit returns true for BLZ/account "
// 	 << bankLeitZahl << "/" << kontoNummer << "!" << endl;
    accbalval *= -1.0;
  }

  startingBalanceValue = accbalval - balanceOfTransactions;

  // set debit
  if ( startingBalanceValue > 0.0 ){
    startingBalance.setDebit ( false );
  }else{
    startingBalance.setDebit ( true );
  }

  // set value
  HBCI::Value startingValue( startingBalanceValue, (*hbciAccount).currency() );
  startingBalance.setValue (startingValue );

    // set date
    const list<HBCI::Transaction> &transactions = (*hbciAccount).transactions();
    list<HBCI::Transaction>::const_iterator trIt = transactions.begin();
    if ( trIt != transactions.end() ){
      const HBCI::Date &booked = trIt->date ();
      const HBCI::Date &valuta = trIt->valutaDate ();
      int comp = booked.compare ( valuta );
      if ( comp == -1 ){
	startingBalance.setDate ( booked );
      }else{
	startingBalance.setDate ( valuta );
      }
    }

    // set time
    HBCI::Time midnight (0, 0, 0);
    startingBalance.setTime ( midnight );

    startingBalanceIsSet = true;
}

// bool LxAccount::isDataLine (QString &txt)
// {
//   txt = txt.stripWhiteSpace ();

//   if ( txt.isEmpty() ){
//     return false;
//   }else if ( txt[0] == '#' ){
//     return false;
//   }else{
//     return true;
//   }
// }

void LxAccount::open ( )
{
  setupAccountStmtList ( );
//   setupRemittanceLists ( );
  isOpen = true;

  emit updateAccountDataView( *this );
  emit updateAccountStmtView ( accountStmtList );
  emit updateCurrentRemittanceView ( currentRemittanceList );
  emit updateProcessedRemittanceView ( processedRemittanceList );
}

void LxAccount::updateAccount ( )
{
  updateAccountData();
  setupAccountStmtList();

  emit updateAccountDataView( *this );
  emit updateAccountStmtView ( accountStmtList );
}

void LxAccount::close ( )
{
  if (!isOpen)
    return;

  accountStmtList.clear ();
//   currentRemittanceList.clear ();
//   processedRemittanceList.clear ();
  isOpen = false;
//   remittanceListsRead = false;

  emit updateProcessedRemittanceView ( emptyRemittanceList );
  emit updateCurrentRemittanceView ( emptyRemittanceList );
  emit updateAccountStmtView ( accountStmtList );
  emit updateAccountDataView( *this );
}

void LxAccount::updateBalanceAndAccStmt ( ){
  HBCI::Error err;
  HBCI::Date from, to;

  if ( lastUpdated.isValid() ){
    from = lastUpdated;
  }

  if ( from.isValid() && lastTransactionDate.isValid() ){
    int comp = lastTransactionDate.compare ( from );
    if ( comp == -1 ){
      from = lastTransactionDate;
    }
  }

  HBCI::Pointer<HBCI::Interactor> intActor = hbciApi->interactor();

  const list<HBCI::Pointer<HBCI::Customer> > & customersOfAccount = (*hbciAccount).authorizedCustomers();
  list<HBCI::Pointer<HBCI::Customer> >::const_iterator cit = customersOfAccount.begin();

  HBCI::Pointer<HBCI::OutboxJob> balJob = new HBCI::OutboxJobGetBalance( *cit, hbciAccount);
  hbciApi->addJob (balJob);

  HBCI::Pointer<HBCI::OutboxJob> transJob = new HBCI::OutboxJobGetTransactions( *cit, hbciAccount, from, to );
  hbciApi->addJob (transJob);

  try {
    err = hbciApi->executeQueue();
    if ( !err.isOk() ){
      LxHbci::reportError (err, "LxAccount::updateBalanceAndAccStmt: Error at executeQueue!");
    }
  }
  catch (HBCI::Error excErr) {
    LxHbci::reportError (excErr, "LxAccount::updateBalanceAndAccStmt: Exeption at executeQueue!");
  }

  if ( (*intActor).aborted() ){
    (*intActor).abort(false);
    //     cerr << "\nStatus of Interactor: aborted! Interactor reset!" << endl;
  }
  //  else{
  //     cerr << "\nStatus of Interactor: not aborted!" << endl;
  //  }
  //     switch ( (*balJob).result() ){
  //     case HBCI_JOB_RESULT_NONE:
  //       cerr << "\nJobGetBalance: job was not executed" << endl;
  //       break;
  //     case HBCI_JOB_RESULT_SUCCESS:
  //       cerr << "\nJobGetBalance: job was successfully performed" << endl;
  //       break;
  //     case HBCI_JOB_RESULT_FAILED:
  //       cerr << "\nJobGetBalance: job was executed and failed" << endl;
  //     }

  //     switch ( (*transJob).result() ){
  //     case HBCI_JOB_RESULT_NONE:
  //       cerr << "\nJobGetTransactions: job was not executed" << endl;
  //       break;
  //     case HBCI_JOB_RESULT_SUCCESS:
  //       cerr << "\nJobGetTransactions: job was performed successfully" << endl;
  //       break;
  //     case HBCI_JOB_RESULT_FAILED:
  //       cerr << "\nJobGetTransactions: job was executed and failed" << endl;
  //     }

  bool balJobSuccessfull = false;
  bool transJobSuccessfull = false;
    
  if ( (*balJob).result() == HBCI_JOB_RESULT_SUCCESS ){
    cerr << "\nBalance job has been performed successfully!" << endl;
    balJobSuccessfull = true;
  }else{
    cerr << "\nBalance job has not been performed successfully!" << endl;
    balJobSuccessfull = false;
  }

  if ( (*transJob).result() == HBCI_JOB_RESULT_SUCCESS ){
    cerr << "\nTransaction job has been successfully performed!" << endl;
    transJobSuccessfull = true;
  }else{
    cerr << "\nTransaction job has not been performed successfully!" << endl;
    transJobSuccessfull = false;
  }

  if ( balJobSuccessfull || transJobSuccessfull ){
    //       cerr << "\nSave HBCI stuff!" << endl;
    hbciApi->save();
  }

  if ( transJobSuccessfull ){
    //       cerr << "\nUpdate last account statement dates!" << endl;

    const list<HBCI::Transaction> &transactions = (*hbciAccount).transactions();
    list<HBCI::Transaction>::const_reverse_iterator trIt = transactions.rbegin();
    if ( trIt != transactions.rend() ){
      // update last transaction date
      lastTransactionDate = trIt->date ();

      // update last account statement date
      QDate today ( QDate::currentDate () );
      HBCI::Date todayHBCI ( today.day(), today.month(), today.year() );
      lastUpdated = todayHBCI;
      lastUpdatedIsSet = true;

    }else{
      transJobSuccessfull = false;
    }
  }

  if ( balJobSuccessfull && transJobSuccessfull ){
    //       cerr << "\nCompute starting balance!" << endl;

    if ( !startingBalanceIsSet ){  // compute start balance, but do it only once
      setupStartingBalance ();
    }
  }

  if ( transJobSuccessfull ){

    err = saveAccountConfig ();
    //   cerr << "LxAccount::~LxAccount: err = " << err.errorString ();
    updateAccount( );

  }else if ( balJobSuccessfull ){

    updateAccount( );

  } 
  //else{
  //       cerr << "\njobs have not been successfully performed! Do not perform saves and updates!" << endl;
  //     }

  // clear queue
  list<HBCI::Pointer<HBCI::OutboxJob> > qjobs = hbciApi->queuedJobs ();
  list<HBCI::Pointer<HBCI::OutboxJob> >::iterator jb;
  //   cerr << "\nClear queue!\n\nNumber of queued jobs = " << qjobs.size() << endl;

  for ( jb = qjobs.begin(); jb != qjobs.end(); ++jb){
    hbciApi->removeQueuedJob ( *jb );
  }
  qjobs = hbciApi->queuedJobs ();
  //   cerr << "\nNumber of queued jobs = " << qjobs.size() << endl;

}

void LxAccount::submitRemittance ( LxRemittance * rm){
  HBCI::Error err;

  //   cerr << "LxAccount::submitRemittance called!" << endl;

  HBCI::Pointer<HBCI::Interactor> intActor = hbciApi->interactor();
  //   if ( (*intActor).aborted() ){
  //     cerr << "\nStatus of Interactor: aborted!" << endl;
  //   }else{
  //     cerr << "\nStatus of Interactor: not aborted!" << endl;
  //   }

  const list<HBCI::Pointer<HBCI::Customer> > & customersOfAccount = (*hbciAccount).authorizedCustomers();
  list<HBCI::Pointer<HBCI::Customer> >::const_iterator cit = customersOfAccount.begin();
  const HBCI::Transaction &transaction = rm->HBCItransaction();

  HBCI::Pointer<HBCI::OutboxJob> transferJob = new HBCI::OutboxJobTransfer( *cit, hbciAccount, transaction);
  hbciApi->addJob (transferJob);

  try {
    err = hbciApi->executeQueue();
    if ( !err.isOk() ){
      LxHbci::reportError (err, "LxAccount::submitRemittance: Error at executeQueue!");
    }
  }
  catch (HBCI::Error excErr) {
    LxHbci::reportError (excErr, "LxAccount::submitRemittance: Exeption at executeQueue!");
  }

  //   switch ( (*transferJob).result() ){
  //   case HBCI_JOB_RESULT_NONE:
  //     cerr << "\nJobTransfer: job was not executed" << endl;