Project

General

Profile

Statistics
| Branch: | Tag: | Revision:

aqbanking / src / libs / aqbanking / types2 / imexporter_accountinfo.xml @ f4a16f5b

History | View | Annotate | Download (38.7 KB)

1
<?xml?>
2

    
3
<tm2>
4
  <type id="AB_IMEXPORTER_ACCOUNTINFO" type="pointer">
5
    <descr>
6
    </descr>
7

    
8
    <lang id="c">
9
      <identifier>AB_IMEXPORTER_ACCOUNTINFO</identifier>
10
      <prefix>AB_ImExporterAccountInfo</prefix>
11
      
12
      <baseFileName>imexporter_accountInfo</baseFileName>
13
      
14
      <flags>
15
        with_db
16
        with_xml
17
        with_list1
18
        with_list2
19
        with_refcount
20
        with_hash
21
      </flags>
22
      
23
      <headers>
24
        <header type="sys" loc="pre">aqbanking/error.h</header>
25
        <header type="sys" loc="pre">gwenhywfar/types.h</header>
26
        <header type="sys" loc="pre">gwenhywfar/gwentime.h</header>
27

    
28
        <header type="sys" loc="post">aqbanking/transaction.h</header>
29
        <header type="sys" loc="post">aqbanking/accstatus.h</header>
30
        <header type="sys" loc="post">aqbanking/document.h</header>
31
        <header type="sys" loc="post">aqbanking/account_type.h</header>
32
      </headers>
33

    
34

    
35

    
36
      <inlines>
37

    
38
        <inline loc="end" access="public">
39
          <typeFlagsMask>with_list2</typeFlagsMask>
40
          <typeFlagsValue>with_list2</typeFlagsValue>
41
          <content>
42
             $(api) int $(struct_prefix)_List2_freeAll($(struct_type)_LIST2 *tl);
43
          </content>
44
        </inline>
45

    
46
        <inline loc="code">
47
          <typeFlagsMask>with_list2</typeFlagsMask>
48
          <typeFlagsValue>with_list2</typeFlagsValue>
49
          <content>
50

    
51
             static $(struct_type) *$(struct_prefix)_List2__freeAll_cb($(struct_type) *t, void *user_data) {
52
               $(struct_prefix)_free(t);
53
               return NULL;
54
             }
55

    
56

    
57
             int $(struct_prefix)_List2_freeAll($(struct_type)_LIST2 *tl) {
58
               if (tl) {
59
                 $(struct_prefix)_List2_ForEach(tl, $(struct_prefix)_List2__freeAll_cb, NULL);
60
                 $(struct_prefix)_List2_free(tl); 
61
               }
62
               else {
63
                 DBG_ERROR(AQBANKING_LOGDOMAIN, "List missing");
64
                 return GWEN_ERROR_INVALID;
65
               }
66
               return 0;
67
             }
68
          </content>
69
        </inline>
70

    
71

    
72

    
73
        <inline loc="end" access="public">
74
          <content>
75
             $(api) AB_TRANSACTION *$(struct_prefix)_GetFirstTransaction(const $(struct_type) *t, int ty, int cmd);
76
          </content>
77
        </inline>
78

    
79
        <inline loc="code">
80
          <content>
81
             AB_TRANSACTION *$(struct_prefix)_GetFirstTransaction(const $(struct_type) *st, int ty, int cmd) {
82
               assert(st);
83
               if (st->transactionList)
84
                 return AB_Transaction_List_FindFirstByType(st->transactionList, ty, cmd);
85
               return NULL;
86
             }
87
          </content>
88
        </inline>
89

    
90

    
91

    
92
        <inline loc="end" access="public">
93
          <content>
94
             $(api) void $(struct_prefix)_AddTransaction($(struct_type) *st, AB_TRANSACTION *t);
95
          </content>
96
        </inline>
97

    
98
        <inline loc="code">
99
          <content>
100
             void $(struct_prefix)_AddTransaction($(struct_type) *st, AB_TRANSACTION *t) {
101
               assert(st);
102
               if (NULL==st->transactionList)
103
                 st->transactionList=AB_Transaction_List_new();
104
               AB_Transaction_List_Add(t, st->transactionList);
105
             }
106
          </content>
107
        </inline>
108

    
109

    
110

    
111
        <inline loc="end" access="public">
112
          <content>
113
             $(api) int $(struct_prefix)_GetTransactionCount(const $(struct_type) *t, int ty, int cmd);
114
          </content>
115
        </inline>
116

    
117
        <inline loc="code">
118
          <content>
119
             int $(struct_prefix)_GetTransactionCount(const $(struct_type) *st, int ty, int cmd) {
120
               assert(st);
121
               if (st->transactionList)
122
                 return AB_Transaction_List_CountByType(st->transactionList, ty, cmd);
123
               return 0;
124
             }
