int AB_ImExporterYN__ReadAccountStatus(AB_IMEXPORTER *ie,
AB_IMEXPORTER_ACCOUNTINFO *ai,
GWEN_XMLNODE *doc) {
GWEN_XMLNODE *n;
n=GWEN_XMLNode_FindFirstTag(doc, "SG4", 0, 0);
while(n) {
GWEN_XMLNODE *nn;
nn=GWEN_XMLNode_GetNodeByXPath(n, "LIN/PF:D_0805",
GWEN_PATH_FLAGS_NAMEMUSTEXIST);
if (nn) {
const char *s;
s=GWEN_XMLNode_GetProperty(nn, "Value", 0);
if (s && strcasecmp(s, "LEN")==0) {
GWEN_XMLNODE *nnn;
GWEN_TIME *ti=0;
AB_VALUE *val=0;
/* read time */
nnn=GWEN_XMLNode_GetNodeByXPath(n, "SG5/DTM",
GWEN_PATH_FLAGS_NAMEMUSTEXIST);
if (nnn)
ti=AB_ImExporterYN__ReadTime(ie, nnn, 202);
/* read value */
nnn=GWEN_XMLNode_GetNodeByXPath(n, "SG5/MOA",
GWEN_PATH_FLAGS_NAMEMUSTEXIST);
if (nnn)
val=AB_ImExporterYN__ReadValue(ie, nnn, 343);
if (val) {
AB_ACCOUNT_STATUS *ast;
AB_BALANCE *bal;
AB_Value_SetCurrency(val, AB_ImExporterAccountInfo_GetCurrency(ai));
ast=AB_AccountStatus_new();
bal=AB_Balance_new(val, ti);
AB_AccountStatus_SetBookedBalance(ast, bal);
AB_Balance_free(bal);
AB_ImExporterAccountInfo_AddAccountStatus(ai, ast);
}
AB_Value_free(val);
GWEN_Time_free(ti);
}
}
n=GWEN_XMLNode_FindNextTag(n, "SG4", 0, 0);
}
return 0;
}
/**
* Create a new AB_TRANSACTION, fill the values from the entry fields into it
* and return it. The caller must AB_TRANSACTION_free() it when finished.
*/
static AB_TRANSACTION *
ab_trans_fill_values(GncABTransDialog *td)
{
/* Fill in the user-entered values */
AB_TRANSACTION *trans = AB_Transaction_new();
AB_VALUE *value;
AB_Transaction_SetLocalBankCode(trans, AB_Account_GetBankCode(td->ab_acc));
AB_Transaction_SetLocalAccountNumber(
trans, AB_Account_GetAccountNumber(td->ab_acc));
AB_Transaction_SetLocalCountry(trans, "DE");
AB_Transaction_SetRemoteBankCode(
trans, gtk_entry_get_text(GTK_ENTRY(td->recp_bankcode_entry)));
AB_Transaction_SetRemoteAccountNumber(
trans, gtk_entry_get_text(GTK_ENTRY(td->recp_account_entry)));
AB_Transaction_SetRemoteCountry(trans, "DE");
AB_Transaction_AddRemoteName(
trans, gtk_entry_get_text(GTK_ENTRY(td->recp_name_entry)), FALSE);
AB_Transaction_AddPurpose(
trans, gtk_entry_get_text(GTK_ENTRY(td->purpose_entry)), FALSE);
AB_Transaction_AddPurpose(
trans, gtk_entry_get_text(GTK_ENTRY(td->purpose_cont_entry)), FALSE);
AB_Transaction_AddPurpose(
trans, gtk_entry_get_text(GTK_ENTRY(td->purpose_cont2_entry)), FALSE);
AB_Transaction_AddPurpose(
trans, gtk_entry_get_text(GTK_ENTRY(td->purpose_cont3_entry)), FALSE);
value = AB_Value_fromDouble(gnc_amount_edit_get_damount(
GNC_AMOUNT_EDIT(td->amount_edit)));
/* FIXME: Replace "EUR" by account-dependent string here. */
AB_Value_SetCurrency(value, "EUR");
AB_Transaction_SetValue(trans, value);
AB_Value_free(value);
/* If this is a direct debit, a textkey/ "Textschluessel"/transactionCode
* different from the default has to be set. */
switch (td->trans_type)
{
case SINGLE_DEBITNOTE:
/* AB_Transaction_SetTransactionCode (trans, 05); */
AB_Transaction_SetTextKey(trans, 05);
break;
default:
/* AB_Transaction_SetTransactionCode (trans, 51); */
AB_Transaction_SetTextKey (trans, 51);
break;
}
return trans;
}
static
void _dumpBal(const AB_BALANCE *bal,
const GWEN_TIME *ti,
FILE *fd) {
if (bal) {
const GWEN_TIME *bti;
const AB_VALUE *val;
bti=AB_Balance_GetTime(bal);
if (bti==0)
bti=ti;
if (bti) {
GWEN_BUFFER *tbuf;
tbuf=GWEN_Buffer_new(0, 24, 0, 1);
GWEN_Time_toString(bti, "DD.MM.YYYY\thh:mm", tbuf);
fprintf(fd, "%s\t", GWEN_Buffer_GetStart(tbuf));
GWEN_Buffer_free(tbuf);
}
else {
fprintf(fd, "\t\t");
}
val=AB_Balance_GetValue(bal);
if (val) {
AB_VALUE *vNew;
GWEN_BUFFER *vbuf;
const char *cur;
vNew=AB_Value_dup(val);
AB_Value_SetCurrency(vNew, NULL);
vbuf=GWEN_Buffer_new(0, 32, 0, 1);
AB_Value_toHumanReadableString(vNew, vbuf, 2);
fprintf(fd, "%s\t", GWEN_Buffer_GetStart(vbuf));
GWEN_Buffer_free(vbuf);
AB_Value_free(vNew);
cur=AB_Value_GetCurrency(val);
if (cur)
fprintf(fd, "%s\t", cur);
else
fprintf(fd, "\t");
}
else {
fprintf(fd, "\t\t");
}
}
else {
fprintf(fd, "\t\t\t\t");
}
}
AB_TRANSACTION *AB_ImExporterYN__ReadLNE_LNS(AB_IMEXPORTER *ie,
AB_IMEXPORTER_ACCOUNTINFO *ai,
GWEN_XMLNODE *node)
{
AB_TRANSACTION *t;
GWEN_XMLNODE *nn;
GWEN_DATE *da=NULL;
AB_VALUE *val=NULL;
t=AB_Transaction_new();
/* get date */
nn=GWEN_XMLNode_FindFirstTag(node, "DTM", 0, 0);
if (nn)
da=AB_ImExporterYN__ReadDate(ie, nn, 209);
AB_Transaction_SetValutaDate(t, da);
GWEN_Date_free(da);
da=NULL;
/* read amount */
nn=GWEN_XMLNode_FindFirstTag(node, "MOA", 0, 0);
if (nn) {
/* Gutschrift */
val=AB_ImExporterYN__ReadValue(ie, nn, 210);
if (val) {
if (AB_Value_IsZero(val)) {
AB_Value_free(val);
val=NULL;
}
}
if (val==NULL) {
val=AB_ImExporterYN__ReadValue(ie, nn, 211);
if (val)
AB_Value_Negate(val);
}
}
if (val==NULL)
val=AB_Value_new();
AB_Value_SetCurrency(val, AB_ImExporterAccountInfo_GetCurrency(ai));
AB_Transaction_SetValue(t, val);
AB_Value_free(val);
val=0;
/* read purpose */
nn=GWEN_XMLNode_GetNodeByXPath(node, "FTX/C108",
GWEN_PATH_FLAGS_NAMEMUSTEXIST);
if (nn) {
GWEN_XMLNODE *nnn;
nnn=GWEN_XMLNode_FindFirstTag(nn, "D_4440", 0, 0);
while (nnn) {
GWEN_XMLNODE *nData;
nData=GWEN_XMLNode_GetFirstData(nnn);
if (nData) {
const char *s;
s=GWEN_XMLNode_GetData(nData);
if (s) {
GWEN_BUFFER *xbuf;
xbuf=GWEN_Buffer_new(0, 256, 0, 1);
AB_ImExporter_Iso8859_1ToUtf8(s, strlen(s), xbuf);
AB_Transaction_AddPurposeLine(t, GWEN_Buffer_GetStart(xbuf));
GWEN_Buffer_free(xbuf);
}
}
nnn=GWEN_XMLNode_FindNextTag(nnn, "D_4440", 0, 0);
}
}
return t;
}
int AHB_DTAUS__Export(GWEN_DBIO *dbio,
GWEN_SYNCIO *sio,
GWEN_DB_NODE *data,
GWEN_DB_NODE *cfg,
uint32_t flags){
AB_VALUE *sumEUR;
AB_VALUE *sumDEM;
AB_VALUE *sumBankCodes;
AB_VALUE *sumAccountIds;
unsigned int cSets;
GWEN_BUFFER *dst;
GWEN_DB_NODE *gr;
int isDebitNote;
//int isEuro;
const uint8_t *p;
uint32_t size;
int rv;
isDebitNote=(strcasecmp(GWEN_DB_GetCharValue(cfg, "type", 0, "transfer"),
"debitnote")==0);
//isEuro=(strcasecmp(GWEN_DB_GetCharValue(cfg, "currency", 0, "EUR"),
// "EUR")==0);
cSets=0;
sumEUR=AB_Value_new();
sumDEM=AB_Value_new();
sumBankCodes=AB_Value_new();
sumAccountIds=AB_Value_new();
dst=GWEN_Buffer_new(0, 1024, 0, 1);
GWEN_Buffer_SetHardLimit(dst, AHB_DTAUS_HARDLIMIT);
/* create A set */
if (AHB_DTAUS__CreateSetA(dst, cfg)) {
DBG_INFO(AQBANKING_LOGDOMAIN, "Error creating A set");
GWEN_Buffer_free(dst);
AB_Value_free(sumAccountIds);
AB_Value_free(sumBankCodes);
AB_Value_free(sumDEM);
AB_Value_free(sumEUR);
return -1;
}
/* create C sets */
gr=GWEN_DB_GetFirstGroup(data);
while(gr) {
const char *gn;
gn=GWEN_DB_GroupName(gr);
if ((isDebitNote && strcasecmp(gn, "debitnote")==0) ||
(!isDebitNote &&
(strcasecmp(gn, "transfer")==0 ||
strcasecmp(gn, "transaction")==0))){
if (AHB_DTAUS__CreateSetC(dst, cfg, gr,
sumEUR, sumDEM,
sumBankCodes, sumAccountIds)) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error creating C set from this data:");
GWEN_DB_Dump(gr, 2);
GWEN_Buffer_free(dst);
AB_Value_free(sumAccountIds);
AB_Value_free(sumBankCodes);
AB_Value_free(sumDEM);
AB_Value_free(sumEUR);
return -1;
}
cSets++;
} /* if group matches */
else {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Ignoring group [%s]",
GWEN_DB_GroupName(gr));
}
gr=GWEN_DB_GetNextGroup(gr);
} /* while */
/* create E set */
if (AHB_DTAUS__CreateSetE(dst, cfg, cSets,
sumEUR, sumDEM,
sumBankCodes, sumAccountIds)) {
DBG_INFO(AQBANKING_LOGDOMAIN, "Error creating E set");
GWEN_Buffer_free(dst);
AB_Value_free(sumAccountIds);
AB_Value_free(sumBankCodes);
AB_Value_free(sumDEM);
AB_Value_free(sumEUR);
return -1;
}
AB_Value_free(sumAccountIds);
AB_Value_free(sumBankCodes);
AB_Value_free(sumDEM);
AB_Value_free(sumEUR);
/* DTAUS finished, write it */
p=(const uint8_t*)GWEN_Buffer_GetStart(dst);
size=GWEN_Buffer_GetUsedBytes(dst);
rv=GWEN_SyncIo_WriteForced(sio, p, size);
if (rv<0) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Broken pipe");
GWEN_Buffer_free(dst);
return GWEN_ERROR_IO;
}
GWEN_Buffer_free(dst);
return 0;
}
int AHB_DTAUS__CreateSetC(GWEN_BUFFER *dst,
GWEN_DB_NODE *cfg,
GWEN_DB_NODE *xa,
AB_VALUE *sumEUR,
AB_VALUE *sumDEM,
AB_VALUE *sumBankCodes,
AB_VALUE *sumAccountIds){
unsigned int i;
const char *p;
char buffer[32];
int isDebitNote;
int isEuro;
unsigned int extSets;
//unsigned int startPos;
AB_VALUE *val;
GWEN_STRINGLIST *purposeList;
DBG_DEBUG(AQBANKING_LOGDOMAIN, "Creating C set");
/* ______________________________________________________________________
* preparations
*/
purposeList=GWEN_StringList_new();
/* cut purpose lines into manageable portions (max 27 chars) */
for (i=0; ; i++) {
int slen;
GWEN_BUFFER *nbuf;
p=GWEN_DB_GetCharValue(xa, "purpose", i, 0);
if (p==NULL)
break;
if (i>14) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Too many purpose lines (maxmimum is 14)");
GWEN_StringList_free(purposeList);
return -1;
}
slen=strlen(p);
nbuf=GWEN_Buffer_new(0, slen+1, 0, 1);
AB_ImExporter_Utf8ToDta(p, -1, nbuf);
p=GWEN_Buffer_GetStart(nbuf);
while(*p) {
while(*p>0 && *p<33)
p++;
slen=strlen(p);
if (slen==0)
break;
else if (slen>27) {
char *ns;
ns=(char*) malloc(28);
assert(ns);
memmove(ns, p, 27);
ns[27]=0;
/* let stringlist take over ownership of the the string */
GWEN_StringList_AppendString(purposeList, ns, 1, 0);
p+=27;
}
else {
GWEN_StringList_AppendString(purposeList, p, 0, 0);
break;
}
}
GWEN_Buffer_free(nbuf);
} /* for */
//startPos=GWEN_Buffer_GetPos(dst);
GWEN_Buffer_AllocRoom(dst, 256);
isDebitNote=(strcasecmp(GWEN_DB_GetCharValue(cfg, "type", 0, "transfer"),
"debitnote")==0);
isEuro=(strcasecmp(GWEN_DB_GetCharValue(cfg, "currency", 0, "EUR"),
"EUR")==0);
/* compute number of extension sets */
extSets=0;
/* add purpose */
if (GWEN_StringList_Count(purposeList))
extSets+=GWEN_StringList_Count(purposeList)-1;
/* add name */
for (i=1; i<2; i++) { /* max 1 extset for local name */
if (GWEN_DB_GetCharValue(xa, "localName", i, 0)==0)
break;
if (i>1) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Too many name lines (maxmimum is 2)");
GWEN_StringList_free(purposeList);
return -1;
}
extSets++;
} /* for */
/* add other name */
for (i=1; i<2; i++) { /* max 1 extset for remote name */
if (GWEN_DB_GetCharValue(xa, "remoteName", i, 0)==0)
break;
if (i>1) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Too many peer name lines (maxmimum is 2)");
GWEN_StringList_free(purposeList);
return -1;
}
extSets++;
} /* for */
/* check number of extension sets */
if (extSets>15) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Too many extension sets (%d)", extSets);
GWEN_StringList_free(purposeList);
return -1;
}
/* ______________________________________________________________________
* actually write C set
*/
/* field 1, 2: record header */
snprintf(buffer, sizeof(buffer), "%04d", 187+(extSets*29));
GWEN_Buffer_AppendString(dst, buffer);
GWEN_Buffer_AppendByte(dst, 'C');
/* field 3: acting bank code */
if (AHB_DTAUS__AddNum(dst, 8, GWEN_DB_GetCharValue(cfg, "bankCode", 0, ""))) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
/* field 4: destination bank code */
p=GWEN_DB_GetCharValue(xa, "remoteBankCode", 0, 0);
if (p) {
val=AB_Value_fromString(p);
if (val==NULL) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Bad bank code");
GWEN_StringList_free(purposeList);
return -1;
}
AB_Value_AddValue(sumBankCodes, val);
AB_Value_free(val);
if (AHB_DTAUS__AddNum(dst, 8, p)) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
}
else {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Peer bank code missing");
GWEN_StringList_free(purposeList);
return -1;
}
/* field 5: destination account id */
p=GWEN_DB_GetCharValue(xa, "remoteAccountNumber", 0, 0);
if (p) {
val=AB_Value_fromString(p);
if (val==NULL) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Bad account id");
GWEN_StringList_free(purposeList);
return -1;
}
AB_Value_AddValue(sumAccountIds, val);
AB_Value_free(val);
if (AHB_DTAUS__AddNum(dst, 10, p)) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
}
else {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Peer account id missing");
GWEN_StringList_free(purposeList);
return -1;
}
/* field 6: internal customer number (0s for now) */
for (i=0; i<13; i++) GWEN_Buffer_AppendByte(dst, '0');
/* field 7a: text key */
snprintf(buffer, sizeof(buffer), "%02d", GWEN_DB_GetIntValue(xa, "textkey", 0, isDebitNote?5:51));
if (AHB_DTAUS__AddNum(dst, 2, buffer)) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
/* field 7b: text key extension */
snprintf(buffer, sizeof(buffer), "%03d", GWEN_DB_GetIntValue(xa, "textkeyext", 0, 0));
if (AHB_DTAUS__AddNum(dst, 3, buffer)) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
/* field 8: bank internal field */
GWEN_Buffer_AppendByte(dst, ' ');
/* field 9: value in DEM */
if (!isEuro) {
val=AB_Value_fromString(GWEN_DB_GetCharValue(xa, "value/value", 0, "0,0"));
if (val==NULL || AB_Value_IsZero(val)) {
AB_Value_free(val);
DBG_ERROR(AQBANKING_LOGDOMAIN, "Bad DEM value:");
GWEN_StringList_free(purposeList);
return -1;
}
AB_Value_AddValue(sumDEM, val);
snprintf(buffer, sizeof(buffer), "%011.0f", AB_Value_GetValueAsDouble(val)*100.0);
AB_Value_free(val);
if (AHB_DTAUS__AddNum(dst, 11, buffer)) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
}
else {
if (AHB_DTAUS__AddNum(dst, 11, "0")) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
}
/* field 10: local bank code */
p=GWEN_DB_GetCharValue(xa, "localbankCode", 0, 0);
if (!p)
p=GWEN_DB_GetCharValue(cfg, "bankCode", 0, 0);
if (!p) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "No local bank code");
GWEN_StringList_free(purposeList);
return -1;
}
if (AHB_DTAUS__AddNum(dst, 8, p)) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
/* field 11: local account id */
p=GWEN_DB_GetCharValue(xa, "localAccountNumber", 0, 0);
if (!p)
GWEN_DB_GetCharValue(cfg, "accountId", 0, 0);
if (!p) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "No local account number");
GWEN_StringList_free(purposeList);
return -1;
}
if (AHB_DTAUS__AddNum(dst, 10, p)) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
/* field 12: value in EUR */
if (isEuro) {
val=AB_Value_fromString(GWEN_DB_GetCharValue(xa, "value/value", 0, "0,0"));
if (val==NULL || AB_Value_IsZero(val)) {
AB_Value_free(val);
DBG_ERROR(AQBANKING_LOGDOMAIN, "Bad EUR value:");
GWEN_StringList_free(purposeList);
return -1;
}
AB_Value_AddValue(sumEUR, val);
snprintf(buffer, sizeof(buffer), "%011.0f", AB_Value_GetValueAsDouble(val)*100.0);
AB_Value_free(val);
if (AHB_DTAUS__AddNum(dst, 11, buffer)) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
}
else {
if (AHB_DTAUS__AddNum(dst, 11, "0")) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
}
/* field 13: blanks */
for (i=0; i<3; i++) GWEN_Buffer_AppendByte(dst, ' ');
/* field 14a: peer name */
if (AHB_DTAUS__AddWord(dst, 27, GWEN_DB_GetCharValue(xa, "remoteName", 0, ""))) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
/* field 14b: blanks */
for (i=0; i<8; i++) GWEN_Buffer_AppendByte(dst, ' ');
/* field 15: name */
if (AHB_DTAUS__AddWord(dst, 27, GWEN_DB_GetCharValue(xa, "localname", 0, ""))) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
/* field 16: purpose */
p=GWEN_StringList_FirstString(purposeList);
if (p==NULL)
p="";
if (AHB_DTAUS__AddWord(dst, 27, p)) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
/* field 17a: currency */
if (isEuro)
GWEN_Buffer_AppendByte(dst, '1');
else
GWEN_Buffer_AppendByte(dst, ' ');
/* field 17b: blanks */
for (i=0; i<2; i++) GWEN_Buffer_AppendByte(dst, ' ');
/* field 18: number of extension sets */
snprintf(buffer, sizeof(buffer), "%02d", extSets);
if (AHB_DTAUS__AddNum(dst, 2, buffer)) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
if (extSets) {
unsigned int writtenExtSets=0;
/* now append extension sets */
/* add peer name lines */
for (i=1; i<2; i++) { /* max: 1 extset */
unsigned int j;
p=GWEN_DB_GetCharValue(xa, "remoteName", i, 0);
if (!p)
break;
/* append extension set */
GWEN_Buffer_AppendString(dst, "01");
if (AHB_DTAUS__AddWord(dst, 27, p)) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
writtenExtSets++;
if (writtenExtSets==2)
/* 2 ext sets written, so we need to align "C 2.Satzabschnitt" to 128 now */
for (j=0; j<11; j++) GWEN_Buffer_AppendByte(dst, ' ');
else if (writtenExtSets>2 && ((writtenExtSets-2) % 4)==0)
/* "C 3-5.Satzabschnitt" complete, align to 128 bytes */
for (j=0; j<12; j++) GWEN_Buffer_AppendByte(dst, ' ');
} /* for */
/* add purpose lines */
for (i=1; i<GWEN_StringList_Count(purposeList); i++) {
unsigned int j;
p=GWEN_StringList_StringAt(purposeList, i);
if (!p)
break;
/* append extension set */
GWEN_Buffer_AppendString(dst, "02");
/* strings in the list are already in DTA charset */
if (AHB_DTAUS__AddDtaWord(dst, 27, p)) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
writtenExtSets++;
if (writtenExtSets==2)
/* 2 ext sets written, so we need to align "C 2.Satzabschnitt" to 128 now */
for (j=0; j<11; j++) GWEN_Buffer_AppendByte(dst, ' ');
else if (writtenExtSets>2 && ((writtenExtSets-2) % 4)==0)
/* "C 3-5.Satzabschnitt" complete, align to 128 bytes */
for (j=0; j<12; j++) GWEN_Buffer_AppendByte(dst, ' ');
} /* for */
/* add name lines */
for (i=1; i<2; i++) { /* max: 1 extset */
unsigned int j;
p=GWEN_DB_GetCharValue(xa, "localname", i, 0);
if (!p)
break;
/* append extension set */
GWEN_Buffer_AppendString(dst, "03");
if (AHB_DTAUS__AddWord(dst, 27, p)) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
writtenExtSets++;
if (writtenExtSets==2)
/* 2 ext sets written, so we need to align "C 2.Satzabschnitt" to 128 now */
for (j=0; j<11; j++) GWEN_Buffer_AppendByte(dst, ' ');
else if (writtenExtSets>2 && ((writtenExtSets-2) % 4)==0)
/* "C 3-5.Satzabschnitt" complete, align to 128 bytes */
for (j=0; j<12; j++) GWEN_Buffer_AppendByte(dst, ' ');
} /* for */
}
i=((GWEN_Buffer_GetUsedBytes(dst)+127) & ~127)-GWEN_Buffer_GetUsedBytes(dst);
while(i--)
GWEN_Buffer_AppendByte(dst, ' ');
GWEN_StringList_free(purposeList);
return 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;
}
/* --------------------------------------------------------------- FUNCTION */
AB_BALANCE *AH_Job_GetBalance__ReadBalance(GWEN_DB_NODE *dbT) {
GWEN_BUFFER *buf;
GWEN_TIME *t;
AB_VALUE *v1, *v2;
AB_BALANCE *bal;
const char *p;
bal=0;
/* read date and time */
buf=GWEN_Buffer_new(0, 32, 0, 1);
p=GWEN_DB_GetCharValue(dbT, "date", 0, 0);
if (p)
GWEN_Buffer_AppendString(buf, p);
else {
AH_AccountJob_AddCurrentDate(buf);
}
p=GWEN_DB_GetCharValue(dbT, "time", 0, 0);
if (p)
GWEN_Buffer_AppendString(buf, p);
else {
AH_AccountJob_AddCurrentTime(buf);
}
t=GWEN_Time_fromString(GWEN_Buffer_GetStart(buf), "YYYYMMDDhhmmss");
if (!t) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Error parsing date and time");
}
GWEN_Buffer_free(buf);
/* read value */
v1=AB_Value_fromDb(dbT);
v2=0;
if (!v1) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Error parsing value from DB");
}
else {
p=GWEN_DB_GetCharValue(dbT, "debitMark", 0, 0);
if (p) {
if (strcasecmp(p, "D")==0 ||
strcasecmp(p, "RC")==0) {
v2=AB_Value_dup(v1);
AB_Value_Negate(v2);
}
else if (strcasecmp(p, "C")==0 ||
strcasecmp(p, "RD")==0)
v2=AB_Value_dup(v1);
else {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Bad debit mark \"%s\"", p);
v2=0;
}
}
if (v2)
bal=AB_Balance_new(v2, t);
else
bal=0;
}
AB_Value_free(v2);
AB_Value_free(v1);
GWEN_Time_free(t);
return bal;
}
AB_TRANSACTION *mkSepaTransfer(AB_ACCOUNT *a, GWEN_DB_NODE *db, int expTransferType) {
AB_BANKING *ab;
AB_TRANSACTION *t;
const char *s;
int i;
GWEN_TIME *d;
assert(a);
assert(db);
ab=AB_Account_GetBanking(a);
assert(ab);
t=AB_Transaction_new();
AB_Banking_FillGapsInTransaction(ab, a, t);
s=GWEN_DB_GetCharValue(db, "name", 0, 0);
if (s && *s)
AB_Transaction_SetLocalName(t, s);
/* remote account */
s=GWEN_DB_GetCharValue(db, "remoteBankId", 0, 0);
if (s && *s)
AB_Transaction_SetRemoteBankCode(t, s);
s=GWEN_DB_GetCharValue(db, "remoteAccountId", 0, 0);
if (s && *s)
AB_Transaction_SetRemoteAccountNumber(t, s);
s=GWEN_DB_GetCharValue(db, "remoteIban", 0, 0);
if (s && *s)
AB_Transaction_SetRemoteIban(t, s);
else {
DBG_ERROR(0, "No remote IBAN given");
AB_Transaction_free(t);
return NULL;
}
s=GWEN_DB_GetCharValue(db, "remoteBic", 0, 0);
if (s && *s)
AB_Transaction_SetRemoteBic(t, s);
else if (strncmp(AB_Transaction_GetLocalIban(t),
AB_Transaction_GetRemoteIban(t), 2)) {
DBG_ERROR(0, "Remote BIC id required for international transaction");
AB_Transaction_free(t);
return NULL;
}
for (i=0; i<10; i++) {
s=GWEN_DB_GetCharValue(db, "remoteName", i, 0);
if (!s)
break;
if (*s)
AB_Transaction_AddRemoteName(t, s, 0);
}
if (i<1) {
DBG_ERROR(0, "No remote name given");
AB_Transaction_free(t);
return NULL;
}
/* transfer data */
for (i=0; i<20; i++) {
s=GWEN_DB_GetCharValue(db, "purpose", i, 0);
if (!s)
break;
if (*s)
AB_Transaction_AddPurpose(t, s, 0);
}
if (i<1) {
DBG_ERROR(0, "No purpose given");
AB_Transaction_free(t);
return NULL;
}
i=GWEN_DB_GetIntValue(db, "textkey", 0, -1);
if (i>0)
AB_Transaction_SetTextKey(t, i);
s=GWEN_DB_GetCharValue(db, "value", 0, 0);
if (s && *s) {
AB_VALUE *v;
v=AB_Value_fromString(s);
assert(v);
if (AB_Value_IsNegative(v) || AB_Value_IsZero(v)) {
DBG_ERROR(0, "Only positive non-zero amount allowed");
AB_Transaction_free(t);
return NULL;
}
AB_Transaction_SetValue(t, v);
AB_Value_free(v);
}
else {
DBG_ERROR(0, "No value given");
AB_Transaction_free(t);
return NULL;
}
/* dated transfer, SEPA debit notes */
s=GWEN_DB_GetCharValue(db, "executionDate", 0, 0);
if (s && *s) {
GWEN_BUFFER *dbuf;
dbuf=GWEN_Buffer_new(0, 32, 0, 1);
GWEN_Buffer_AppendString(dbuf, s);
GWEN_Buffer_AppendString(dbuf, "-00:00");
d=GWEN_Time_fromUtcString(GWEN_Buffer_GetStart(dbuf),
"YYYYMMDD-hh:mm");
GWEN_Buffer_free(dbuf);
if (d==0) {
DBG_ERROR(0, "Invalid execution date value \"%s\"", s);
AB_Transaction_free(t);
return NULL;
}
AB_Transaction_SetDate(t, d);
GWEN_Time_free(d);
}
/* standing orders */
s=GWEN_DB_GetCharValue(db, "firstExecutionDate", 0, 0);
if (s && *s) {
GWEN_BUFFER *dbuf;
dbuf=GWEN_Buffer_new(0, 32, 0, 1);
GWEN_Buffer_AppendString(dbuf, s);
GWEN_Buffer_AppendString(dbuf, "-00:00");
d=GWEN_Time_fromUtcString(GWEN_Buffer_GetStart(dbuf),
"YYYYMMDD-hh:mm");
GWEN_Buffer_free(dbuf);
if (d==0) {
DBG_ERROR(0, "Invalid first execution date value \"%s\"", s);
AB_Transaction_free(t);
return NULL;
}
AB_Transaction_SetFirstExecutionDate(t, d);
GWEN_Time_free(d);
}
s=GWEN_DB_GetCharValue(db, "lastExecutionDate", 0, 0);
if (s && *s) {
GWEN_BUFFER *dbuf;
dbuf=GWEN_Buffer_new(0, 32, 0, 1);
GWEN_Buffer_AppendString(dbuf, s);
GWEN_Buffer_AppendString(dbuf, "-00:00");
d=GWEN_Time_fromUtcString(GWEN_Buffer_GetStart(dbuf),
"YYYYMMDD-hh:mm");
GWEN_Buffer_free(dbuf);
if (d==0) {
DBG_ERROR(0, "Invalid last execution date value \"%s\"", s);
AB_Transaction_free(t);
return NULL;
}
AB_Transaction_SetLastExecutionDate(t, d);
GWEN_Time_free(d);
}
if (expTransferType==AB_Job_TypeSepaCreateStandingOrder ||
expTransferType==AB_Job_TypeSepaModifyStandingOrder) {
const char *s;
AB_TRANSACTION_PERIOD period=AB_Transaction_PeriodUnknown;
/* only needed for standing orders */
s=GWEN_DB_GetCharValue(db, "executionPeriod", 0, 0);
if (s && *s) {
period=AB_Transaction_Period_fromString(s);
if (period==AB_Transaction_PeriodUnknown) {
DBG_ERROR(0, "Invalid execution period value \"%s\"", s);
AB_Transaction_free(t);
return NULL;
}
}
else {
DBG_ERROR(0, "Missing execution period value");
return NULL;
}
AB_Transaction_SetPeriod(t, period);
i=GWEN_DB_GetIntValue(db, "executionCycle", 0, -1);
if (i <= 0) {
DBG_ERROR(0, "Invalid execution cycle value \"%d\"", i);
AB_Transaction_free(t);
return NULL;
}
AB_Transaction_SetCycle(t, i);
i=GWEN_DB_GetIntValue(db, "executionDay", 0, -1);
if (i <= 0 || (period == AB_Transaction_PeriodWeekly && i > 7) ||
(period == AB_Transaction_PeriodMonthly && i > 30 &&
(i < 97 || i > 99))) {
DBG_ERROR(0, "Invalid execution day value \"%d\"", i);
AB_Transaction_free(t);
return NULL;
}
AB_Transaction_SetExecutionDay(t, i);
}
return t;
}
AB_VALUE *AB_Value_fromString(const char *s) {
AB_VALUE *v;
const char *currency=NULL;
int conversion_succeeded = 1; // assume conversion will succeed
char *tmpString=NULL;
char *p;
char *t;
char decimalComma;
int isNeg=0;
if( !s ) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Attempt to convert a NULL value");
return NULL;
}
tmpString=strdup(s);
p=tmpString;
while(*p && *p<33)
p++;
if (*p=='-') {
isNeg=1;
p++;
}
else if (*p=='+') {
p++;
}
t=strchr(p, ':');
if (t) {
currency=t+1;
*t=0;
}
/* remove thousand's comma */
decimalComma=AB_Value_determineDecimalComma(p);
if (decimalComma) {
char *s1, *d1;
s1=p;
d1=p;
while(*s1) {
register char c;
c=*(s1++);
if (isdigit(c) || c=='/')
*(d1++)=c;
else if (c==decimalComma)
/* always use '.' as decimal comma */
*(d1++)='.';
}
*d1=0;
}
v=AB_Value_new();
t=strchr(p, '.');
if (t) {
// remove comma and calculate denominator
unsigned long denominator = 1;
char *next;
do {
next=t+1;
*t=*next;
if (*next != 0)
denominator *= 10;
t++;
} while (*next);
// set denominator to the calculated value
mpz_set_ui(mpq_denref(v->value), denominator);
// set numerator to the resulting integer string without comma
if (mpz_set_str(mpq_numref(v->value), p, 10) == -1) {
conversion_succeeded = 0;
}
}
else {
/*DBG_ERROR(0, "Scanning this value: %s\n", p);*/
conversion_succeeded = (gmp_sscanf(p, "%Qu", v->value) == 1);
}
/* set currency (if any) */
if (currency)
v->currency=strdup(currency);
/* temporary string no longer needed */
free(tmpString);
if (!conversion_succeeded) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "[%s] is not a valid value", s);
AB_Value_free(v);
return NULL;
}
if (isNeg)
mpq_neg(v->value, v->value);
return v;
}
int AH_ImExporterOFX_TransactionCallback_cb(const struct OfxTransactionData data,
void *user_data)
{
AH_IMEXPORTER_OFX *ieh;
DBG_INFO(AQBANKING_LOGDOMAIN,
"Transaction callback");
ieh=(AH_IMEXPORTER_OFX *)user_data;
if (!ieh->lastAccountInfo) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Transaction but no account. Ignoring");
return -1;
}
else {
AB_TRANSACTION *t;
t=AB_Transaction_new();
if (data.account_id_valid)
AB_Transaction_SetLocalAccountNumber(t, data.account_id);
else
AB_Transaction_SetLocalAccountNumber(t, "----");
if (data.date_posted_valid) {
GWEN_TIME *ti;
ti=GWEN_Time_fromSeconds(data.date_posted);
AB_Transaction_SetValutaDate(t, ti);
GWEN_Time_free(ti);
}
if (data.date_initiated_valid) {
GWEN_TIME *ti;
ti=GWEN_Time_fromSeconds(data.date_initiated);
AB_Transaction_SetDate(t, ti);
GWEN_Time_free(ti);
}
if (data.fi_id_valid)
AB_Transaction_SetFiId(t, data.fi_id);
if (data.name_valid)
AB_Transaction_AddRemoteName(t, data.name, 0);
if (data.memo_valid)
AB_Transaction_AddPurpose(t, data.memo, 0);
if (data.amount_valid) {
AB_VALUE *val;
const char *cur;
cur=0;
if (data.account_ptr)
if (data.account_ptr->currency_valid)
cur=data.account_ptr->currency;
val=AB_Value_fromDouble(data.amount);
assert(val);
AB_Value_SetCurrency(val, cur);
if (data.invtransactiontype_valid)
/* negate for investment transaction type (hack, see KMyMoney) */
AB_Value_Negate(val);
AB_Transaction_SetValue(t, val);
AB_Value_free(val);
}
else {
DBG_ERROR(AQBANKING_LOGDOMAIN,
"No amount in transaction");
}
if (data.transactiontype_valid) {
switch (data.transactiontype) {
case OFX_CHECK:
AB_Transaction_SetTransactionKey(t, "CHK");
AB_Transaction_SetTransactionText(t, "Check");
break;
case OFX_INT:
AB_Transaction_SetTransactionKey(t, "INT");
AB_Transaction_SetTransactionText(t, "Interest");
break;
case OFX_DIV:
AB_Transaction_SetTransactionKey(t, "DIV");
AB_Transaction_SetTransactionText(t, "Dividend");
break;
case OFX_SRVCHG:
AB_Transaction_SetTransactionKey(t, "CHG");
AB_Transaction_SetTransactionText(t, "Service charge");
break;
case OFX_FEE:
AB_Transaction_SetTransactionKey(t, "BRF");
AB_Transaction_SetTransactionText(t, "Fee");
break;
case OFX_DEP:
AB_Transaction_SetTransactionKey(t, "LDP"); /* FIXME: not sure */
AB_Transaction_SetTransactionText(t, "Deposit");
break;
case OFX_ATM:
AB_Transaction_SetTransactionKey(t, "MSC"); /* misc */
AB_Transaction_SetTransactionText(t, "Cash dispenser");
break;
case OFX_POS:
AB_Transaction_SetTransactionKey(t, "MSC"); /* misc */
AB_Transaction_SetTransactionText(t, "Point of sale");
break;
case OFX_XFER:
AB_Transaction_SetTransactionKey(t, "TRF");
AB_Transaction_SetTransactionText(t, "Transfer");
break;
case OFX_PAYMENT:
AB_Transaction_SetTransactionKey(t, "TRF"); /* FIXME: not sure */
AB_Transaction_SetTransactionText(t, "Electronic payment");
break;
case OFX_CASH:
AB_Transaction_SetTransactionKey(t, "MSC"); /* FIXME: not sure */
AB_Transaction_SetTransactionText(t, "Cash");
break;
case OFX_DIRECTDEP:
AB_Transaction_SetTransactionKey(t, "LDP"); /* FIXME: not sure */
AB_Transaction_SetTransactionText(t, "Direct deposit");
break;
case OFX_DIRECTDEBIT:
AB_Transaction_SetTransactionKey(t, "MSC"); /* FIXME: not sure */
AB_Transaction_SetTransactionText(t, "Merchant initiated debit");
break;
case OFX_REPEATPMT:
AB_Transaction_SetTransactionKey(t, "STO");
AB_Transaction_SetTransactionText(t, "Standing order");
break;
case OFX_DEBIT:
case OFX_CREDIT:
case OFX_OTHER:
AB_Transaction_SetTransactionKey(t, "MSC"); /* FIXME: not sure */
break;
}
} /* if transaction type is valid */
else if (data.invtransactiontype_valid) {
switch (data.invtransactiontype) {
case OFX_BUYDEBT:
case OFX_BUYMF:
case OFX_BUYOPT:
case OFX_BUYOTHER:
case OFX_BUYSTOCK:
AB_Transaction_SetTransactionKey(t, "BUY");
AB_Transaction_SetTransactionText(t, "Buy stocks or alike");
AB_Transaction_SetSubType(t, AB_Transaction_SubTypeBuy);
break;
case OFX_REINVEST:
AB_Transaction_SetTransactionKey(t, "REINV");
AB_Transaction_SetTransactionText(t, "Reinvestment");
AB_Transaction_SetSubType(t, AB_Transaction_SubTypeReinvest);
break;
case OFX_SELLDEBT:
case OFX_SELLMF:
case OFX_SELLOPT:
case OFX_SELLOTHER:
case OFX_SELLSTOCK:
AB_Transaction_SetTransactionKey(t, "BUY");
AB_Transaction_SetTransactionText(t, "Buy stocks or alike");
AB_Transaction_SetSubType(t, AB_Transaction_SubTypeSell);
break;
case OFX_INCOME:
AB_Transaction_SetTransactionKey(t, "DIV");
AB_Transaction_SetTransactionText(t, "Dividend");
AB_Transaction_SetSubType(t, AB_Transaction_SubTypeDividend);
break;
/* rest is unhandled */
case OFX_CLOSUREOPT:
AB_Transaction_SetTransactionText(t, "XCLOSUREOPT");
break;
case OFX_INVEXPENSE:
AB_Transaction_SetTransactionText(t, "XINVEXPENSE");
break;
case OFX_JRNLFUND:
AB_Transaction_SetTransactionText(t, "XJRNLFUND");
break;
case OFX_MARGININTEREST:
AB_Transaction_SetTransactionText(t, "XMARGININTEREST");
break;
case OFX_RETOFCAP:
AB_Transaction_SetTransactionText(t, "XRETOFCAP");
break;
case OFX_SPLIT:
AB_Transaction_SetTransactionText(t, "XSPLIT");
break;
case OFX_TRANSFER:
AB_Transaction_SetTransactionText(t, "XTRANSFER");
break;
default:
break;
}
#ifdef HAVE_OFX_0_8_PLUS
if (data.fees_valid || data.commission_valid) {
AB_VALUE *vFees;
vFees=AB_Value_new();
if (data.fees_valid) {
AB_VALUE *v;
v=AB_Value_fromDouble(data.fees);
AB_Value_AddValue(vFees, v);
AB_Value_free(v);
}
if (data.commission_valid) {
AB_VALUE *v;
v=AB_Value_fromDouble(data.commission);
AB_Value_AddValue(vFees, v);
AB_Value_free(v);
}
AB_Transaction_SetFees(t, vFees);
AB_Value_free(vFees);
}
#endif
if (data.units_valid)
AB_Transaction_SetUnits(t, data.units);
#ifdef HAVE_OFX_0_8_PLUS
if (data.unitprice_valid && data.fees_valid) {
AB_VALUE *v;
v=AB_Value_fromDouble(data.fees); /* TODO: add currency */
AB_Transaction_SetUnitPrice(t, v);
AB_Value_free(v);
}
#endif
}
else {
DBG_NOTICE(AQBANKING_LOGDOMAIN, "No transaction type");
}
if (data.server_transaction_id_valid)
AB_Transaction_SetBankReference(t, data.server_transaction_id);
if (data.check_number_valid)
AB_Transaction_SetCustomerReference(t, data.check_number);
else if (data.reference_number_valid)
AB_Transaction_SetCustomerReference(t, data.reference_number);
DBG_INFO(0, "Adding transaction");
AB_ImExporterAccountInfo_AddTransaction(ieh->lastAccountInfo, t);
}
return 0;
}
int AH_Job_GetTransactionsCreditCard_Process(AH_JOB *j, AB_IMEXPORTER_CONTEXT *ctx)
{
AH_JOB_GETTRANSACTIONS *aj;
AB_ACCOUNT *a;
AB_IMEXPORTER_ACCOUNTINFO *ai;
AB_USER *u;
GWEN_DB_NODE *dbResponses;
GWEN_DB_NODE *dbCurr;
GWEN_BUFFER *tbooked;
GWEN_BUFFER *tnoted;
int rv;
DBG_INFO(AQHBCI_LOGDOMAIN, "Processing JobGetTransactionsCreditCard");
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);
DBG_INFO(AQHBCI_LOGDOMAIN, "Response:");
GWEN_DB_Dump(dbResponses, 2);
DBG_INFO(AQHBCI_LOGDOMAIN, "Response end");
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);
AB_ImExporterAccountInfo_SetAccountId(ai, AB_Account_GetUniqueId(a));
u=AH_Job_GetUser(j);
assert(u);
/* 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/transactionscreditcard");
if (dbXA) {
GWEN_DB_NODE *dbT;
GWEN_DB_NODE *dbV;
GWEN_DATE *date;
GWEN_DATE *valutaDate;
const char *p;
const char *ref;
int i;
dbT=GWEN_DB_GetGroup(dbXA, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
"entries");
while (dbT) {
AB_VALUE *v1;
AB_VALUE *v2;
GWEN_STRINGLIST *purpose;
AB_TRANSACTION *t;
/* read date (Buchungsdatum) */
p=GWEN_DB_GetCharValue(dbT, "date", 0, 0);
if (p)
date=GWEN_Date_fromStringWithTemplate(p, "YYYYMMDD");
else
date=NULL;
/* read valutaData (Umsatzdatum) */
p=GWEN_DB_GetCharValue(dbT, "valutaDate", 0, 0);
if (p)
valutaDate=GWEN_Date_fromStringWithTemplate(p, "YYYYMMDD");
else
valutaDate=NULL;
/* read value */
dbV=GWEN_DB_GetGroup(dbT, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
"value");
if (dbV)
v1=AB_Value_fromDb(dbV);
else
v1=NULL;
v2=0;
if (!v1) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Error parsing value from DB");
}
else {
p=GWEN_DB_GetCharValue(dbT, "debitMark", 0, 0);
if (p) {
if (strcasecmp(p, "D")==0 ||
strcasecmp(p, "RC")==0) {
v2=AB_Value_dup(v1);
AB_Value_Negate(v2);
}
else if (strcasecmp(p, "C")==0 ||
strcasecmp(p, "RD")==0)
v2=AB_Value_dup(v1);
else {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Bad debit mark \"%s\"", p);
v2=0;
}
}
AB_Value_free(v1);
}
/* read purpose */
purpose=GWEN_StringList_new();
for (i=0; i<10; i++) {
p=GWEN_DB_GetCharValue(dbT, "purpose", i, 0);
if (!p)
break;
GWEN_StringList_AppendString(purpose, p, 0, 0);
}
/* read reference */
ref=GWEN_DB_GetCharValue(dbT, "reference", 0, 0);
if (ref)
GWEN_StringList_AppendString(purpose, ref, 0, 0);
t=AB_Transaction_new();
if (ref)
AB_Transaction_SetFiId(t, ref);
AB_Transaction_SetUniqueAccountId(t, AB_Account_GetUniqueId(a));
AB_Transaction_SetLocalBankCode(t, AB_User_GetBankCode(u));
AB_Transaction_SetLocalAccountNumber(t, AB_Account_GetAccountNumber(a));
AB_Transaction_SetValutaDate(t, valutaDate);
AB_Transaction_SetDate(t, date);
AB_Transaction_SetValue(t, v2);
AB_Transaction_SetPurposeFromStringList(t, purpose);
DBG_INFO(AQHBCI_LOGDOMAIN, "Adding transaction");
AB_ImExporterAccountInfo_AddTransaction(ai, t);
GWEN_StringList_free(purpose);
AB_Value_free(v2);
GWEN_Date_free(date);
GWEN_Date_free(valutaDate);
dbT = GWEN_DB_FindNextGroup(dbT, "entries");
} //while (dbT)
} //if (dbXA)
dbCurr=GWEN_DB_GetNextGroup(dbCurr);
}
return 0;
}
/* --------------------------------------------------------------- FUNCTION */
int AH_Job_GetTransactions__ReadTransactions(AH_JOB *j,
AB_IMEXPORTER_ACCOUNTINFO *ai,
const char *docType,
int noted,
GWEN_BUFFER *buf){
GWEN_DBIO *dbio;
GWEN_SYNCIO *sio;
int rv;
GWEN_DB_NODE *db;
GWEN_DB_NODE *dbDay;
GWEN_DB_NODE *dbParams;
AB_ACCOUNT *a;
AB_USER *u;
uint32_t progressId;
uint64_t cnt=0;
a=AH_AccountJob_GetAccount(j);
assert(a);
u=AH_Job_GetUser(j);
assert(u);
dbio=GWEN_DBIO_GetPlugin("swift");
if (!dbio) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Plugin SWIFT is not found");
GWEN_Gui_ProgressLog(0,
GWEN_LoggerLevel_Error,
I18N("Plugin \"SWIFT\" not found."));
return AB_ERROR_PLUGIN_MISSING;
}
GWEN_Buffer_Rewind(buf);
sio=GWEN_SyncIo_Memory_new(buf, 0);
db=GWEN_DB_Group_new("transactions");
dbParams=GWEN_DB_Group_new("params");
GWEN_DB_SetCharValue(dbParams, GWEN_DB_FLAGS_OVERWRITE_VARS,
"type", docType);
if (AH_User_GetFlags(u) & AH_USER_FLAGS_KEEP_MULTIPLE_BLANKS)
GWEN_DB_SetIntValue(dbParams, GWEN_DB_FLAGS_OVERWRITE_VARS,
"keepMultipleBlanks", 1);
else
GWEN_DB_SetIntValue(dbParams, GWEN_DB_FLAGS_OVERWRITE_VARS,
"keepMultipleBlanks", 0);
rv=GWEN_DBIO_Import(dbio, sio,
db, dbParams,
GWEN_PATH_FLAGS_CREATE_GROUP);
if (rv<0) {
DBG_ERROR(AQHBCI_LOGDOMAIN,
"Error parsing SWIFT %s (%d)",
docType, rv);
GWEN_DB_Group_free(dbParams);
GWEN_DB_Group_free(db);
GWEN_SyncIo_free(sio);
GWEN_DBIO_free(dbio);
return rv;
}
GWEN_DB_Group_free(dbParams);
GWEN_SyncIo_free(sio);
GWEN_DBIO_free(dbio);
/* first count the groups */
dbDay=GWEN_DB_FindFirstGroup(db, "day");
while(dbDay) {
GWEN_DB_NODE *dbT;
dbT=GWEN_DB_FindFirstGroup(dbDay, "transaction");
while(dbT) {
cnt++;
dbT=GWEN_DB_FindNextGroup(dbT, "transaction");
} /* while */
dbDay=GWEN_DB_FindNextGroup(dbDay, "day");
} /* while */
progressId=GWEN_Gui_ProgressStart(GWEN_GUI_PROGRESS_DELAY |
GWEN_GUI_PROGRESS_ALLOW_EMBED |
GWEN_GUI_PROGRESS_SHOW_PROGRESS |
GWEN_GUI_PROGRESS_SHOW_ABORT,
I18N("Importing transactions..."),
NULL,
cnt,
0);
/* add transactions to list */
dbDay=GWEN_DB_FindFirstGroup(db, "day");
while(dbDay) {
GWEN_DB_NODE *dbT;
dbT=GWEN_DB_FindFirstGroup(dbDay, "transaction");
while(dbT) {
AB_TRANSACTION *t;
t=AB_Transaction_fromDb(dbT);
if (!t) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Bad transaction data:");
GWEN_DB_Dump(dbT, 2);
}
else {
const char *s;
AB_Transaction_SetLocalBankCode(t, AB_User_GetBankCode(u));
AB_Transaction_SetLocalAccountNumber(t,
AB_Account_GetAccountNumber(a));
/* some translations */
s=AB_Transaction_GetRemoteIban(t);
if (!(s && *s)) {
const char *sAid;
/* no remote IBAN set, check whether the bank sends this info in the
* fields for national account specifications (instead of the SWIFT
* field "?38" which was specified for this case) */
sAid=AB_Transaction_GetRemoteAccountNumber(t);
if (sAid && *sAid && AB_Banking_CheckIban(sAid)==0) {
/* there is a remote account number specification, and that is an IBAN,
* so we set that accordingly */
DBG_INFO(AQBANKING_LOGDOMAIN, "Setting remote IBAN from account number");
AB_Transaction_SetRemoteIban(t, sAid);
/* set remote BIC if it not already is */
s=AB_Transaction_GetRemoteBic(t);
if (!(s && *s)) {
const char *sBid;
sBid=AB_Transaction_GetRemoteBankCode(t);
if (sBid && *sBid) {
DBG_INFO(AQBANKING_LOGDOMAIN, "Setting remote BIC from bank code");
AB_Transaction_SetRemoteBic(t, sBid);
}
}
}
}
DBG_INFO(AQHBCI_LOGDOMAIN, "Adding transaction");
if (noted)
AB_ImExporterAccountInfo_AddNotedTransaction(ai, t);
else
AB_ImExporterAccountInfo_AddTransaction(ai, t);
}
if (GWEN_ERROR_USER_ABORTED==
GWEN_Gui_ProgressAdvance(progressId, GWEN_GUI_PROGRESS_ONE)) {
GWEN_Gui_ProgressEnd(progressId);
return GWEN_ERROR_USER_ABORTED;
}
dbT=GWEN_DB_FindNextGroup(dbT, "transaction");
} /* while */
/* read all endsaldos */
if (!noted) {
dbT=GWEN_DB_FindFirstGroup(dbDay, "endSaldo");
while (dbT) {
GWEN_DB_NODE *dbX;
GWEN_TIME *ti=0;
dbX=GWEN_DB_GetGroup(dbT, GWEN_PATH_FLAGS_NAMEMUSTEXIST, "date");
if (dbX)
ti=GWEN_Time_fromDb(dbX);
dbX=GWEN_DB_GetGroup(dbT, GWEN_PATH_FLAGS_NAMEMUSTEXIST, "value");
if (dbX) {
AB_VALUE *v;
v=AB_Value_fromDb(dbX);
if (v) {
AB_BALANCE *bal;
AB_ACCOUNT_STATUS *as;
bal=AB_Balance_new(v, ti);
AB_Value_free(v);
as=AB_AccountStatus_new();
if (ti)
AB_AccountStatus_SetTime(as, ti);
AB_AccountStatus_SetNotedBalance(as, bal);
AB_Balance_free(bal);
AB_ImExporterAccountInfo_AddAccountStatus(ai, as);
}
}
GWEN_Time_free(ti);
dbT=GWEN_DB_FindNextGroup(dbT, "endSaldo");
} /* while */
}
dbDay=GWEN_DB_FindNextGroup(dbDay, "day");
} /* while */
GWEN_Gui_ProgressEnd(progressId);
GWEN_DB_Group_free(db);
return 0;
}
