Example #1
0
int AB_BankInfo_ReadDb(AB_BANKINFO *st, GWEN_DB_NODE *db) {
  assert(st);
  assert(db);
  AB_BankInfo_SetCountry(st, GWEN_DB_GetCharValue(db, "country", 0, 0));
  AB_BankInfo_SetBranchId(st, GWEN_DB_GetCharValue(db, "branchId", 0, 0));
  AB_BankInfo_SetBankId(st, GWEN_DB_GetCharValue(db, "bankId", 0, 0));
  AB_BankInfo_SetBic(st, GWEN_DB_GetCharValue(db, "bic", 0, 0));
  AB_BankInfo_SetBankName(st, GWEN_DB_GetCharValue(db, "bankName", 0, 0));
  AB_BankInfo_SetLocation(st, GWEN_DB_GetCharValue(db, "location", 0, 0));
  AB_BankInfo_SetStreet(st, GWEN_DB_GetCharValue(db, "street", 0, 0));
  AB_BankInfo_SetZipcode(st, GWEN_DB_GetCharValue(db, "zipcode", 0, 0));
  AB_BankInfo_SetCity(st, GWEN_DB_GetCharValue(db, "city", 0, 0));
  AB_BankInfo_SetRegion(st, GWEN_DB_GetCharValue(db, "region", 0, 0));
  AB_BankInfo_SetPhone(st, GWEN_DB_GetCharValue(db, "phone", 0, 0));
  AB_BankInfo_SetFax(st, GWEN_DB_GetCharValue(db, "fax", 0, 0));
  AB_BankInfo_SetEmail(st, GWEN_DB_GetCharValue(db, "email", 0, 0));
  AB_BankInfo_SetWebsite(st, GWEN_DB_GetCharValue(db, "website", 0, 0));
  st->services=AB_BankInfoService_List_new();
  if (1) {/* just for local vars */
    GWEN_DB_NODE *dbT;
    AB_BANKINFO_SERVICE *e;

    dbT=GWEN_DB_GetGroup(db, GWEN_PATH_FLAGS_NAMEMUSTEXIST, "services");
    if (dbT) {
      GWEN_DB_NODE *dbT2;

      dbT2=GWEN_DB_FindFirstGroup(dbT, "element");
      while(dbT2) {
        e=AB_BankInfoService_fromDb(dbT2);
        if (!e) {
          DBG_ERROR(0, "Bad element for type \"AB_BANKINFO_SERVICE\"");
          if (GWEN_Logger_GetLevel(0)>=GWEN_LoggerLevel_Debug)
            GWEN_DB_Dump(dbT2, 2);
          AB_BankInfo_free(st);
          return 0;
        }
        AB_BankInfoService_List_Add(e, st->services);    dbT2=GWEN_DB_FindNextGroup(dbT2, "element");
      } /* while */
    } /* if (dbT) */
  } /* if (1) */
  return 0;
}
Example #2
0
int EBC_Dialog_ExchangeMessages(GWEN_HTTP_SESSION *sess,
                                EB_MSG *msg,
                                EB_MSG **pResponse) {
  AB_USER *u;
  int rv;
  GWEN_BUFFER *sendBuf;
  GWEN_BUFFER *recvBuf;
  EB_MSG *mResponse;

  /* preparations */
  u=AB_HttpSession_GetUser(sess);
  assert(u);
  sendBuf=GWEN_Buffer_new(0, 1024, 0, 1);
  recvBuf=GWEN_Buffer_new(0, 1024, 0, 1);

  /* convert message to buffer for sending */
  EB_Msg_toBuffer(msg, sendBuf);

#if 0
  if (GWEN_Logger_GetLevel(AQEBICS_LOGDOMAIN)>=GWEN_LoggerLevel_Debug) {
    DBG_ERROR(AQEBICS_LOGDOMAIN, "Sending this:");
    fprintf(stderr, "====================================\n");
    fprintf(stderr, "%s\n", GWEN_Buffer_GetStart(sendBuf));
    fprintf(stderr, "====================================\n");
  }
#endif

  /* send request */
  rv=GWEN_HttpSession_SendPacket(sess,
				 "POST",
				 (const uint8_t*)GWEN_Buffer_GetStart(sendBuf),
				 GWEN_Buffer_GetUsedBytes(sendBuf));
  if (rv<0) {
    DBG_ERROR(AQEBICS_LOGDOMAIN, "Error sending request (%d)", rv);
    GWEN_Buffer_free(recvBuf);
    GWEN_Buffer_free(sendBuf);
    return rv;
  }
  GWEN_Buffer_free(sendBuf);

  /* receive response */
  rv=GWEN_HttpSession_RecvPacket(sess, recvBuf);
  if (rv<0 || rv>=300) {
    DBG_ERROR(AQEBICS_LOGDOMAIN, "Error sending request (%d)", rv);
    GWEN_Buffer_free(recvBuf);
    return rv;
  }

#if 0
  if (GWEN_Logger_GetLevel(AQEBICS_LOGDOMAIN)>=GWEN_LoggerLevel_Debug) {
    DBG_ERROR(AQEBICS_LOGDOMAIN, "Received this:");
    fprintf(stderr, "====================================\n");
    fprintf(stderr, "%s\n", GWEN_Buffer_GetStart(recvBuf));
    fprintf(stderr, "====================================\n");
  }
#endif

  /* convert buffer to EBICS message */
  mResponse=EB_Msg_fromBuffer(GWEN_Buffer_GetStart(recvBuf),
                              GWEN_Buffer_GetUsedBytes(recvBuf));
  GWEN_Buffer_free(recvBuf);
  if (!mResponse) {
    DBG_ERROR(AQEBICS_LOGDOMAIN, "Invalid response (no EBICS message)");
    return GWEN_ERROR_BAD_DATA;
  }

  *pResponse=mResponse;
  return 0;
}
Example #3
0
/* --------------------------------------------------------------- FUNCTION */
int AH_Job_GetBalance_Process(AH_JOB *j, AB_IMEXPORTER_CONTEXT *ctx){
  AH_JOB_GETBALANCE *aj;
  GWEN_DB_NODE *dbResponses;
  GWEN_DB_NODE *dbCurr;
  int rv;

  DBG_INFO(AQHBCI_LOGDOMAIN, "Processing JobGetBalance");

  assert(j);
  aj=GWEN_INHERIT_GETDATA(AH_JOB, AH_JOB_GETBALANCE, j);
  assert(aj);

  dbResponses=AH_Job_GetResponses(j);
  assert(dbResponses);

  /* search for "Balance" */
  dbCurr=GWEN_DB_GetFirstGroup(dbResponses);
  while(dbCurr) {
    GWEN_DB_NODE *dbBalance;

    rv=AH_Job_CheckEncryption(j, dbCurr);
    if (rv) {
      DBG_INFO(AQHBCI_LOGDOMAIN, "Compromised security (encryption)");
      AH_Job_SetStatus(j, AH_JobStatusError);
      return rv;
    }
    rv=AH_Job_CheckSignature(j, dbCurr);
    if (rv) {
      DBG_INFO(AQHBCI_LOGDOMAIN, "Compromised security (signature)");
      AH_Job_SetStatus(j, AH_JobStatusError);
      return rv;
    }

    dbBalance=GWEN_DB_GetGroup(dbCurr, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
                               "data/balance");
    if (!dbBalance)
      dbBalance=GWEN_DB_GetGroup(dbCurr, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
                                         "data/balancecreditcard");
    if (dbBalance) {
      AB_ACCOUNT_STATUS *acst;
      GWEN_DB_NODE *dbT;
      AB_ACCOUNT *a;
      AB_IMEXPORTER_ACCOUNTINFO *ai;

      DBG_NOTICE(AQHBCI_LOGDOMAIN, "Got a balance");
      if (GWEN_Logger_GetLevel(0)>=GWEN_LoggerLevel_Debug)
        GWEN_DB_Dump(dbBalance, 2);

      acst=AB_AccountStatus_new();

      /* read booked balance */
      dbT=GWEN_DB_GetGroup(dbBalance, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
                           "booked");
      if (dbT) {
        AB_BALANCE *bal;

        bal=AH_Job_GetBalance__ReadBalance(dbT);
        if (bal) {
	  AB_AccountStatus_SetBookedBalance(acst, bal);
	  AB_AccountStatus_SetTime(acst, AB_Balance_GetTime(bal));
          AB_Balance_free(bal);
        }
      }

      /* read noted balance */
      dbT=GWEN_DB_GetGroup(dbBalance, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
                           "noted");
      if (dbT) {
        AB_BALANCE *bal;

        bal=AH_Job_GetBalance__ReadBalance(dbT);
        if (bal) {
	  AB_AccountStatus_SetNotedBalance(acst, bal);
	  if (AB_AccountStatus_GetTime(acst)==NULL)
	    AB_AccountStatus_SetTime(acst, AB_Balance_GetTime(bal));
          AB_Balance_free(bal);
        }
      }

      /* read credit Line */
      dbT=GWEN_DB_GetGroup(dbBalance, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
                           "creditLine");
      if (dbT) {
        AB_VALUE *v;

        v=AB_Value_fromDb(dbT);
        if (!v) {
          DBG_ERROR(AQHBCI_LOGDOMAIN, "Error parsing value from DB");
        }
        else {
          AB_AccountStatus_SetBankLine(acst, v);
        }
        AB_Value_free(v);
      }

      a=AH_AccountJob_GetAccount(j);
      assert(a);
      ai=AB_ImExporterContext_GetAccountInfo(ctx,
                                             AB_Account_GetBankCode(a),
                                             AB_Account_GetAccountNumber(a));
      assert(ai);

      /* add new account status */
      AB_ImExporterAccountInfo_AddAccountStatus(ai, acst);
      break; /* break loop, we found the balance */
    } /* if "Balance" */
    dbCurr=GWEN_DB_GetNextGroup(dbCurr);
  }

  return 0;
}
Example #4
0
/* --------------------------------------------------------------- FUNCTION */
int AH_Job_GetTransactions_Process(AH_JOB *j, AB_IMEXPORTER_CONTEXT *ctx)
{
  AH_JOB_GETTRANSACTIONS *aj;
  AB_ACCOUNT *a;
  AB_IMEXPORTER_ACCOUNTINFO *ai;
  GWEN_DB_NODE *dbResponses;
  GWEN_DB_NODE *dbCurr;
  GWEN_BUFFER *tbooked;
  GWEN_BUFFER *tnoted;
  int rv;

  DBG_INFO(AQHBCI_LOGDOMAIN, "Processing JobGetTransactions");

  assert(j);
  aj=GWEN_INHERIT_GETDATA(AH_JOB, AH_JOB_GETTRANSACTIONS, j);
  assert(aj);

  tbooked=GWEN_Buffer_new(0, 1024, 0, 1);
  tnoted=GWEN_Buffer_new(0, 1024, 0, 1);

  dbResponses=AH_Job_GetResponses(j);
  assert(dbResponses);

  /* search for "Transactions" */
  dbCurr=GWEN_DB_GetFirstGroup(dbResponses);
  while (dbCurr) {
    GWEN_DB_NODE *dbXA;

    rv=AH_Job_CheckEncryption(j, dbCurr);
    if (rv) {
      DBG_INFO(AQHBCI_LOGDOMAIN, "Compromised security (encryption)");
      GWEN_Buffer_free(tbooked);
      GWEN_Buffer_free(tnoted);
      AH_Job_SetStatus(j, AH_JobStatusError);
      return rv;
    }
    rv=AH_Job_CheckSignature(j, dbCurr);
    if (rv) {
      DBG_INFO(AQHBCI_LOGDOMAIN, "Compromised security (signature)");
      GWEN_Buffer_free(tbooked);
      GWEN_Buffer_free(tnoted);
      AH_Job_SetStatus(j, AH_JobStatusError);
      return rv;
    }

    dbXA=GWEN_DB_GetGroup(dbCurr, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
                          "data/transactions");
    if (dbXA) {
      const void *p;
      unsigned int bs;

      if (GWEN_Logger_GetLevel(0)>=GWEN_LoggerLevel_Debug)
        GWEN_DB_Dump(dbXA, 2);
      p=GWEN_DB_GetBinValue(dbXA, "booked", 0, 0, 0, &bs);
      if (p && bs)
        GWEN_Buffer_AppendBytes(tbooked, p, bs);
      p=GWEN_DB_GetBinValue(dbXA, "noted", 0, 0, 0, &bs);
      if (p && bs)
        GWEN_Buffer_AppendBytes(tnoted, p, bs);
    } /* if "Transactions" */
    dbCurr=GWEN_DB_GetNextGroup(dbCurr);
  }

  GWEN_Buffer_Rewind(tbooked);
  GWEN_Buffer_Rewind(tnoted);

  /* now the buffers contain data to be parsed by DBIOs */
  a=AH_AccountJob_GetAccount(j);
  assert(a);
  ai=AB_ImExporterContext_GetOrAddAccountInfo(ctx,
                                              AB_Account_GetUniqueId(a),
                                              AB_Account_GetIban(a),
                                              AB_Account_GetBankCode(a),
                                              AB_Account_GetAccountNumber(a),
                                              AB_Account_GetAccountType(a));
  assert(ai);

  /* read booked transactions */
  if (GWEN_Buffer_GetUsedBytes(tbooked)) {
    if (getenv("AQHBCI_LOGBOOKED")) {
      FILE *f;

      f=fopen("/tmp/booked.mt", "w+");
      if (f) {
        if (fwrite(GWEN_Buffer_GetStart(tbooked),
                   GWEN_Buffer_GetUsedBytes(tbooked), 1, f)!=1) {
          DBG_ERROR(AQHBCI_LOGDOMAIN, "fwrite: %s", strerror(errno));
        }
        if (fclose(f)) {
          DBG_ERROR(AQHBCI_LOGDOMAIN, "fclose: %s", strerror(errno));
        }
      }
    }

    if (AH_Job_GetTransactions__ReadTransactions(j,
                                                 ai,
                                                 "SWIFT-MT940",
                                                 AB_Transaction_TypeStatement,
                                                 (const uint8_t *) GWEN_Buffer_GetStart(tbooked),
                                                 GWEN_Buffer_GetUsedBytes(tbooked))) {
      GWEN_Buffer_free(tbooked);
      GWEN_Buffer_free(tnoted);
      DBG_INFO(AQHBCI_LOGDOMAIN, "Error parsing booked transactions");
      AH_Job_SetStatus(j, AH_JobStatusError);
      return -1;
    }
  }

  /* read noted transactions */
  if (GWEN_Buffer_GetUsedBytes(tnoted)) {
    if (getenv("AQHBCI_LOGNOTED")) {
      FILE *f;

      f=fopen("/tmp/noted.mt", "w+");
      if (f) {
        if (fwrite(GWEN_Buffer_GetStart(tnoted),
                   GWEN_Buffer_GetUsedBytes(tnoted), 1, f)!=1) {
          DBG_ERROR(AQHBCI_LOGDOMAIN, "fwrite: %s", strerror(errno));
        }
        if (fclose(f)) {
          DBG_ERROR(AQHBCI_LOGDOMAIN, "fclose: %s", strerror(errno));
        }
      }
    }

    if (AH_Job_GetTransactions__ReadTransactions(j,
                                                 ai,
                                                 "SWIFT-MT942",
                                                 AB_Transaction_TypeNotedStatement,
                                                 (const uint8_t *) GWEN_Buffer_GetStart(tnoted),
                                                 GWEN_Buffer_GetUsedBytes(tnoted))) {
      GWEN_Buffer_free(tbooked);
      GWEN_Buffer_free(tnoted);
      DBG_INFO(AQHBCI_LOGDOMAIN, "Error parsing noted transactions");
      AH_Job_SetStatus(j, AH_JobStatusError);
      return -1;
    }
  }

  if (GWEN_Logger_GetLevel(AQHBCI_LOGDOMAIN)>=GWEN_LoggerLevel_Debug) {
    GWEN_DB_NODE *gn;
    AB_TRANSACTION *ttmp;

    DBG_INFO(AQHBCI_LOGDOMAIN, "*** Dumping transactions *******************");
    ttmp=AB_ImExporterAccountInfo_GetFirstTransaction(ai, 0, 0);
    while (ttmp) {
      DBG_INFO(AQHBCI_LOGDOMAIN, "*** --------------------------------------");
      gn=GWEN_DB_Group_new("transaction");
      AB_Transaction_toDb(ttmp, gn);
      GWEN_DB_Dump(gn, 2);
      GWEN_DB_Group_free(gn);
      ttmp=AB_Transaction_List_Next(ttmp);
    }

    DBG_INFO(AQHBCI_LOGDOMAIN, "*** End dumping transactions ***************");
  }

  GWEN_Buffer_free(tbooked);
  GWEN_Buffer_free(tnoted);
  return 0;
}
int AB_TransactionLimits_ReadDb(AB_TRANSACTION_LIMITS *st, GWEN_DB_NODE *db) {
  assert(st);
  assert(db);
  AB_TransactionLimits_SetMaxLenLocalName(st, GWEN_DB_GetIntValue(db, "maxLenLocalName", 0, 0));
  AB_TransactionLimits_SetMinLenLocalName(st, GWEN_DB_GetIntValue(db, "minLenLocalName", 0, 0));
  AB_TransactionLimits_SetMaxLenRemoteName(st, GWEN_DB_GetIntValue(db, "maxLenRemoteName", 0, 0));
  AB_TransactionLimits_SetMinLenRemoteName(st, GWEN_DB_GetIntValue(db, "minLenRemoteName", 0, 0));
  AB_TransactionLimits_SetMaxLinesRemoteName(st, GWEN_DB_GetIntValue(db, "maxLinesRemoteName", 0, 0));
  AB_TransactionLimits_SetMinLinesRemoteName(st, GWEN_DB_GetIntValue(db, "minLinesRemoteName", 0, 0));
  AB_TransactionLimits_SetMaxLenLocalBankCode(st, GWEN_DB_GetIntValue(db, "maxLenLocalBankCode", 0, 0));
  AB_TransactionLimits_SetMinLenLocalBankCode(st, GWEN_DB_GetIntValue(db, "minLenLocalBankCode", 0, 0));
  AB_TransactionLimits_SetMaxLenLocalAccountNumber(st, GWEN_DB_GetIntValue(db, "maxLenLocalAccountNumber", 0, 0));
  AB_TransactionLimits_SetMinLenLocalAccountNumber(st, GWEN_DB_GetIntValue(db, "minLenLocalAccountNumber", 0, 0));
  AB_TransactionLimits_SetMaxLenLocalSuffix(st, GWEN_DB_GetIntValue(db, "maxLenLocalSuffix", 0, 0));
  AB_TransactionLimits_SetMinLenLocalSuffix(st, GWEN_DB_GetIntValue(db, "minLenLocalSuffix", 0, 0));
  AB_TransactionLimits_SetMaxLenRemoteBankCode(st, GWEN_DB_GetIntValue(db, "maxLenRemoteBankCode", 0, 0));
  AB_TransactionLimits_SetMinLenRemoteBankCode(st, GWEN_DB_GetIntValue(db, "minLenRemoteBankCode", 0, 0));
  AB_TransactionLimits_SetMaxLenRemoteAccountNumber(st, GWEN_DB_GetIntValue(db, "maxLenRemoteAccountNumber", 0, 0));
  AB_TransactionLimits_SetMinLenRemoteAccountNumber(st, GWEN_DB_GetIntValue(db, "minLenRemoteAccountNumber", 0, 0));
  AB_TransactionLimits_SetMaxLenRemoteSuffix(st, GWEN_DB_GetIntValue(db, "maxLenRemoteSuffix", 0, 0));
  AB_TransactionLimits_SetMinLenRemoteSuffix(st, GWEN_DB_GetIntValue(db, "minLenRemoteSuffix", 0, 0));
  AB_TransactionLimits_SetMaxLenRemoteIban(st, GWEN_DB_GetIntValue(db, "maxLenRemoteIban", 0, 0));
  AB_TransactionLimits_SetMinLenRemoteIban(st, GWEN_DB_GetIntValue(db, "minLenRemoteIban", 0, 0));
  AB_TransactionLimits_SetMaxLenTextKey(st, GWEN_DB_GetIntValue(db, "maxLenTextKey", 0, 0));
  AB_TransactionLimits_SetMinLenTextKey(st, GWEN_DB_GetIntValue(db, "minLenTextKey", 0, 0));
  if (1) {
    int i;

    for (i=0; ; i++) {
      const char *s;

      s=GWEN_DB_GetCharValue(db, "valuesTextKey", i, 0);
      if (!s)
        break;
      AB_TransactionLimits_AddValuesTextKey(st, s, 0);
    } /* for */
  }
  st->textKeys=AB_TextKeyDescr_List_new();
  if (1) {/* just for local vars */
    GWEN_DB_NODE *dbT;
    AB_TEXTKEY_DESCR *e;

    dbT=GWEN_DB_GetGroup(db, GWEN_PATH_FLAGS_NAMEMUSTEXIST, "textKeys");
    if (dbT) {
      GWEN_DB_NODE *dbT2;

      dbT2=GWEN_DB_FindFirstGroup(dbT, "element");
      while(dbT2) {
        e=AB_TextKeyDescr_fromDb(dbT2);
        if (!e) {
          DBG_ERROR(0, "Bad element for type \"AB_TEXTKEY_DESCR\"");
          if (GWEN_Logger_GetLevel(0)>=GWEN_LoggerLevel_Debug)
            GWEN_DB_Dump(dbT2, 2);
          AB_TransactionLimits_free(st);
          return 0;
        }
        AB_TextKeyDescr_List_Add(e, st->textKeys);    dbT2=GWEN_DB_FindNextGroup(dbT2, "element");
      } /* while */
    } /* if (dbT) */
  } /* if (1) */
  AB_TransactionLimits_SetMaxLenCustomerReference(st, GWEN_DB_GetIntValue(db, "maxLenCustomerReference", 0, 0));
  AB_TransactionLimits_SetMinLenCustomerReference(st, GWEN_DB_GetIntValue(db, "minLenCustomerReference", 0, 0));
  AB_TransactionLimits_SetMaxLenBankReference(st, GWEN_DB_GetIntValue(db, "maxLenBankReference", 0, 0));
  AB_TransactionLimits_SetMinLenBankReference(st, GWEN_DB_GetIntValue(db, "minLenBankReference", 0, 0));
  AB_TransactionLimits_SetMaxLenPurpose(st, GWEN_DB_GetIntValue(db, "maxLenPurpose", 0, 0));
  AB_TransactionLimits_SetMinLenPurpose(st, GWEN_DB_GetIntValue(db, "minLenPurpose", 0, 0));
  AB_TransactionLimits_SetMaxLinesPurpose(st, GWEN_DB_GetIntValue(db, "maxLinesPurpose", 0, 0));
  AB_TransactionLimits_SetMinLinesPurpose(st, GWEN_DB_GetIntValue(db, "minLinesPurpose", 0, 0));
  AB_TransactionLimits_SetNeedDate(st, GWEN_DB_GetIntValue(db, "needDate", 0, 0));
  AB_TransactionLimits_SetMinValueSetupTime(st, GWEN_DB_GetIntValue(db, "minValueSetupTime", 0, 0));
  AB_TransactionLimits_SetMaxValueSetupTime(st, GWEN_DB_GetIntValue(db, "maxValueSetupTime", 0, 0));
  AB_TransactionLimits_SetMinValueSetupTimeFirst(st, GWEN_DB_GetIntValue(db, "minValueSetupTimeFirst", 0, 0));
  AB_TransactionLimits_SetMaxValueSetupTimeFirst(st, GWEN_DB_GetIntValue(db, "maxValueSetupTimeFirst", 0, 0));
  AB_TransactionLimits_SetMinValueSetupTimeOnce(st, GWEN_DB_GetIntValue(db, "minValueSetupTimeOnce", 0, 0));
  AB_TransactionLimits_SetMaxValueSetupTimeOnce(st, GWEN_DB_GetIntValue(db, "maxValueSetupTimeOnce", 0, 0));
  AB_TransactionLimits_SetMinValueSetupTimeRecurring(st, GWEN_DB_GetIntValue(db, "minValueSetupTimeRecurring", 0, 0));
  AB_TransactionLimits_SetMaxValueSetupTimeRecurring(st, GWEN_DB_GetIntValue(db, "maxValueSetupTimeRecurring", 0, 0));
  AB_TransactionLimits_SetMinValueSetupTimeFinal(st, GWEN_DB_GetIntValue(db, "minValueSetupTimeFinal", 0, 0));
  AB_TransactionLimits_SetMaxValueSetupTimeFinal(st, GWEN_DB_GetIntValue(db, "maxValueSetupTimeFinal", 0, 0));
  if (1) {
    int i;

    for (i=0; ; i++) {
      const char *s;

      s=GWEN_DB_GetCharValue(db, "valuesCycleWeek", i, 0);
      if (!s)
        break;
      AB_TransactionLimits_AddValuesCycleWeek(st, s, 0);
    } /* for */
  }
  if (1) {
    int i;

    for (i=0; ; i++) {
      const char *s;

      s=GWEN_DB_GetCharValue(db, "valuesCycleMonth", i, 0);
      if (!s)
        break;
      AB_TransactionLimits_AddValuesCycleMonth(st, s, 0);
    } /* for */
  }
  if (1) {
    int i;

    for (i=0; ; i++) {
      const char *s;

      s=GWEN_DB_GetCharValue(db, "valuesExecutionDayWeek", i, 0);
      if (!s)
        break;
      AB_TransactionLimits_AddValuesExecutionDayWeek(st, s, 0);
    } /* for */
  }
  if (1) {
    int i;

    for (i=0; ; i++) {
      const char *s;

      s=GWEN_DB_GetCharValue(db, "valuesExecutionDayMonth", i, 0);
      if (!s)
        break;
      AB_TransactionLimits_AddValuesExecutionDayMonth(st, s, 0);
    } /* for */
  }
  AB_TransactionLimits_SetAllowMonthly(st, GWEN_DB_GetIntValue(db, "allowMonthly", 0, 0));
  AB_TransactionLimits_SetAllowWeekly(st, GWEN_DB_GetIntValue(db, "allowWeekly", 0, 0));
  AB_TransactionLimits_SetAllowChangeRecipientAccount(st, GWEN_DB_GetIntValue(db, "allowChangeRecipientAccount", 0, 0));
  AB_TransactionLimits_SetAllowChangeRecipientName(st, GWEN_DB_GetIntValue(db, "allowChangeRecipientName", 0, 0));
  AB_TransactionLimits_SetAllowChangeValue(st, GWEN_DB_GetIntValue(db, "allowChangeValue", 0, 0));
  AB_TransactionLimits_SetAllowChangeTextKey(st, GWEN_DB_GetIntValue(db, "allowChangeTextKey", 0, 0));
  AB_TransactionLimits_SetAllowChangePurpose(st, GWEN_DB_GetIntValue(db, "allowChangePurpose", 0, 0));
  AB_TransactionLimits_SetAllowChangeFirstExecutionDate(st, GWEN_DB_GetIntValue(db, "allowChangeFirstExecutionDate", 0, 0));
  AB_TransactionLimits_SetAllowChangeLastExecutionDate(st, GWEN_DB_GetIntValue(db, "allowChangeLastExecutionDate", 0, 0));
  AB_TransactionLimits_SetAllowChangeCycle(st, GWEN_DB_GetIntValue(db, "allowChangeCycle", 0, 0));
  AB_TransactionLimits_SetAllowChangePeriod(st, GWEN_DB_GetIntValue(db, "allowChangePeriod", 0, 0));
  AB_TransactionLimits_SetAllowChangeExecutionDay(st, GWEN_DB_GetIntValue(db, "allowChangeExecutionDay", 0, 0));
  return 0;
}