125
          </content>
126
        </inline>
127

    
128

    
129
        <inline loc="end" access="public">
130
          <content>
131
             $(api) AB_BALANCE *$(struct_prefix)_GetFirstBalance(const $(struct_type) *as);
132
          </content>
133
        </inline>
134

    
135
        <inline loc="code">
136
          <content>
137
             AB_BALANCE *$(struct_prefix)_GetFirstBalance(const $(struct_type) *st) {
138
               assert(st);
139
               if (st->balanceList)
140
                 return AB_Balance_List_First(st->balanceList);
141
               return NULL;
142
             }
143
          </content>
144
        </inline>
145

    
146

    
147
        <inline loc="end" access="public">
148
          <content>
149
             $(api) void $(struct_prefix)_AddBalance($(struct_type) *st, AB_BALANCE *bal);
150
          </content>
151
        </inline>
152

    
153
        <inline loc="code">
154
          <content>
155
             void $(struct_prefix)_AddBalance($(struct_type) *st, AB_BALANCE *bal) {
156
               assert(bal);
157
               if (NULL==st->balanceList)
158
                 st->balanceList=AB_Balance_List_new();
159
               AB_Balance_List_Add(bal, st->balanceList);
160
             }
161
          </content>
162
        </inline>
163

    
164

    
165

    
166
        <inline loc="end" access="public">
167
          <content>
168
             $(api) AB_DOCUMENT *$(struct_prefix)_GetFirstEStatement(const $(struct_type) *st);
169
          </content>
170
        </inline>
171

    
172
        <inline loc="code">
173
          <content>
174
             AB_DOCUMENT *$(struct_prefix)_GetFirstEStatement(const $(struct_type) *st) {
175
               assert(st);
176
               if (st->eStatementList)
177
                 return AB_Document_List_First(st->eStatementList);
178
               return NULL;
179
             }
180
          </content>
181
        </inline>
182

    
183

    
184

    
185
        <inline loc="end" access="public">
186
          <content>
187
             $(api) void $(struct_prefix)_AddEStatement($(struct_type) *st, AB_DOCUMENT *d);
188
          </content>
189
        </inline>
190

    
191
        <inline loc="code">
192
          <content>
193
             void $(struct_prefix)_AddEStatement($(struct_type) *st, AB_DOCUMENT *d) {
194
               assert(d);
195
               if (NULL==st->eStatementList)
196
                 st->eStatementList=AB_Document_List_new();
197
               AB_Document_List_Add(d, st->eStatementList);
198
             }
199
          </content>
200
        </inline>
201

    
202

    
203

    
204
        <inline loc="end" access="public">
205
          <content>
206
             /** \n
207
              * This function clears the account info (e.g. removes all transactions etc). \n
208
              */ \n
209
             $(api) void $(struct_prefix)_Clear($(struct_type) *st);
210
          </content>
211
        </inline>
212

    
213
        <inline loc="code">
214
          <content>
215
             void $(struct_prefix)_Clear($(struct_type) *st) {
216
               assert(st);
217
               if (st->transactionList)
218
                 AB_Transaction_List_Clear(st->transactionList);
219
               if (st->balanceList)
220
                 AB_Balance_List_Clear(st->balanceList);
221
               if (st->eStatementList)
222
                 AB_Document_List_Clear(st->eStatementList);
223
             }
224
          </content>
225
        </inline>
226

    
227

    
228
<!--
229
        <inline loc="end" access="protected">
230
          <content>
231
             $(api) void $(struct_prefix)_FillFromAccount($(struct_type) *st, const AB_ACCOUNT *a);
232
          </content>
233
        </inline>
234

235
        <inline loc="code">
236
          <content>
237
             void $(struct_prefix)_FillFromAccount($(struct_type) *st, const AB_ACCOUNT *a) {
238
               const char *s;
239
               AB_ACCOUNT_TYPE at;
240
             
241
               assert(st);
242
               assert(a);
243
             
244
               s=AB_Account_GetBankCode(a);
245
               $(struct_prefix)_SetBankCode(st, s);
246
             
247
               s=AB_Account_GetBankName(a);
248
               $(struct_prefix)_SetBankName(st, s);
249
             
250
               s=AB_Account_GetAccountNumber(a);
251
               $(struct_prefix)_SetAccountNumber(st, s);
252

253
               s=AB_Account_GetSubAccountId(a);
254
               $(struct_prefix)_SetSubAccountId(st, s);
255

256
               $(struct_prefix)_SetAccountId(st, AB_Account_GetUniqueId(a));
257
             
258
               s=AB_Account_GetAccountName(a);
259
               $(struct_prefix)_SetAccountName(st, s);
260
             
261
               s=AB_Account_GetIban(a);
262
               $(struct_prefix)_SetIban(st, s);
263
             
264
               s=AB_Account_GetBic(a);
265
               $(struct_prefix)_SetBic(st, s);
266
             
267
               s=AB_Account_GetCurrency(a);
268
               $(struct_prefix)_SetCurrency(st, s);
269
             
270
               s=AB_Account_GetOwnerName(a);
271
               $(struct_prefix)_SetOwner(st, s);
272
             
273
               at=AB_Account_GetAccountType(a);
274
               $(struct_prefix)_SetAccountType(st, at);
275
             }
