AB_VALUE *AB_ImExporterYN__ReadValue(AB_IMEXPORTER *ie,
GWEN_XMLNODE *node,
int value)
{
GWEN_XMLNODE *n;
AB_VALUE *val=0;
n=GWEN_XMLNode_FindFirstTag(node, "C516", 0, 0);
if (n) {
GWEN_XMLNODE *nn;
int v=0;
nn=GWEN_XMLNode_FindFirstTag(n, "D_5025", 0, 0);
if (nn)
v=atoi(GWEN_XMLNode_GetProperty(nn, "Value", "0"));
if (value==0 || v==value) {
const char *sValue;
const char *sSign;
sValue=GWEN_XMLNode_GetCharValue(n, "D_5004", 0);
sSign=GWEN_XMLNode_GetCharValue(node, "PF:D_5003", 0);
if (sValue) {
val=AB_Value_fromString(sValue);
if (val && sSign && strcmp(sSign, "-")==0)
AB_Value_Negate(val);
}
}
}
return val;
}
int AB_ImExporterYN_Import(AB_IMEXPORTER *ie,
AB_IMEXPORTER_CONTEXT *ctx,
GWEN_SYNCIO *sio,
GWEN_DB_NODE *params){
AB_IMEXPORTER_YELLOWNET *ieh;
//GWEN_DB_NODE *dbSubParams;
GWEN_XMLNODE *doc;
GWEN_XMLNODE *node;
int rv;
GWEN_XML_CONTEXT *ctxml;
assert(ie);
ieh=GWEN_INHERIT_GETDATA(AB_IMEXPORTER, AB_IMEXPORTER_YELLOWNET, ie);
assert(ieh);
// dbSubParams=GWEN_DB_GetGroup(params, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
// "params");
doc=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "root");
ctxml=GWEN_XmlCtxStore_new(doc, GWEN_XML_FLAGS_HANDLE_HEADERS);
rv=GWEN_XMLContext_ReadFromIo(ctxml, sio);
GWEN_XmlCtx_free(ctxml);
if (rv) {
DBG_ERROR(AQBANKING_LOGDOMAIN,
"Could not parse XML stream (%d)", rv);
GWEN_XMLNode_free(doc);
return GWEN_ERROR_BAD_DATA;
}
node=GWEN_XMLNode_FindFirstTag(doc, "IC", 0, 0);
if (node==NULL) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Document does not contain element \"IC\"");
GWEN_XMLNode_Dump(doc, 2);
GWEN_XMLNode_free(doc);
return GWEN_ERROR_BAD_DATA;
}
node=GWEN_XMLNode_FindFirstTag(node, "KONAUS", 0, 0);
while(node) {
AB_IMEXPORTER_ACCOUNTINFO *ai;
ai=AB_ImExporterYN__ReadAccountInfo(ie, ctx, node);
assert(ai);
rv=AB_ImExporterYN__ReadAccountStatus(ie, ai, node);
if (rv==0)
rv=AB_ImExporterYN__ReadTransactions(ie, ai, node);
if (rv) {
AB_ImExporterAccountInfo_free(ai);
GWEN_XMLNode_free(doc);
return rv;
}
AB_ImExporterContext_AddAccountInfo(ctx, ai);
node=GWEN_XMLNode_FindNextTag(node, "KONAUS", 0, 0);
}
GWEN_XMLNode_free(doc);
return 0;
}
LC_CLIENT_RESULT LC_EgkCard_ReadInsuranceData_5_1_0(GWEN_XMLNODE *n,
LC_HI_INSURANCE_DATA *d) {
const char *s;
GWEN_XMLNODE *nn;
n=GWEN_XMLNode_FindFirstTag(n,
"Versicherter",
NULL, NULL);
if (n) {
nn=GWEN_XMLNode_FindFirstTag(n,
"Versicherungsschutz",
NULL, NULL);
if (nn) {
GWEN_XMLNODE *nnn;
s=GWEN_XMLNode_GetCharValue(nn, "Beginn", NULL);
if (s) {
GWEN_TIME *ti=GWEN_Time_fromUtcString(s, "YYYYMMDD");
LC_HIInsuranceData_SetCoverBegin(d, ti);
GWEN_Time_free(ti);
}
s=GWEN_XMLNode_GetCharValue(nn, "Ende", NULL);
if (s) {
GWEN_TIME *ti=GWEN_Time_fromUtcString(s, "YYYYMMDD");
LC_HIInsuranceData_SetCoverEnd(d, ti);
GWEN_Time_free(ti);
}
nnn=GWEN_XMLNode_FindFirstTag(nn,
"Kostentraeger",
NULL, NULL);
if (nnn) {
s=GWEN_XMLNode_GetCharValue(nnn, "Kostentraegerkennung", NULL);
LC_HIInsuranceData_SetInstitutionId(d, s);
s=GWEN_XMLNode_GetCharValue(nnn, "Name", NULL);
LC_HIInsuranceData_SetInstitutionName(d, s);
}
}
else {
DBG_INFO(LC_LOGDOMAIN,
"XML element \"Versicherungsschutz\" not found");
}
nn=GWEN_XMLNode_FindFirstTag(n,
"Zusatzinfos",
NULL, NULL);
if (nn)
nn=GWEN_XMLNode_FindFirstTag(nn,
"ZusatzinfosGKV",
NULL, NULL);
if (nn) {
s=GWEN_XMLNode_GetCharValue(nn, "Rechtskreis", NULL);
LC_HIInsuranceData_SetGroup(d, s);
s=GWEN_XMLNode_GetCharValue(nn, "Versichertenart", NULL);
LC_HIInsuranceData_SetStatus(d, s);
}
}
return LC_Client_ResultOk;
}
LC_CLIENT_RESULT LC_EgkCard_ReadPersonalData_old(GWEN_XMLNODE *n,
LC_HI_PERSONAL_DATA *d) {
const char *s;
GWEN_XMLNODE *nn;
s=GWEN_XMLNode_GetCharValue(n, "Versicherten_ID", NULL);
LC_HIPersonalData_SetInsuranceId(d, s);
s=GWEN_XMLNode_GetCharValue(n, "Geburtsdatum", NULL);
if (s) {
GWEN_TIME *ti=GWEN_Time_fromUtcString(s, "YYYYMMDD");
LC_HIPersonalData_SetDateOfBirth(d, ti);
GWEN_Time_free(ti);
}
s=GWEN_XMLNode_GetCharValue(n, "Vorname", NULL);
LC_HIPersonalData_SetPrename(d, s);
s=GWEN_XMLNode_GetCharValue(n, "Nachname", NULL);
LC_HIPersonalData_SetName(d, s);
s=GWEN_XMLNode_GetCharValue(n, "Sex", "1");
if (s) {
if (strcasecmp(s, "1")==0)
LC_HIPersonalData_SetSex(d, LC_HIPersonalData_SexMale);
else if (strcasecmp(s, "2")==0)
LC_HIPersonalData_SetSex(d, LC_HIPersonalData_SexFemale);
else {
DBG_WARN(LC_LOGDOMAIN, "Unknown sex \"%s\"", s);
}
}
nn=GWEN_XMLNode_FindFirstTag(n,
"Anschrift",
NULL, NULL);
if (nn) {
s=GWEN_XMLNode_GetCharValue(nn, "Postleitzahl", NULL);
LC_HIPersonalData_SetAddrZipCode(d, s);
s=GWEN_XMLNode_GetCharValue(nn, "Ort", NULL);
LC_HIPersonalData_SetAddrCity(d, s);
s=GWEN_XMLNode_GetCharValue(nn, "Wohnsitzlaendercode", NULL);
LC_HIPersonalData_SetAddrCountry(d, s);
nn=GWEN_XMLNode_FindFirstTag(nn,
"Adresse",
NULL, NULL);
if (nn) {
s=GWEN_XMLNode_GetCharValue(nn, "Strasse", NULL);
LC_HIPersonalData_SetAddrStreet(d, s);
s=GWEN_XMLNode_GetCharValue(nn, "Hausnummer", NULL);
LC_HIPersonalData_SetAddrHouseNum(d, s);
}
}
return LC_Client_ResultOk;
}
const char *GWEN_XMLNode_GetCharValue(const GWEN_XMLNODE *n,
const char *name,
const char *defValue) {
GWEN_XMLNODE *nn;
if (name && *name) {
nn=GWEN_XMLNode_FindFirstTag(n, name, 0, 0);
while(nn) {
GWEN_XMLNODE *dn;
dn=GWEN_XMLNode_GetFirstData(nn);
if (dn) {
if (dn->data)
return dn->data;
}
nn=GWEN_XMLNode_FindNextTag(nn, name, 0, 0);
}
}
else {
GWEN_XMLNODE *dn;
dn=GWEN_XMLNode_GetFirstData(n);
if (dn) {
if (dn->data)
return dn->data;
}
}
return defValue;
}
GWEN_DATE *AB_ImExporterYN__ReadDate(AB_IMEXPORTER *ie, GWEN_XMLNODE *node, int value)
{
GWEN_XMLNODE *n;
GWEN_DATE *da=NULL;
n=GWEN_XMLNode_GetNodeByXPath(node, "C507", GWEN_PATH_FLAGS_NAMEMUSTEXIST);
if (n) {
GWEN_XMLNODE *nn;
int v=0;
nn=GWEN_XMLNode_FindFirstTag(n, "D_2005", 0, 0);
if (nn)
v=atoi(GWEN_XMLNode_GetProperty(nn, "Value", "0"));
if (value==0 || v==value) {
const char *s;
s=GWEN_XMLNode_GetCharValue(n, "D_2380", 0);
if (s)
da=GWEN_Date_fromStringWithTemplate(s, "YYYYMMDD");
}
}
return da;
}
GWEN_TIME *AB_ImExporterYN__ReadTime(AB_IMEXPORTER *ie,
GWEN_XMLNODE *node,
int value) {
GWEN_XMLNODE *n;
GWEN_TIME *ti=0;
n=GWEN_XMLNode_GetNodeByXPath(node, "C507",
GWEN_PATH_FLAGS_NAMEMUSTEXIST);
if (n) {
GWEN_XMLNODE *nn;
int v=0;
nn=GWEN_XMLNode_FindFirstTag(n, "D_2005", 0, 0);
if (nn)
v=atoi(GWEN_XMLNode_GetProperty(nn, "Value", "0"));
if (value==0 || v==value) {
const char *s;
s=GWEN_XMLNode_GetCharValue(n, "D_2380", 0);
if (s)
ti=AB_ImExporter_DateFromString(s, "YYYYMMDD", 0);
}
}
return ti;
}
const char *GWEN_XMLNode_GetLocalizedCharValue(const GWEN_XMLNODE *n,
const char *name,
const char *defValue) {
GWEN_XMLNODE *nn=0;
GWEN_STRINGLIST *langl;
langl=GWEN_I18N_GetCurrentLocaleList();
if (langl) {
GWEN_STRINGLISTENTRY *se;
se=GWEN_StringList_FirstEntry(langl);
while(se) {
const char *l;
l=GWEN_StringListEntry_Data(se);
DBG_DEBUG(GWEN_LOGDOMAIN, "Trying locale \"%s\"", l);
assert(l);
nn=GWEN_XMLNode_FindFirstTag(n, name, "lang", l);
while(nn) {
GWEN_XMLNODE *dn;
dn=GWEN_XMLNode_GetFirstData(nn);
if (dn) {
if (dn->data && *(dn->data))
return dn->data;
}
nn=GWEN_XMLNode_FindNextTag(nn, name, "lang", l);
} /* while nn */
se=GWEN_StringListEntry_Next(se);
} /* while */
} /* if language list available */
/* otherwise try without locale */
nn=GWEN_XMLNode_FindFirstTag(n, name, 0, 0);
while(nn) {
GWEN_XMLNODE *dn;
dn=GWEN_XMLNode_GetFirstData(nn);
if (dn) {
if (dn->data)
return dn->data;
}
nn=GWEN_XMLNode_FindNextTag(nn, name, 0, 0);
}
return defValue;
}
int GWEN_DBIO_XmlDb_Import(GWEN_DBIO *dbio,
GWEN_SYNCIO *sio,
GWEN_DB_NODE *data,
GWEN_DB_NODE *cfg,
uint32_t flags) {
int rv;
GWEN_XMLNODE *root;
GWEN_XMLNODE *n;
const char *rootName=0;
GWEN_XML_CONTEXT *ctx;
assert(data);
if (cfg)
rootName=GWEN_DB_GetCharValue(cfg, "rootElement", 0, 0);
root=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "root");
ctx=GWEN_XmlCtxStore_new(root,
GWEN_XML_FLAGS_DEFAULT |
GWEN_XML_FLAGS_HANDLE_HEADERS);
rv=GWEN_XMLContext_ReadFromIo(ctx, sio);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_XmlCtx_free(ctx);
GWEN_XMLNode_free(root);
return rv;
}
GWEN_XmlCtx_free(ctx);
if (rootName) {
n=GWEN_XMLNode_FindFirstTag(root, rootName, 0, 0);
if (!n) {
DBG_ERROR(GWEN_LOGDOMAIN,
"Root node in XML file is not \"%s\"", rootName);
GWEN_XMLNode_free(root);
return GWEN_ERROR_BAD_DATA;
}
}
else {
n=GWEN_XMLNode_GetFirstTag(root);
if (!n) {
DBG_ERROR(GWEN_LOGDOMAIN,
"No root node in XML file");
GWEN_XMLNode_free(root);
return GWEN_ERROR_BAD_DATA;
}
}
rv=GWEN_DBIO__XmlDb_ImportGroup(dbio, flags, data, cfg, n);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_XMLNode_free(root);
return rv;
}
GWEN_XMLNode_free(root);
return 0;
}
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;
}
int AB_ImExporterYN__ReadTransactions(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, "LNE")==0 ||
strcasecmp(s, "LNS")==0)
) {
nn = GWEN_XMLNode_FindFirstTag(n, "SG6", 0, 0);
while (nn) {
AB_TRANSACTION *t;
const char *s;
t=AB_ImExporterYN__ReadLNE_LNS(ie, ai, nn);
s=AB_ImExporterAccountInfo_GetAccountNumber(ai);
AB_Transaction_SetLocalAccountNumber(t, s);
s=AB_ImExporterAccountInfo_GetIban(ai);
AB_Transaction_SetLocalIban(t, s);
AB_ImExporterAccountInfo_AddTransaction(ai, t);
nn=GWEN_XMLNode_FindNextTag(nn, "SG6", 0, 0);
}
}
}
n=GWEN_XMLNode_FindNextTag(n, "SG4", 0, 0);
}
return 0;
}
LC_CLIENT_RESULT LC_EgkCard_ParseInsuranceData(GWEN_XMLNODE *root,
LC_HI_INSURANCE_DATA **pData) {
LC_CLIENT_RESULT res;
GWEN_XMLNODE *n;
LC_HI_INSURANCE_DATA *d=NULL;
n=GWEN_XMLNode_FindFirstTag(root,
"UC_allgemeineVersicherungsdatenXML",
NULL, NULL);
if (n) {
const char *s;
d=LC_HIInsuranceData_new();
s=GWEN_XMLNode_GetProperty(n, "CDM_VERSION", NULL);
if (s) {
DBG_INFO(LC_LOGDOMAIN, "CDM_VERSION is [%s]", s);
if (GWEN_Text_ComparePattern(s, "5.*", 0)!=-1) {
DBG_INFO(LC_LOGDOMAIN, "Reading as 5.1.0");
res=LC_EgkCard_ReadInsuranceData_5_1_0(n, d);
}
else if (GWEN_Text_ComparePattern(s, "3.*", 0)!=-1) {
DBG_INFO(LC_LOGDOMAIN, "Reading as 3.0.0");
res=LC_EgkCard_ReadInsuranceData_3_0_0(n, d);
}
else {
DBG_WARN(LC_LOGDOMAIN,
"Unhandled CDM_VERSION [%s], trying 5.1.0", s);
res=LC_EgkCard_ReadInsuranceData_5_1_0(n, d);
}
}
else {
DBG_INFO(LC_LOGDOMAIN,
"Missing CDM_VERSION, trying old data type");
/*GWEN_XMLNode_Dump(n, stderr, 2);*/
res=LC_EgkCard_ReadInsuranceData_old(n, d);
}
if (res!=LC_Client_ResultOk) {
DBG_INFO(LC_LOGDOMAIN, "here (%d)", res);
LC_HIInsuranceData_free(d);
return res;
}
}
else {
DBG_ERROR(LC_LOGDOMAIN, "UC_allgemeineVersicherungsdatenXML not found, data follows:");
GWEN_XMLNode_Dump(root, 2);
return LC_Client_ResultNotFound;
}
*pData=d;
return LC_Client_ResultOk;
}
int write_hp_files_c(ARGUMENTS *args, GWEN_XMLNODE *node)
{
GWEN_XMLNODE *n;
int rv;
n=GWEN_XMLNode_FindFirstTag(node, "type", 0, 0);
while (n) {
rv=write_hp_file_c(args, n);
if (rv)
return rv;
n=GWEN_XMLNode_FindNextTag(n, "type", 0, 0);
}
return 0;
}
uint32_t LC_ReaderFlags_fromXml(GWEN_XMLNODE *node, const char *name){
const char *p;
uint32_t flags=0;
GWEN_XMLNODE *n;
n=GWEN_XMLNode_FindFirstTag(node, name, 0, 0);
while(n) {
GWEN_XMLNODE *nn;
nn=GWEN_XMLNode_GetFirstData(n);
if (nn) {
p=GWEN_XMLNode_GetData(nn);
assert(p);
if (strcasecmp(p, "keypad")==0)
flags|=LC_READER_FLAGS_KEYPAD;
else if (strcasecmp(p, "display")==0)
flags|=LC_READER_FLAGS_DISPLAY;
else if (strcasecmp(p, "noinfo")==0)
flags|=LC_READER_FLAGS_NOINFO;
else if (strcasecmp(p, "remote")==0)
flags|=LC_READER_FLAGS_REMOTE;
else if (strcasecmp(p, "auto")==0)
flags|=LC_READER_FLAGS_AUTO;
else if (strcasecmp(p, "suspended_checks")==0)
flags|=LC_READER_FLAGS_SUSPENDED_CHECKS;
else if (strcasecmp(p, "driverHasVerify")==0)
flags|=LC_READER_FLAGS_DRIVER_HAS_VERIFY;
else if (strcasecmp(p, "keepRunning")==0)
flags|=LC_READER_FLAGS_KEEP_RUNNING;
else if (strcasecmp(p, "lowWriteBoundary")==0)
flags|=LC_READER_FLAGS_LOW_WRITE_BOUNDARY;
else if (strcasecmp(p, "noMemorySw")==0)
flags|=LC_READER_FLAGS_NO_MEMORY_SW;
else {
DBG_WARN(0, "Unknown flag \"%s\", ignoring", p);
}
}
n=GWEN_XMLNode_FindNextTag(n, name, 0, 0);
} /* while */
return flags;
}
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;
}
LC_CLIENT_RESULT LC_EgkCard_ReadPersonalData(LC_CARD *card,
LC_HI_PERSONAL_DATA **pData) {
GWEN_BUFFER *dbuf;
LC_CLIENT_RESULT res;
dbuf=GWEN_Buffer_new(0, 256, 0, 1);
res=LC_EgkCard_ReadPd(card, dbuf);
if (res!=LC_Client_ResultOk) {
DBG_INFO(LC_LOGDOMAIN, "here (%d)", res);
GWEN_Buffer_free(dbuf);
return res;
}
else {
GWEN_XMLNODE *root;
GWEN_XMLNODE *n;
root=GWEN_XMLNode_fromString(GWEN_Buffer_GetStart(dbuf),
GWEN_Buffer_GetUsedBytes(dbuf),
GWEN_XML_FLAGS_HANDLE_HEADERS |
GWEN_XML_FLAGS_HANDLE_NAMESPACES);
if (root==NULL) {
DBG_INFO(LC_LOGDOMAIN, "Invalid XML string");
GWEN_Buffer_free(dbuf);
return LC_Client_ResultDataError;
}
GWEN_Buffer_free(dbuf);
GWEN_XMLNode_StripNamespaces(root);
/*GWEN_XMLNode_Dump(root, stderr, 2);*/
n=GWEN_XMLNode_FindFirstTag(root,
"UC_PersoenlicheVersichertendatenXML",
NULL, NULL);
if (n) {
const char *s;
LC_HI_PERSONAL_DATA *d;
d=LC_HIPersonalData_new();
s=GWEN_XMLNode_GetProperty(n, "CDM_VERSION", NULL);
if (s) {
if (GWEN_Text_ComparePattern(s, "5.*", 0)!=-1)
res=LC_EgkCard_ReadPersonalData_5_1_0(n, d);
else if (GWEN_Text_ComparePattern(s, "3.*", 0)!=-1)
res=LC_EgkCard_ReadPersonalData_3_0_0(n, d);
else {
DBG_WARN(LC_LOGDOMAIN,
"Unhandled CDM_VERSION [%s], trying 5.1.0", s);
res=LC_EgkCard_ReadPersonalData_5_1_0(n, d);
}
}
else
res=LC_EgkCard_ReadPersonalData_old(n, d);
if (res!=LC_Client_ResultOk) {
DBG_INFO(LC_LOGDOMAIN, "here (%d)", res);
LC_HIPersonalData_free(d);
GWEN_XMLNode_free(root);
return res;
}
*pData=d;
}
GWEN_XMLNode_free(root);
}
return LC_Client_ResultOk;
}
void GWEN_Param_ReadXml(GWEN_PARAM *p_struct, GWEN_XMLNODE *p_db)
{
assert(p_struct);
/* member "name" */
if (p_struct->name) {
free(p_struct->name);
}
{
const char *s;
s=GWEN_XMLNode_GetCharValue(p_db, "name", NULL);
if (s)
p_struct->name=strdup(s);
}
if (p_struct->name==NULL) { /* member "name" is volatile, just presetting */
p_struct->name=NULL;
}
/* member "flags" */
p_struct->flags=GWEN_XMLNode_GetIntValue(p_db, "flags", 0);
/* member "type" */
{
const char *s;
s=GWEN_XMLNode_GetCharValue(p_db, "type", NULL);
if (s)
p_struct->type=GWEN_Param_Type_fromString(s);
else
p_struct->type=GWEN_Param_Type_Unknown;
}
/* member "dataType" */
{
const char *s;
s=GWEN_XMLNode_GetCharValue(p_db, "dataType", NULL);
if (s)
p_struct->dataType=GWEN_Param_DataType_fromString(s);
else
p_struct->dataType=GWEN_Param_DataType_Unknown;
}
/* member "shortDescription" */
if (p_struct->shortDescription) {
free(p_struct->shortDescription);
}
{
const char *s;
s=GWEN_XMLNode_GetCharValue(p_db, "shortDescription", NULL);
if (s)
p_struct->shortDescription=strdup(s);
}
if (p_struct->shortDescription==NULL) { /* member "shortDescription" is volatile, just presetting */
p_struct->shortDescription=NULL;
}
/* member "longDescription" */
if (p_struct->longDescription) {
free(p_struct->longDescription);
}
{
const char *s;
s=GWEN_XMLNode_GetCharValue(p_db, "longDescription", NULL);
if (s)
p_struct->longDescription=strdup(s);
}
if (p_struct->longDescription==NULL) { /* member "longDescription" is volatile, just presetting */
p_struct->longDescription=NULL;
}
/* member "currentValue" */
if (p_struct->currentValue) {
free(p_struct->currentValue);
}
{
const char *s;
s=GWEN_XMLNode_GetCharValue(p_db, "currentValue", NULL);
if (s)
p_struct->currentValue=strdup(s);
}
if (p_struct->currentValue==NULL) { /* member "currentValue" is volatile, just presetting */
p_struct->currentValue=NULL;
}
/* member "defaultValue" */
if (p_struct->defaultValue) {
free(p_struct->defaultValue);
}
{
const char *s;
s=GWEN_XMLNode_GetCharValue(p_db, "defaultValue", NULL);
if (s)
p_struct->defaultValue=strdup(s);
}
if (p_struct->defaultValue==NULL) { /* member "defaultValue" is volatile, just presetting */
p_struct->defaultValue=NULL;
}
/* member "choices" */
if (p_struct->choices) {
GWEN_StringList2_free(p_struct->choices);
}
{
GWEN_XMLNODE *n;
n=GWEN_XMLNode_FindFirstTag(p_db, "choices", 0, 0);
if (n) {
p_struct->choices=GWEN_StringList2_fromXml(n, GWEN_StringList2_IntertMode_AlwaysAdd);
}
else
p_struct->choices=NULL;
}
if (p_struct->choices==NULL) { /* member "choices" is volatile, just presetting */
p_struct->choices=NULL;
}
/* member "internalIntValue" */
/* member "internalIntValue" is volatile, just presetting */
p_struct->internalIntValue=0;
/* member "internalFloatValue" */
/* member "internalFloatValue" is volatile, just presetting */
p_struct->internalFloatValue=0;
/* member "runtimeFlags" */
/* member "runtimeFlags" is volatile, just presetting */
p_struct->runtimeFlags=0;
}
int Typemaker2_TypeManager_LoadTypeFileNoLookup(TYPEMAKER2_TYPEMANAGER *tym, const char *fileName,
TYPEMAKER2_TYPE_LIST2 *tlist2) {
int rv;
TYPEMAKER2_TYPE *ty=NULL;
GWEN_XMLNODE *root;
GWEN_XMLNODE *node;
/* read XML file */
root=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "xml");
rv=GWEN_XML_ReadFile(root, fileName,
GWEN_XML_FLAGS_DEFAULT |
GWEN_XML_FLAGS_HANDLE_HEADERS |
GWEN_XML_FLAGS_HANDLE_OPEN_HTMLTAGS);
if (rv<0) {
DBG_ERROR(GWEN_LOGDOMAIN, "Could not load typefile [%s] (%d)", fileName, rv);
GWEN_XMLNode_free(root);
return rv;
}
/* get <tm2> element */
node=GWEN_XMLNode_FindFirstTag(root, "tm2", NULL, NULL);
if (node==NULL) {
DBG_ERROR(GWEN_LOGDOMAIN,
"File [%s] does not contain a tm2 element",
fileName);
GWEN_XMLNode_free(root);
return GWEN_ERROR_NO_DATA;
}
/* get <type> element with id==typeName and wanted language */
node=GWEN_XMLNode_FindFirstTag(node, "type", NULL, NULL);
if (node==NULL) {
DBG_ERROR(GWEN_LOGDOMAIN,
"File [%s] does not contain a type element",
fileName);
GWEN_XMLNode_free(root);
return GWEN_ERROR_NO_DATA;
}
/* read all types from the file */
while(node) {
/* load type from XML element */
ty=Typemaker2_Type_new();
rv=Typemaker2_Type_readXml(ty, node, tym->lang);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "Error reading type from file [%s] (%d)",
fileName,
rv);
Typemaker2_Type_free(ty);
GWEN_XMLNode_free(root);
return rv;
}
/* preset some stuff */
if (1) {
const char *x;
x=Typemaker2_Type_GetExtends(ty);
if (!x || !(*x))
Typemaker2_Type_SetExtends(ty, "struct_base");
}
/* add first, because other types might want to refer to this one */
Typemaker2_Type_List_Add(ty, tym->typeList);
Typemaker2_Type_List2_PushBack(tlist2, ty);
if (Typemaker2_Type_GetFlags(ty) & TYPEMAKER2_FLAGS_WITH_LIST1)
Typemaker2_TypeManager_MakeTypeList1(tym, ty);
if (Typemaker2_Type_GetFlags(ty) & TYPEMAKER2_FLAGS_WITH_LIST2)
Typemaker2_TypeManager_MakeTypeList2(tym, ty);
if (Typemaker2_Type_GetFlags(ty) & TYPEMAKER2_FLAGS_WITH_TREE)
Typemaker2_TypeManager_MakeTypeTree(tym, ty);
node=GWEN_XMLNode_FindNextTag(node, "type", NULL, NULL);
}
GWEN_XMLNode_free(root);
//Typemaker2_TypeManager_Dump(tym, stderr, 2);
return 0;
}
TYPEMAKER2_TYPE *Typemaker2_TypeManager_LoadType(TYPEMAKER2_TYPEMANAGER *tym, const char *typeName) {
GWEN_BUFFER *tbuf;
GWEN_BUFFER *nbuf;
char *p;
int rv;
TYPEMAKER2_TYPE *ty=NULL;
GWEN_XMLNODE *root;
GWEN_XMLNODE *node;
tbuf=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Buffer_AppendString(tbuf, typeName);
p=GWEN_Buffer_GetStart(tbuf);
while(*p) {
*p=tolower(*p);
p++;
}
GWEN_Buffer_AppendString(tbuf, ".tm2");
nbuf=GWEN_Buffer_new(0, 256, 0, 1);
rv=GWEN_Directory_FindFileInPaths(tym->folders, GWEN_Buffer_GetStart(tbuf), nbuf);
if (rv<0) {
DBG_ERROR(GWEN_LOGDOMAIN, "Typefile [%s] not found (%d)", GWEN_Buffer_GetStart(tbuf), rv);
GWEN_Buffer_free(nbuf);
GWEN_Buffer_free(tbuf);
return NULL;
}
/* read XML file */
root=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "xml");
rv=GWEN_XML_ReadFile(root, GWEN_Buffer_GetStart(nbuf),
GWEN_XML_FLAGS_DEFAULT |
GWEN_XML_FLAGS_HANDLE_HEADERS |
GWEN_XML_FLAGS_HANDLE_OPEN_HTMLTAGS);
if (rv<0) {
DBG_ERROR(GWEN_LOGDOMAIN, "Could not load typefile [%s] (%d)", GWEN_Buffer_GetStart(nbuf), rv);
GWEN_XMLNode_free(root);
GWEN_Buffer_free(nbuf);
GWEN_Buffer_free(tbuf);
return NULL;
}
/* get <tm2> element */
node=GWEN_XMLNode_FindFirstTag(root, "tm2", NULL, NULL);
if (node==NULL) {
DBG_ERROR(GWEN_LOGDOMAIN,
"File [%s] does not contain a tm2 element",
GWEN_Buffer_GetStart(nbuf));
GWEN_XMLNode_free(root);
GWEN_Buffer_free(nbuf);
GWEN_Buffer_free(tbuf);
return NULL;
}
/* get <typedef> element with id==typeName and wanted language */
node=GWEN_XMLNode_FindFirstTag(node, "typedef", "id", typeName);
while(node) {
const char *s=GWEN_XMLNode_GetProperty(node, "lang", NULL);
if (s && *s && strcasecmp(s, tym->lang)==0)
break;
node=GWEN_XMLNode_FindNextTag(node, "typedef", "id", typeName);
}
if (node==NULL) {
DBG_ERROR(GWEN_LOGDOMAIN,
"File [%s] does not contain a <typedef> element for type [%s] and language [%s]",
GWEN_Buffer_GetStart(nbuf), typeName, tym->lang);
GWEN_XMLNode_free(root);
GWEN_Buffer_free(nbuf);
GWEN_Buffer_free(tbuf);
return NULL;
}
/* load typedef from XML element */
ty=Typemaker2_Type_new();
rv=Typemaker2_Type_readXml(ty, node, NULL);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "Error reading type [%s] from file [%s] (%d)",
typeName,
GWEN_Buffer_GetStart(nbuf),
rv);
Typemaker2_Type_free(ty);
GWEN_XMLNode_free(root);
GWEN_Buffer_free(nbuf);
GWEN_Buffer_free(tbuf);
return NULL;
}
GWEN_XMLNode_free(root);
GWEN_Buffer_free(nbuf);
GWEN_Buffer_free(tbuf);
return ty;
}
void* GWEN_XMLNode_HandlePath(const char *entry,
void *data,
int idx,
uint32_t flags) {
GWEN_XMLNODE *n;
GWEN_XMLNODE *nn;
int i;
n=(GWEN_XMLNODE*)data;
if (flags & GWEN_PATH_FLAGS_VARIABLE) {
DBG_ERROR(GWEN_LOGDOMAIN,
"GWEN_PATH_FLAGS_VARIABLE not allowed for XPATH");
return 0;
}
if (flags & GWEN_PATH_FLAGS_ROOT) {
while(n->parent)
n=n->parent;
if (*entry=='/')
entry++;
}
if (strcasecmp(entry, "..")==0) {
return n->parent;
}
else if (strcasecmp(entry, ".")==0 ||
strcasecmp(entry, "here()")==0) {
return n;
}
/* check whether we are allowed to simply create the node */
if (
((flags & GWEN_PATH_FLAGS_LAST) &&
(((flags & GWEN_PATH_FLAGS_VARIABLE) &&
(flags & GWEN_PATH_FLAGS_CREATE_VAR)) ||
(!(flags & GWEN_PATH_FLAGS_VARIABLE) &&
(flags & GWEN_PATH_FLAGS_CREATE_GROUP)))
) ||
(
!(flags & GWEN_PATH_FLAGS_LAST) &&
(flags & GWEN_PATH_FLAGS_PATHCREATE))
) {
/* simply create the new variable/group */
if (flags & GWEN_PATH_FLAGS_VARIABLE) {
/* not allowed for now */
return 0;
}
else {
if (idx!=0) {
DBG_ERROR(GWEN_LOGDOMAIN,
"Can not create tag with index!=1 (%s)", entry);
return 0;
}
DBG_VERBOUS(GWEN_LOGDOMAIN,
"Unconditionally creating tag \"%s\"", entry);
nn=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, entry);
GWEN_XMLNode_AddChild(n, nn);
return nn;
}
}
/* find the node */
i=idx;
nn=GWEN_XMLNode_FindFirstTag(n, entry, 0, 0);
while(nn && i--) {
nn=GWEN_XMLNode_FindNextTag(nn, entry, 0, 0);
}
if (!nn) {
/* node not found, check, if we are allowed to create it */
if (
(!(flags & GWEN_PATH_FLAGS_LAST) &&
(flags & GWEN_PATH_FLAGS_PATHMUSTEXIST)) ||
(flags & GWEN_PATH_FLAGS_NAMEMUSTEXIST)
) {
DBG_VERBOUS(GWEN_LOGDOMAIN,
"Tag \"%s\" does not exist", entry);
return 0;
}
/* create the new variable/group */
if (idx!=0) {
DBG_ERROR(GWEN_LOGDOMAIN,
"Can not create tag with index!=1 (%s)", entry);
return 0;
}
DBG_VERBOUS(GWEN_LOGDOMAIN,
"Tag \"%s\" not found, creating", entry);
nn=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, entry);
GWEN_XMLNode_AddChild(n, nn);
} /* if node not found */
else {
/* node does exist, check whether this is ok */
if (
((flags & GWEN_PATH_FLAGS_LAST) &&
(flags & GWEN_PATH_FLAGS_NAMEMUSTNOTEXIST)) ||
(!(flags & GWEN_PATH_FLAGS_LAST) &&
(flags & GWEN_PATH_FLAGS_PATHMUSTNOTEXIST))
) {
DBG_VERBOUS(GWEN_LOGDOMAIN, "Entry \"%s\" already exists", entry);
return 0;
}
}
return nn;
}
int GWEN_DBIO__XmlDb_ImportVar(GWEN_DBIO *dbio,
uint32_t flags,
GWEN_DB_NODE *data,
GWEN_DB_NODE *cfg,
GWEN_XMLNODE *node) {
GWEN_XMLNODE *n;
const char *vname;
GWEN_BUFFER *tbuf;
assert(node);
vname=GWEN_XMLNode_GetData(node);
assert(vname && *vname);
tbuf=GWEN_Buffer_new(0, 256, 0, 1);
n=GWEN_XMLNode_FindFirstTag(node, "value", 0, 0);
while(n) {
const char *s;
const char *d;
int rv;
GWEN_DBIO__XmlDb_ReadDataTags(n, tbuf);
d=GWEN_Buffer_GetStart(tbuf);
if (*d) {
s=GWEN_XMLNode_GetData(n);
assert(s && *s);
s=GWEN_XMLNode_GetProperty(n, "type", 0);
if (s) {
if (strcasecmp(s, "char")==0) {
rv=GWEN_DB_SetCharValue(data, flags, vname, d);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(tbuf);
return rv;
}
}
else if (strcasecmp(s, "int")==0) {
int val;
if (1!=sscanf(d, "%i", &val)) {
DBG_INFO(GWEN_LOGDOMAIN, "Non-integer value [%s]", d);
GWEN_Buffer_free(tbuf);
return GWEN_ERROR_INVALID;
}
rv=GWEN_DB_SetIntValue(data, flags, vname, val);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(tbuf);
return rv;
}
}
else if (strcasecmp(s, "bin")==0) {
GWEN_BUFFER *xbuf;
xbuf=GWEN_Buffer_new(0, 256, 0, 1);
rv=GWEN_Text_FromHexBuffer(d, xbuf);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(xbuf);
GWEN_Buffer_free(tbuf);
return rv;
}
rv=GWEN_DB_SetBinValue(data, flags, vname,
GWEN_Buffer_GetStart(xbuf),
GWEN_Buffer_GetUsedBytes(xbuf));
GWEN_Buffer_free(xbuf);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(tbuf);
return rv;
}
}
else {
DBG_ERROR(GWEN_LOGDOMAIN,
"Unhandled value type \"%s\"", s);
GWEN_Buffer_free(tbuf);
return GWEN_ERROR_INVALID;
}
}
}
else {
DBG_DEBUG(GWEN_LOGDOMAIN, "Empty value");
}
GWEN_Buffer_Reset(tbuf);
n=GWEN_XMLNode_FindNextTag(n, "value", 0, 0);
}
GWEN_Buffer_free(tbuf);
return 0;
}
int GWEN_XMLNode_GetXPath(const GWEN_XMLNODE *n1,
const GWEN_XMLNODE *n2,
GWEN_BUFFER *nbuf) {
GWEN_BUFFER *lbuf;
const GWEN_XMLNODE *ln1;
const GWEN_XMLNODE *ln2;
if (!n1 && !n2) {
DBG_ERROR(GWEN_LOGDOMAIN, "Both nodes are NULL");
return -1;
}
if (!n1) {
n1=n2;
while(n1->parent)
n1=n1->parent;
}
if (!n2) {
n2=n1;
while(n2->parent)
n2=n2->parent;
}
if (n2==n1) {
GWEN_Buffer_AppendString(nbuf, "here()");
return 0;
}
lbuf=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Buffer_ReserveBytes(lbuf, 128);
ln1=n1->parent;
if (ln1) {
GWEN_Buffer_AppendString(lbuf, "../");
while(ln1) {
if (ln1==n2) {
/* found n2 */
GWEN_Buffer_AppendBuffer(nbuf, lbuf);
GWEN_Buffer_free(lbuf);
return 0;
}
if (GWEN_XMLNode_IsChildOf(ln1, n2))
break;
ln1=ln1->parent;
GWEN_Buffer_AppendString(lbuf, "../");
}
if (!ln1) {
DBG_ERROR(GWEN_LOGDOMAIN, "Nodes do not share root node");
GWEN_Buffer_free(lbuf);
return -1;
}
/* append path to n1 */
GWEN_Buffer_AppendBuffer(nbuf, lbuf);
}
DBG_ERROR(GWEN_LOGDOMAIN, "Path so far: %s", GWEN_Buffer_GetStart(lbuf));
/* get path to n2 */
GWEN_Buffer_Reset(lbuf);
ln2=n2;
while(ln2) {
GWEN_XMLNODE *tn;
int idx;
char idxbuf[32];
if (ln2->parent==ln1)
break;
/* count occurences of this tag in this level */
idx=1;
tn=ln2->parent;
if (tn) {
tn=GWEN_XMLNode_FindFirstTag(tn, ln2->data, 0, 0);
while(tn) {
if (tn==ln2)
break;
idx++;
tn=GWEN_XMLNode_FindNextTag(tn, ln2->data, 0, 0);
}
}
snprintf(idxbuf, sizeof(idxbuf), "[%d]", idx);
idxbuf[sizeof(idxbuf)-1]=0;
GWEN_Buffer_InsertString(lbuf, idxbuf);
GWEN_Buffer_InsertString(lbuf, GWEN_XMLNode_GetData(ln2));
GWEN_Buffer_InsertByte(lbuf, '/');
ln2=ln2->parent;
}
DBG_ERROR(GWEN_LOGDOMAIN, "Path so far: %s", GWEN_Buffer_GetStart(lbuf));
assert(ln2);
/* append path to n2 */
GWEN_Buffer_AppendBuffer(nbuf, lbuf);
GWEN_Buffer_free(lbuf);
return 0;
}
AB_IMEXPORTER_ACCOUNTINFO *AB_ImExporterYN__ReadAccountInfo(AB_IMEXPORTER *ie,
AB_IMEXPORTER_CONTEXT *ctx,
GWEN_XMLNODE *doc)
{
GWEN_XMLNODE *n;
AB_IMEXPORTER_ACCOUNTINFO *ai;
ai=AB_ImExporterAccountInfo_new();
n=GWEN_XMLNode_FindFirstTag(doc, "SG2", 0, 0);
if (n)
n=GWEN_XMLNode_FindFirstTag(n, "FII", 0, 0);
if (n) {
GWEN_XMLNODE *nn;
const char *s;
nn=GWEN_XMLNode_FindFirstTag(n, "C078", 0, 0);
if (nn) {
GWEN_XMLNODE *nnn;
/* account number */
s=GWEN_XMLNode_GetCharValue(nn, "D_3194", 0);
if (s)
AB_ImExporterAccountInfo_SetAccountNumber(ai, s);
/* IBAN */
s=GWEN_XMLNode_GetCharValue(nn, "D_3192", 0);
if (s)
AB_ImExporterAccountInfo_SetIban(ai, s);
/* currency */
nnn=GWEN_XMLNode_FindFirstTag(nn, "D_6345", 0, 0);
if (nnn) {
s=GWEN_XMLNode_GetProperty(nnn, "value", 0);
if (s)
AB_ImExporterAccountInfo_SetCurrency(ai, s);
}
}
/* account number */
s=GWEN_XMLNode_GetCharValue(n, "PF:D_5388", 0);
if (s)
AB_ImExporterAccountInfo_SetAccountName(ai, s);
}
/* owner name */
n=GWEN_XMLNode_GetNodeByXPath(doc, "SG3[1]/NAD",
GWEN_PATH_FLAGS_NAMEMUSTEXIST);
if (n) {
GWEN_XMLNODE *nn;
nn=GWEN_XMLNode_FindFirstTag(n, "D_3035", 0, 0);
if (nn) {
const char *s;
s=GWEN_XMLNode_GetProperty(nn, "Value", 0);
if (s && strcasecmp(s, "HQ")==0) {
nn=GWEN_XMLNode_FindFirstTag(n, "C058", 0, 0);
if (nn) {
s=GWEN_XMLNode_GetCharValue(nn, "D_3124", 0);
if (s && *s) {
GWEN_BUFFER *xbuf;
xbuf=GWEN_Buffer_new(0, 256, 0, 1);
AB_ImExporter_Iso8859_1ToUtf8(s, strlen(s), xbuf);
AB_ImExporterAccountInfo_SetOwner(ai, GWEN_Buffer_GetStart(xbuf));
GWEN_Buffer_free(xbuf);
}
}
}
}
}
return ai;
}
GWEN_DIALOG *AB_SetupNewUserDialog_new(AB_BANKING *ab) {
GWEN_DIALOG *dlg;
AB_SETUP_NEWUSER_DIALOG *xdlg;
GWEN_BUFFER *fbuf;
int rv;
GWEN_XMLNODE *n;
GWEN_XMLNODE *nDialog;
GWEN_PLUGIN_DESCRIPTION_LIST2 *providers;
GWEN_DIALOG_LIST *subDialogs=NULL;
dlg=GWEN_Dialog_new("ab_setup_newuser");
GWEN_NEW_OBJECT(AB_SETUP_NEWUSER_DIALOG, xdlg);
GWEN_INHERIT_SETDATA(GWEN_DIALOG, AB_SETUP_NEWUSER_DIALOG, dlg, xdlg,
AB_SetupNewUserDialog_FreeData);
GWEN_Dialog_SetSignalHandler(dlg, AB_SetupNewUserDialog_SignalHandler);
xdlg->backendDialogs=GWEN_Dialog_List2_new();
xdlg->backendRadioNames=GWEN_StringList_new();
xdlg->backendNames=GWEN_StringList_new();
/* get path of dialog description file */
fbuf=GWEN_Buffer_new(0, 256, 0, 1);
rv=GWEN_PathManager_FindFile(AB_PM_LIBNAME, AB_PM_DATADIR,
"aqbanking/dialogs/dlg_setup_newuser.dlg",
fbuf);
if (rv<0) {
DBG_INFO(AQBANKING_LOGDOMAIN, "Dialog description file not found (%d).", rv);
GWEN_Buffer_free(fbuf);
GWEN_Dialog_free(dlg);
return NULL;
}
/* read XML file, extend it */
n=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "root");
rv=GWEN_XML_ReadFile(n, GWEN_Buffer_GetStart(fbuf),
GWEN_XML_FLAGS_DEFAULT |
GWEN_XML_FLAGS_HANDLE_HEADERS);
if (rv<0) {
DBG_INFO(AQBANKING_LOGDOMAIN, "here (%d)", rv);
GWEN_XMLNode_free(n);
GWEN_Buffer_free(fbuf);
GWEN_Dialog_free(dlg);
return NULL;
}
nDialog=GWEN_XMLNode_FindFirstTag(n, "dialog", NULL, NULL);
if (nDialog==NULL) {
DBG_INFO(AQBANKING_LOGDOMAIN, "Dialog element not found in XML file [%s]", GWEN_Buffer_GetStart(fbuf));
GWEN_XMLNode_free(n);
GWEN_Buffer_free(fbuf);
GWEN_Dialog_free(dlg);
return NULL;
}
providers=AB_Banking_GetProviderDescrs(ab);
if (providers) {
GWEN_XMLNODE *nBackendRadioWidget;
nBackendRadioWidget=GWEN_XMLNode_FindFirstTag(nDialog, "widget", "name", "dialogVLayout");
if (nBackendRadioWidget)
nBackendRadioWidget=GWEN_XMLNode_FindFirstTag(nBackendRadioWidget, "widget", "name", "wiz_stack");
if (nBackendRadioWidget)
nBackendRadioWidget=GWEN_XMLNode_FindFirstTag(nBackendRadioWidget, "widget", "name", "backendRadioWidget");
subDialogs=GWEN_Dialog_List_new();
if (nBackendRadioWidget) {
GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *pit;
pit=GWEN_PluginDescription_List2_First(providers);
if (pit) {
GWEN_PLUGIN_DESCRIPTION *pd;
pd=GWEN_PluginDescription_List2Iterator_Data(pit);
while(pd) {
const char *name;
name=GWEN_PluginDescription_GetName(pd);
if (name && *name) {
AB_PROVIDER *pro;
pro=AB_Banking_GetProvider(ab, name);
if (pro) {
GWEN_DIALOG *cdlg;
GWEN_BUFFER *tbuf;
GWEN_XMLNODE *wn;
const char *s;
if (AB_Provider_GetFlags(pro) & AB_PROVIDER_FLAGS_HAS_USERTYPE_DIALOG) {
cdlg=AB_ProviderGetUserTypeDialog(pro);
if (cdlg==NULL) {
DBG_WARN(AQBANKING_LOGDOMAIN, "Backend [%s] does not return a userType dialog, using default", name);
cdlg=AB_UserTypePageDefaultDialog_new(ab);
}
}
else
cdlg=AB_UserTypePageDefaultDialog_new(ab);
tbuf=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Buffer_AppendString(tbuf, "backend_");
GWEN_Buffer_AppendString(tbuf, name);
GWEN_Buffer_AppendString(tbuf, "_radio");
wn=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "widget");
GWEN_XMLNode_SetProperty(wn, "type", "radioButton");
GWEN_XMLNode_SetProperty(wn, "name", GWEN_Buffer_GetStart(tbuf));
GWEN_StringList_AppendString(xdlg->backendRadioNames, GWEN_Buffer_GetStart(tbuf), 0, 0);
GWEN_StringList_AppendString(xdlg->backendNames, name, 0, 0);
s=GWEN_PluginDescription_GetShortDescr(pd);
if (!(s && *s))
s=name;
GWEN_XMLNode_SetProperty(wn, "text", I18N(s));
GWEN_XMLNode_SetProperty(wn, "groupId", "999999");
GWEN_XMLNode_SetProperty(wn, "flags", "fillX justifyLeft");
GWEN_XMLNode_AddChild(nBackendRadioWidget, wn);
GWEN_Dialog_List_Add(cdlg, subDialogs);
}
else {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Could not activate backend [%s]", name);
}
}
pd=GWEN_PluginDescription_List2Iterator_Next(pit);
}
GWEN_PluginDescription_List2Iterator_free(pit);
}
}
else {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Dialog description does not contain path [dialogVLayout/wiz_stack/backendRadioWidget]");
GWEN_XMLNode_Dump(nDialog, 2);
GWEN_XMLNode_free(n);
GWEN_Buffer_free(fbuf);
GWEN_Dialog_free(dlg);
return NULL;
}
}
/* read dialog from dialog description file */
rv=GWEN_Dialog_ReadXml(dlg, nDialog);
if (rv<0) {
DBG_INFO(AQBANKING_LOGDOMAIN, "here (%d).", rv);
GWEN_Dialog_List_free(subDialogs);
GWEN_XMLNode_free(n);
GWEN_Buffer_free(fbuf);
GWEN_Dialog_free(dlg);
return NULL;
}
GWEN_XMLNode_free(n);
GWEN_Buffer_free(fbuf);
/* insert pages for each backend */
if (GWEN_Dialog_List_GetCount(subDialogs)) {
GWEN_DIALOG *cdlg;
while ( (cdlg=GWEN_Dialog_List_First(subDialogs)) ) {
GWEN_Dialog_List_Del(cdlg);
DBG_NOTICE(AQBANKING_LOGDOMAIN, "Adding dialog %s", GWEN_Dialog_GetId(cdlg));
rv=GWEN_Dialog_AddSubDialog(dlg, "wiz_stack", cdlg);
if (rv<0) {
DBG_INFO(AQBANKING_LOGDOMAIN, "here (%d)", rv);
GWEN_Dialog_List_free(subDialogs);
GWEN_Dialog_free(cdlg);
GWEN_Dialog_free(dlg);
return NULL;
}
GWEN_Dialog_List2_PushBack(xdlg->backendDialogs, cdlg);
}
}
GWEN_Dialog_List_free(subDialogs);
xdlg->banking=ab;
/* done */
return dlg;
}