276
          </content>
277
        </inline>
278
-->
279

    
280

    
281
        <inline loc="end" access="public">
282
          <content>
283
             $(api) void $(struct_prefix)_FillFromTransaction($(struct_type) *st, const AB_TRANSACTION *t);
284
          </content>
285
        </inline>
286

    
287
        <inline loc="code">
288
          <content>
289
             void $(struct_prefix)_FillFromTransaction($(struct_type) *st, const AB_TRANSACTION *t) {
290
               const char *s;
291

    
292
               assert(st);
293
               assert(t);
294
             
295
               s=AB_Transaction_GetLocalBankCode(t);
296
               $(struct_prefix)_SetBankCode(st, s);
297
             
298
               s=AB_Transaction_GetLocalAccountNumber(t);
299
               $(struct_prefix)_SetAccountNumber(st, s);
300

    
301
               s=AB_Transaction_GetLocalSuffix(t);
302
               $(struct_prefix)_SetSubAccountId(st, s);
303
             
304
               s=AB_Transaction_GetLocalIban(t);
305
               $(struct_prefix)_SetIban(st, s);
306
             
307
               s=AB_Transaction_GetLocalBic(t);
308
               $(struct_prefix)_SetBic(st, s);
309
             
310
               s=AB_Transaction_GetLocalName(t);
311
               $(struct_prefix)_SetOwner(st, s);
312
             }
313
          </content>
314
        </inline>
315

    
316

    
317

    
318
        <inline loc="end" access="public">
319
          <content>
320
             $(api) AB_IMEXPORTER_ACCOUNTINFO *$(struct_prefix)_List_GetByBankCodeAndAccountNumber($(struct_type)_LIST *l, 
321
                                                                                                   const char *bankCode,
322
                                                                                                   const char *accountNumber,
323
                                                                                                   int accountType);
324
          </content>
325
        </inline>
326

    
327
        <inline loc="code">
328
          <content>
329
             AB_IMEXPORTER_ACCOUNTINFO *$(struct_prefix)_List_GetByBankCodeAndAccountNumber($(struct_type)_LIST *l, 
330
                                                                                            const char *bankCode,
331
                                                                                            const char *accountNumber,
332
                                                                                            int accountType) {
333
               AB_IMEXPORTER_ACCOUNTINFO *iea;
334
             
335
               assert(l);
336
               
337
               if (!bankCode)
338
                 bankCode="";
339
               if (!accountNumber)
340
                 accountNumber="";
341
             
342
               iea=$(struct_prefix)_List_First(l);
343
               while(iea) {
344
                 const char *sBankCode;
345
                 const char *sAccountNumber;
346
             
347
                 sBankCode=$(struct_prefix)_GetBankCode(iea);
348
                 if (sBankCode==NULL)
349
                   sBankCode="";
350
                 sAccountNumber=$(struct_prefix)_GetAccountNumber(iea);
351
                 if (sAccountNumber==NULL)
352
                   sAccountNumber="";
353

    
354
                 if ((strcasecmp(sBankCode, bankCode)==0) &amp;&amp;
355
                     (strcasecmp(sAccountNumber, accountNumber)==0) &amp;&amp;
356
                     ((accountType&lt;=AB_AccountType_Unknown) || (accountType==$(struct_prefix)_GetAccountType(iea)))
357
                    )
358
                   return iea;
359
                 
360
                 iea=$(struct_prefix)_List_Next(iea);
361
               }
362
               
363
               return NULL;
364
             }
365
          </content>
366
        </inline>
367

    
368

    
369

    
370
        <inline loc="end" access="public">
371
          <content>
372
             $(api) AB_IMEXPORTER_ACCOUNTINFO *$(struct_prefix)_List_Find($(struct_type)_LIST *l,
373
                                                                          uint32_t uniqueId,
374
                                                                          const char *iban,
375
                                                                          const char *bankCode,
376
                                                                          const char *accountNumber,
377
                                                                          int accountType);
378
          </content>
379
        </inline>
380

    
381
        <inline loc="code">
382
          <content>
383
             AB_IMEXPORTER_ACCOUNTINFO *$(struct_prefix)_List_Find($(struct_type)_LIST *l,
384
                                                                   uint32_t uniqueId,
385
                                                                   const char *iban,
386
                                                                   const char *bankCode,
387
                                                                   const char *accountNumber,
388
                                                                   int accountType) {
389
               AB_IMEXPORTER_ACCOUNTINFO *iea=NULL;
390
             
391
               assert(l);
392
               
393
               if (uniqueId)
394
                 iea=$(struct_prefix)_List_GetByAccountId(l, uniqueId);
395
               
396
               if (iea==NULL &amp;&amp; iban &amp;&amp; *iban)
397
                 $(struct_prefix)_List_GetByIban(l, iban);
398
               
399
               if (iea==NULL)
400
                 iea=$(struct_prefix)_List_GetByBankCodeAndAccountNumber(l, bankCode, accountNumber, accountType);
401
               
402
               return iea;
403
             }
404
          </content>
405
        </inline>
406

    
407

    
408

    
409

    
410
        <inline loc="end" access="public">
411
          <typeFlagsMask></typeFlagsMask>
412
          <typeFlagsValue></typeFlagsValue>
413
          <content>
414
             /** \n
415
              * Check whether a given account info object matches the given criteria.            \n
416
              * @param a account info object to match                                            \n
417
              * @param uniqueId unique account id (use 0 as wildcard)                            \n
418
              * @param country ISO code of the country (wildcards and jokers allowed)            \n
419
              * @param bankId bank code to search for (wildcards and jokers allowed)             \n
420
              * @param accountNumber account number to search for (wildcards and jokers allowed) \n
421
              * @param subAccountId sub account number (wildcards and jokers allowed)            \n
422
              * @param iban IBAN to search for (wildcards and jokers allowed)                    \n
423
              * @param currency currecny the account uses (wildcards and jokers allowed)         \n
424
              * @param ty account type (use AB_AccountType_Unknown as wildcard)                  \n
425
              */                                                                                 \n
426
             $(api) int $(struct_prefix)_Matches(const $(struct_type) *a,
427
                                                 uint32_t uniqueId,
428
                                                 const char *country,
429
                                                 const char *bankId,
430
                                                 const char *accountNumber,
431
                                                 const char *subAccountId,
432
                                                 const char *iban,
433
                                                 const char *currency,
434
                                                 int ty);
435
          </content>
436
        </inline>
437

    
438

    
439

    
440
        <inline loc="code">
441
          <typeFlagsMask></typeFlagsMask>
442
          <typeFlagsValue></typeFlagsValue>
443
          <content>
444
             int $(struct_prefix)_Matches(const $(struct_type) *a,
445
                                          uint32_t uniqueId,
446
                                          const char *country,
447
                                          const char *bankId,
448
                                          const char *accountNumber,
449
                                          const char *subAccountId,
450
                                          const char *iban,
451
                                          const char *currency,
452
                                          int ty) {
453
               const char *lcountry;
454
               const char *lbankId;
455
               const char *laccountNumber;
456
               const char *lsubAccountId;
457
               const char *liban;
458
               const char *lcurrency;
459
               int lty;
460
  
461
               if (!country) country="*";
462
               if (!bankId) bankId="*";
463
               if (!accountNumber) accountNumber="*";
464
               if (!subAccountId) subAccountId="*";
465
               if (!iban) iban="*";
466
               if (!currency) currency="*";
467
               if (ty>=AB_AccountType_Last) ty=AB_AccountType_Unknown;
468
             
469
           
470
               lcountry=$(struct_prefix)_GetCountry(a);
471
               lbankId=$(struct_prefix)_GetBankCode(a);
472
               laccountNumber=$(struct_prefix)_GetAccountNumber(a);
473
               lsubAccountId=$(struct_prefix)_GetSubAccountId(a);
474
               liban=$(struct_prefix)_GetIban(a);
475
               lcurrency=$(struct_prefix)_GetCurrency(a);
476
               lty=$(struct_prefix)_GetAccountType(a);
477
           
478
               if (!lcountry) lcountry="";
479
               if (!lbankId) lbankId="";
480
               if (!laccountNumber) laccountNumber="";
481
               if (!lsubAccountId) lsubAccountId="";
482
               if (!liban) liban="";
483
               if (!lcurrency) lcurrency="";
484
               if (lty>=AB_AccountType_Last || lty &lt;=AB_AccountType_Unknown) lty=AB_AccountType_Unknown;
485
           
486
               if (((uniqueId==0 || uniqueId==$(struct_prefix)_GetAccountId(a))) &amp;&amp;
487
                   (-1!=GWEN_Text_ComparePattern(lcountry, country, 0)) &amp;&amp;
488
                   (-1!=GWEN_Text_ComparePattern(lbankId, bankId, 0)) &amp;&amp;
489
                   (-1!=GWEN_Text_ComparePattern(laccountNumber, accountNumber, 0)) &amp;&amp;
490
                   (-1!=GWEN_Text_ComparePattern(lsubAccountId, subAccountId, 0)) &amp;&amp;
491
                   (-1!=GWEN_Text_ComparePattern(liban, iban, 0)) &amp;&amp;
492
                   (-1!=GWEN_Text_ComparePattern(lcurrency, currency, 0)) &amp;&amp;
493
                   ((ty==AB_AccountType_Unknown) || (ty==lty)))
494
                 return 1;
495
             
496
               return 0;
497
             }
498
          </content>
499
        </inline>
500

    
501

    
502
        <inline loc="end" access="private">
503
          <typeFlagsMask>with_list1</typeFlagsMask>
504
          <typeFlagsValue>with_list1</typeFlagsValue>
505
          <content>
506
             /** \n
507
              * Find an account info object in a list of account info objects.                   \n
508
              * @param a account info object with which to start searching                       \n
509
              * @param uniqueId unique account id (use 0 as wildcard)                            \n
510
              * @param country ISO code of the country (wildcards and jokers allowed)            \n
511
              * @param bankId bank code to search for (wildcards and jokers allowed)             \n
512
              * @param accountNumber account number to search for (wildcards and jokers allowed) \n
513
              * @param subAccountId sub account number (wildcards and jokers allowed)            \n
514
              * @param iban IBAN to search for (wildcards and jokers allowed)                    \n
515
              * @param currency currecny the account uses (wildcards and jokers allowed)         \n
516
              * @param ty account type (use AB_AccountType_Unknown as wildcard)                  \n
517
              */                                                                                 \n
518
             $(struct_type) *$(struct_prefix)_List__FindInternal($(struct_type) *a,
519
                                                                 uint32_t uniqueId,
520
                                                                 const char *country,
521
                                                                 const char *bankId,
522
                                                                 const char *accountNumber,
523
                                                                 const char *subAccountId,
524
                                                                 const char *iban,
525
                                                                 const char *currency,
526
                                                                 int ty);
527
          </content>
528
        </inline>
529

    
530

    
531

    
532
        <inline loc="code">
533
          <typeFlagsMask>with_list1</typeFlagsMask>
534
          <typeFlagsValue>with_list1</typeFlagsValue>
535
          <content>
536
             $(struct_type) *$(struct_prefix)_List__FindInternal($(struct_type) *a,
537
                                                                uint32_t uniqueId,
538
                                                                const char *country,
539
                                                                const char *bankId,
540
                                                                const char *accountNumber,
541
                                                                const char *subAccountId,
542
                                                                const char *iban,
543
                                                                const char *currency,
544
                                                                int ty) {
545

    
546

    
547
               if (!country) country="*";
548
               if (!bankId) bankId="*";
549
               if (!accountNumber) accountNumber="*";
550
               if (!subAccountId) subAccountId="*";
551
               if (!iban) iban="*";
552
               if (!currency) currency="*";
553
               if (ty>=AB_AccountType_Last) ty=AB_AccountType_Unknown;
554
             
555
               while(a) {
556
                 int rv;
557
                   
558
                 rv=$(struct_prefix)_Matches(a,
559
                                             uniqueId,
560
                                             country,
561
                                             bankId,
562
                                             accountNumber,
563
                                             subAccountId,
564
                                             iban,
565
                                             currency,
566
                                             ty);
567
                 if (rv==1)
568
                   break;
569
                 a=$(struct_prefix)_List_Next(a);
570
               } /* while */
571
             
572
               return a;
573
             }
574
          </content>
575
        </inline>
576

    
577

    
578

    
579
        <inline loc="end" access="public">
580
          <typeFlagsMask>with_list1</typeFlagsMask>
581
          <typeFlagsValue>with_list1</typeFlagsValue>
582
          <content>
583
             /** \n
584
              * Find the first matching account info object in a list of account info objects.   \n
585
              * @param al list of account info objects among to search                           \n
586
              * @param uniqueId unique account id (use 0 as wildcard)                            \n
587
              * @param country ISO code of the country (wildcards and jokers allowed)            \n
588
              * @param bankId bank code to search for (wildcards and jokers allowed)             \n
589
              * @param accountNumber account number to search for (wildcards and jokers allowed) \n
590
              * @param subAccountId sub account number (wildcards and jokers allowed)            \n
591
              * @param iban IBAN to search for (wildcards and jokers allowed)                    \n
592
              * @param currency currecny the account uses (wildcards and jokers allowed)         \n
593
              * @param ty account type (use AB_AccountType_Unknown as wildcard)          \n
594
              */                                                                                 \n
595
             $(api) $(struct_type) *$(struct_prefix)_List_FindFirst($(struct_type)_LIST *al,
596
                                                                    uint32_t uniqueId,
597
                                                                    const char *country,
598
                                                                    const char *bankId,
599
                                                                    const char *accountNumber,
600
                                                                    const char *subAccountId,
601
                                                                    const char *iban,
602
                                                                    const char *currency,
603
                                                                    int ty);
604
          </content>
605
        </inline>
606

    
607

    
608

    
609
        <inline loc="code">
610
          <typeFlagsMask>with_list1</typeFlagsMask>
611
          <typeFlagsValue>with_list1</typeFlagsValue>
612
          <content>
613
             $(struct_type) *$(struct_prefix)_List_FindFirst($(struct_type)_LIST *al,
614
                                                             uint32_t uniqueId,
615
                                                             const char *country,
616
                                                             const char *bankId,
617
                                                             const char *accountNumber,
618
                                                             const char *subAccountId,
619
                                                             const char *iban,
620
                                                             const char *currency,
621
                                                             int ty) {
622
               $(struct_type) *a;
623
             
624
               if ($(struct_prefix)_List_GetCount(al)==0) {
625
                 DBG_INFO(AQBANKING_LOGDOMAIN, "No accounts");
626
                 return NULL;
627
               }
628
               a=$(struct_prefix)_List_First(al);
629
               assert(a);
630

    
631
               return $(struct_prefix)_List__FindInternal(a, 
632
                                                          uniqueId,
633
                                                          country,
634
                                                          bankId,
635
                                                          accountNumber,
636
                                                          subAccountId,
637
                                                          iban,
638
                                                          currency,
639
                                                          ty);
640
             }
641
          </content>
642
        </inline>
643

    
644

    
645

    
646
        <inline loc="end" access="public">
647
          <typeFlagsMask>with_list1</typeFlagsMask>
648
          <typeFlagsValue>with_list1</typeFlagsValue>
649
          <content>
650
             /** \n
651
              * Find the next matching account info object in a list of account info objects.    \n
652
              * @param a previous matching account info objects among to search                  \n
653
              * @param uniqueId unique account id (use 0 as wildcard)                            \n
654
              * @param country ISO code of the country (wildcards and jokers allowed)            \n
655
              * @param bankId bank code to search for (wildcards and jokers allowed)             \n
656
              * @param accountNumber account number to search for (wildcards and jokers allowed) \n
657
              * @param subAccountId sub account number (wildcards and jokers allowed)            \n
658
              * @param iban IBAN to search for (wildcards and jokers allowed)                    \n
659
              * @param currency currecny the account uses (wildcards and jokers allowed)         \n
660
              * @param ty account type (use AB_AccountType_Unknown as wildcard)          \n
661
              */                                                                                 \n
662
             $(api) $(struct_type) *$(struct_prefix)_List_FindNext($(struct_type) *a,
663
                                                                     uint32_t uniqueId,
664
                                                                     const char *country,
665
                                                                     const char *bankId,
666
                                                                     const char *accountNumber,
667
                                                                     const char *subAccountId,
668
                                                                     const char *iban,
669
                                                                     const char *currency,
670
                                                                     int ty);
671
          </content>
672
        </inline>
673

    
674

    
675

    
676
        <inline loc="code">
677
          <typeFlagsMask>with_list1</typeFlagsMask>
678
          <typeFlagsValue>with_list1</typeFlagsValue>
679
          <content>
680
             $(struct_type) *$(struct_prefix)_List_FindNext($(struct_type) *a,
681
                                                              uint32_t uniqueId,
682
                                                              const char *country,
683
                                                              const char *bankId,
684
                                                              const char *accountNumber,
685
                                                              const char *subAccountId,
686
                                                              const char *iban,
687
                                                              const char *currency,
688
                                                              int ty) {
689
               assert(a);
690

    
691
               a=$(struct_prefix)_List_Next(a);
692
               if (a==NULL) {
693
                 DBG_INFO(AQBANKING_LOGDOMAIN, "No more account specs");
694
                 return NULL;
695
               }
696
               return $(struct_prefix)_List__FindInternal(a, 
697
                                                          uniqueId,
698
                                                          country,
699
                                                          bankId,
700
                                                          accountNumber,
701
                                                          subAccountId,
702
                                                          iban,
703
                                                          currency,
704
                                                          ty);
705
             }
706
          </content>
707
        </inline>
708

    
709

    
710

    
711

    
712
<!--
713
        <inline loc="end" access="public">
714
          <content>
715
             $(api) AB_IMEXPORTER_ACCOUNTINFO *$(struct_prefix)_List_GetByAccount($(struct_type)_LIST *l, const AB_ACCOUNT *a);
716
          </content>
717
        </inline>
718

719
        <inline loc="code">
720
          <content>
721
             AB_IMEXPORTER_ACCOUNTINFO *$(struct_prefix)_List_GetByAccount($(struct_type)_LIST *l, const AB_ACCOUNT *a) {
722
               assert(l);
723
               assert(a);
724
               
725
               return $(struct_prefix)_List_Find(l,
726
                                                 AB_Account_GetUniqueId(a),
727
                                                 AB_Account_GetIban(a),
728
                                                 AB_Account_GetBankCode(a),
729
                                                 AB_Account_GetAccountNumber(a),
730
                                                 AB_Account_GetAccountType(a));
731
             }
732
          </content>
733
        </inline>
734

735

736
        <inline loc="end" access="public">
737
          <content>
738
             $(api) AB_IMEXPORTER_ACCOUNTINFO *$(struct_prefix)_List_GetOrAddByAccount($(struct_type)_LIST *l, const AB_ACCOUNT *a);
739
          </content>
740
        </inline>
741

742
        <inline loc="code">
743
          <content>
744
             AB_IMEXPORTER_ACCOUNTINFO *$(struct_prefix)_List_GetOrAddByAccount($(struct_type)_LIST *l, const AB_ACCOUNT *a) {
745
               AB_IMEXPORTER_ACCOUNTINFO *iea=NULL;
746
             
747
               assert(l);
748
               
749
               iea=$(struct_prefix)_List_GetByAccount(l, a);
750
               if (iea==NULL) {
751
                 iea=$(struct_prefix)_new();
752
                 $(struct_prefix)_FillFromAccount(iea, a);
753
                 $(struct_prefix)_List_Add(iea, l);
754
               }
755
               return iea;
756
             }
757
          </content>
758
        </inline>
759
-->
760

    
761
        <inline loc="end" access="public">
762
          <content>
763
             $(api) AB_IMEXPORTER_ACCOUNTINFO *$(struct_prefix)_List_GetOrAdd($(struct_type)_LIST *l,
764
                                                                              uint32_t uniqueId,
765
                                                                              const char *iban,
766
                                                                              const char *bankCode,
767
                                                                              const char *accountNumber,
768
                                                                              int accountType);
769
          </content>
770
        </inline>
771

    
772
        <inline loc="code">
773
          <content>
774
             AB_IMEXPORTER_ACCOUNTINFO *$(struct_prefix)_List_GetOrAdd($(struct_type)_LIST *l,
775
                                                                       uint32_t uniqueId,
776
                                                                       const char *iban,
777
                                                                       const char *bankCode,
778
                                                                       const char *accountNumber,
779
                                                                       int accountType) {
780
               AB_IMEXPORTER_ACCOUNTINFO *iea=NULL;
781
             
782
               assert(l);
783
               
784
               iea=$(struct_prefix)_List_Find(l, uniqueId, iban, bankCode, accountNumber, accountType);
785
               if (iea==NULL) {
786
                 iea=$(struct_prefix)_new();
787
                 $(struct_prefix)_SetAccountId(iea, uniqueId);
788
                 $(struct_prefix)_SetIban(iea, iban);
789
                 $(struct_prefix)_SetBankCode(iea, bankCode);
790
                 $(struct_prefix)_SetAccountNumber(iea, accountNumber);
791
                 $(struct_prefix)_SetAccountType(iea, accountType);
792
                 
793
                 $(struct_prefix)_List_Add(iea, l);
794
               }
795
               return iea;
796
             }
797
          </content>
798
        </inline>
799

    
800

    
801

    
802
      </inlines>
803

    
804

    
805
    </lang>
806

    
807
    <enums>
808

    
809
    </enums>
810

    
811
    <defines>
812

    
813
    </defines>
814

    
815

    
816
    <members>
817

    
818
      <member name="country" type="char_ptr" maxlen="16" >
819
        <descr>
820
        </descr>
821
        <access>public</access>
822
        <flags>own with_hash</flags>
823
        <setflags>const dup</setflags>
824
        <getflags>const</getflags>
825
      </member>
826

    
827
      <member name="bankCode" type="char_ptr" maxlen="16" >
828
        <descr>
829
        </descr>
830
        <access>public</access>
831
        <flags>own with_hash</flags>
832
        <setflags>const dup</setflags>
833
        <getflags>const</getflags>
834
      </member>
835

    
836
      <member name="bankName" type="char_ptr" maxlen="64" >
837
        <descr>
838
        </descr>
839
        <access>public</access>
840
        <flags>own with_hash</flags>
841
        <setflags>const dup</setflags>
842
        <getflags>const</getflags>
843
      </member>
844

    
845
      <member name="accountNumber" type="char_ptr" maxlen="32" >
846
        <descr>
847
        </descr>
848
        <access>public</access>
849
        <flags>own with_hash</flags>
850
        <setflags>const dup</setflags>
851
        <getflags>const</getflags>
852
      </member>
853

    
854
      <member name="subAccountId" type="char_ptr" maxlen="32" >
855
        <descr>
856
        </descr>
857
        <access>public</access>
858
        <flags>own with_hash</flags>
859
        <setflags>const dup</setflags>
860
        <getflags>const</getflags>
861
      </member>
862

    
863
      <member name="accountName" type="char_ptr" maxlen="64" >
864
        <descr>
865
        </descr>
866
        <access>public</access>
867
        <flags>own with_hash</flags>
868
        <setflags>const dup</setflags>
869
        <getflags>const</getflags>
870
      </member>
871

    
872
      <member name="iban" type="char_ptr" maxlen="32" >
873
        <descr>
874
        </descr>
875
        <access>public</access>
876
        <flags>own with_hash with_getbyMember</flags>
877
        <setflags>const dup</setflags>
878
        <getflags>const</getflags>
879
      </member>
880

    
881
      <member name="bic" type="char_ptr" maxlen="32" >
882
        <descr>
883
        </descr>
884
        <access>public</access>
885
        <flags>own with_hash</flags>
886
        <setflags>const dup</setflags>
887
        <getflags>const</getflags>
888
      </member>
889

    
890
      <member name="owner" type="char_ptr" maxlen="64" >
891
        <descr>
892
        </descr>
893
        <access>public</access>
894
        <flags>own with_hash</flags>
895
        <setflags>const dup</setflags>
896
        <getflags>const</getflags>
897
      </member>
898

    
899
      <member name="currency" type="char_ptr" maxlen="16" >
900
        <descr>
901
        </descr>
902
        <access>public</access>
903
        <flags>own with_hash</flags>
904
        <setflags>const dup</setflags>
905
        <getflags>const</getflags>
906
      </member>
907

    
908
      <member name="description" type="char_ptr" maxlen="64" >
909
        <descr>
910
        </descr>
911
        <access>public</access>
912
        <flags>own with_hash</flags>
913
        <setflags>const dup</setflags>
914
        <getflags>const</getflags>
915
      </member>
916

    
917
      <member name="accountType" type="int" maxlen="4" >
918
        <default>0</default>
919
        <preset>0</preset>
920
        <access>public</access>
921
        <flags>with_hash</flags>
922
        <setflags>none</setflags>
923
        <getflags>none</getflags>
924
      </member>
925

    
926
      <member name="accountId" type="uint32_t" maxlen="4">
927
        <flags>with_hash with_getbyMember</flags>
928
        <default>0</default>
929
        <preset>0</preset>
930
        <access>public</access>
931
        <descr>
932
        </descr>
933
      </member>
934

    
935
      <member name="balanceList" type="AB_BALANCE_LIST" elementName="balance">
936
        <descr>
937
        </descr>
938
        <default>NULL</default>
939
        <preset>AB_Balance_List_new()</preset>
940
        <access>public</access>
941
        <flags>own</flags>
942
        <setflags>nodup</setflags>
943
        <getflags>none</getflags>
944
      </member>
945

    
946

    
947
      <member name="transactionList" type="AB_TRANSACTION_LIST" elementName="transaction">
948
        <descr>
949
          List of transactions.
950
          This list contains any kind of transactions all in one list. You can differentiate the type
951
          of the transaction (e.g. bank statement, debit note, transfer etc) by looking at the transaction type
952
          (see @ref AB_Transaction_GetType).
953
        </descr>
954
        <default>NULL</default>
955
        <preset>AB_Transaction_List_new()</preset>
956
        <access>public</access>
957
        <flags>own</flags>
958
        <setflags>nodup</setflags>
959
        <getflags>none</getflags>
960
      </member>
961

    
962
      <member name="eStatementList" type="AB_DOCUMENT_LIST" elementName="eStatement">
963
        <descr>
964
        </descr>
965
        <default>NULL</default>
966
        <preset>AB_Document_List_new()</preset>
967
        <access>public</access>
968
        <flags>own</flags>
969
        <setflags>nodup</setflags>
970
        <getflags>none</getflags>
971
      </member>
972

    
973
    </members>
974

    
975
    
976
  </type>
977
  
978
</tm2>
979