1 /* ************************************************************************** */
2 /* */
3 /* Copyright (C) 2000-2008 Cédric Auger (cedric@grisbi.org) */
4 /* 2003-2008 Benjamin Drieu (bdrieu@april.org) */
5 /* https://www.grisbi.org */
6 /* */
7 /* This program is free software; you can redistribute it and/or modify */
8 /* it under the terms of the GNU General Public License as published by */
9 /* the Free Software Foundation; either version 2 of the License, or */
10 /* (at your option) any later version. */
11 /* */
12 /* This program is distributed in the hope that it will be useful, */
13 /* but WITHOUT ANY WARRANTY; without even the implied warranty of */
14 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
15 /* GNU General Public License for more details. */
16 /* */
17 /* You should have received a copy of the GNU General Public License */
18 /* along with this program; if not, write to the Free Software */
19 /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
20 /* */
21 /* ************************************************************************** */
22
23 /**
24 * \file gsb_data_payment.c
25 * work with the payment structure, no GUI here
26 */
27
28
29 #ifdef HAVE_CONFIG_H
30 #include "config.h"
31 #endif
32
33 #include "include.h"
34 #include <glib/gi18n.h>
35
36 /*START_INCLUDE*/
37 #include "gsb_data_payment.h"
38 #include "gsb_data_account.h"
39 #include "utils_str.h"
40 #include "erreur.h"
41 /*END_INCLUDE*/
42
43
44 /**
45 * \struct
46 * Describe a method of payment
47 */
48 typedef struct
49 {
50 gint payment_number;
51 gint account_number;
52 gchar *payment_name;
53 gint payment_sign; /**< GSB_PAYMENT_NEUTRAL, GSB_PAYMENT_DEBIT, GSB_PAYMENT_CREDIT */
54
55 gint show_entry; /**< when select it in form, need to show an entry (for cheque number for example) or not */
56 gint automatic_numbering; /**< for cheque number for example */
57 gchar *last_number; /**< the last number of cheque used */
58 } struct_payment;
59
60
61 /** contains the g_slist of struct_payment */
62 static GSList *payment_list = NULL;
63
64 /** a pointer to the last payment used (to increase the speed) */
65 static struct_payment *payment_buffer;
66
67 /*START_STATIC*/
68 static void _gsb_data_payment_free ( struct_payment *payment );
69 static struct_payment *gsb_data_payment_get_structure ( gint payment_number );
70 static gint gsb_data_payment_max_number ( void );
71 /*END_STATIC*/
72
73 /*START_EXTERN*/
74 /*END_EXTERN*/
75
76
77
78 /**
79 * set the payments global variables to NULL,
80 * usually when we init all the global variables
81 *
82 * \param
83 *
84 * \return FALSE
85 * */
gsb_data_payment_init_variables(void)86 gboolean gsb_data_payment_init_variables ( void )
87 {
88 if ( payment_list )
89 {
90 GSList* tmp_list = payment_list;
91 while ( tmp_list )
92 {
93 struct_payment *payment;
94 payment = tmp_list -> data;
95 tmp_list = tmp_list -> next;
96 _gsb_data_payment_free ( payment );
97 }
98 g_slist_free ( payment_list );
99 }
100 payment_list = NULL;
101 payment_buffer = NULL;
102
103 return FALSE;
104 }
105
106
107 /**
108 * find and return the structure of the payment asked
109 *
110 * \param payment_number number of payment
111 *
112 * \return the struct_payment corresponding to the payment_number or NULL
113 * */
gsb_data_payment_get_structure(gint payment_number)114 struct_payment *gsb_data_payment_get_structure ( gint payment_number )
115 {
116 GSList *tmp;
117
118 if (!payment_number)
119 return NULL;
120
121 /* before checking all the payments, we check the buffer */
122 if ( payment_buffer
123 &&
124 payment_buffer -> payment_number == payment_number )
125 return payment_buffer;
126
127 tmp = payment_list;
128
129 while ( tmp )
130 {
131 struct_payment *payment;
132
133 payment = tmp -> data;
134
135 if ( payment -> payment_number == payment_number )
136 {
137 payment_buffer = payment;
138 return payment;
139 }
140
141 tmp = tmp -> next;
142 }
143 return NULL;
144 }
145
146
147 /**
148 * return the list of payment structure
149 * usefull when want to check all payments
150 *
151 * \param none
152 *
153 * \return the g_slist of payments structure
154 * */
gsb_data_payment_get_payments_list(void)155 GSList *gsb_data_payment_get_payments_list ( void )
156 {
157 return payment_list;
158 }
159
160 /**
161 * return a newly allocated list with the payments numbers for
162 * the asked account
163 * usefull to know for example if there is some method of payments for that account
164 *
165 * \param account_number
166 *
167 * \return a newly allocated GSList of payments number (to be freed), or NULL if none
168 * */
gsb_data_payment_get_list_for_account(gint account_number)169 GSList *gsb_data_payment_get_list_for_account ( gint account_number )
170 {
171 GSList *tmp_list;
172 GSList *returned_list = NULL;
173
174 tmp_list = payment_list;
175
176 while ( tmp_list )
177 {
178 struct_payment *payment;
179
180 payment = tmp_list -> data;
181
182 if ( payment -> account_number == account_number )
183 returned_list = g_slist_append ( returned_list,
184 GINT_TO_POINTER (payment -> payment_number));
185
186 tmp_list = tmp_list -> next;
187 }
188 return returned_list;
189 }
190
191
192 /**
193 * return the number of the payment given in param
194 * and initialise the buffer
195 *
196 * \param payment_ptr a pointer to the struct of the payment
197 *
198 * \return the number of the payment, 0 if problem
199 * */
gsb_data_payment_get_number(gpointer payment_ptr)200 gint gsb_data_payment_get_number ( gpointer payment_ptr )
201 {
202 struct_payment *payment;
203
204 if ( !payment_ptr )
205 return 0;
206
207 payment = payment_ptr;
208 payment_buffer = payment;
209 return payment -> payment_number;
210 }
211
212
213 /**
214 * return the number of the payment given in param
215 *
216 * \param the name of the payment
217 * \param the account_number
218 *
219 * \return the number of the payment, 0 if problem
220 * */
gsb_data_payment_get_number_by_name(const gchar * name,gint account_number)221 gint gsb_data_payment_get_number_by_name ( const gchar *name,
222 gint account_number )
223 {
224 GSList *tmp_list;
225 gint payment_number = 0 ;
226
227 tmp_list = payment_list;
228
229 while ( tmp_list )
230 {
231 struct_payment *payment;
232
233 payment = tmp_list -> data;
234
235 if ( payment -> account_number == account_number )
236 {
237 if ( my_strcasecmp ((gchar *) name, payment -> payment_name ) == 0 )
238 return payment -> payment_number;
239 }
240 tmp_list = tmp_list -> next;
241 }
242
243 return payment_number;
244 }
245
246
247 /**
248 * find and return the last number of payment
249 * carrefull, it's an internal function to create a new payment number,
250 * nothing to see to the number of cheque we want to increase
251 *
252 * \param none
253 *
254 * \return last number of payment
255 * */
gsb_data_payment_max_number(void)256 gint gsb_data_payment_max_number ( void )
257 {
258 GSList *tmp;
259 gint number_tmp = 0;
260
261 tmp = payment_list;
262
263 while ( tmp )
264 {
265 struct_payment *payment;
266
267 payment = tmp -> data;
268
269 if ( payment -> payment_number > number_tmp )
270 number_tmp = payment -> payment_number;
271
272 tmp = tmp -> next;
273 }
274 return number_tmp;
275 }
276
277
278 /**
279 * create a new payment, give him a number, append it to the list
280 * and return the number
281 *
282 * \param name the name of the payment (can be freed after, it's a copy) or NULL
283 *
284 * \return the number of the new payment
285 * */
gsb_data_payment_new(const gchar * name)286 gint gsb_data_payment_new ( const gchar *name )
287 {
288 struct_payment *payment;
289
290 payment = g_malloc0 ( sizeof ( struct_payment ));
291 payment -> payment_number = gsb_data_payment_max_number () + 1;
292
293 if (name)
294 payment -> payment_name = my_strdup (name);
295 else
296 payment -> payment_name = NULL;
297
298 payment -> last_number = NULL;
299
300 payment_list = g_slist_append ( payment_list, payment );
301 payment_buffer = payment;
302
303 return payment -> payment_number;
304 }
305
306 /**
307 * This internal function is called to free the memory used by a struct_payment structure
308 */
_gsb_data_payment_free(struct_payment * payment)309 static void _gsb_data_payment_free ( struct_payment *payment )
310 {
311 if ( ! payment )
312 return;
313 if ( payment -> payment_name )
314 g_free ( payment -> payment_name );
315 if ( payment -> last_number )
316 g_free ( payment -> last_number );
317 g_free ( payment );
318
319 if ( payment_buffer == payment )
320 payment_buffer = NULL;
321 }
322
323 /**
324 * remove a payment
325 * set all the payments of transaction which are this one to 0
326 *
327 * \param payment_number the payment we want to remove
328 *
329 * \return TRUE ok
330 * */
gsb_data_payment_remove(gint payment_number)331 gboolean gsb_data_payment_remove ( gint payment_number )
332 {
333 struct_payment *payment;
334
335 payment = gsb_data_payment_get_structure ( payment_number );
336
337 if (!payment)
338 return FALSE;
339
340 payment_list = g_slist_remove ( payment_list,
341 payment );
342
343 _gsb_data_payment_free (payment);
344
345 return TRUE;
346 }
347
348
349 /**
350 * set a new number for the payment
351 * normally used only while loading the file because
352 * the number are given automatically
353 *
354 * \param payment_number the number of the payment
355 * \param new_no_payment the new number of the payment
356 *
357 * \return the new number or 0 if the payment doen't exist
358 * */
gsb_data_payment_set_new_number(gint payment_number,gint new_no_payment)359 gint gsb_data_payment_set_new_number ( gint payment_number,
360 gint new_no_payment )
361 {
362 struct_payment *payment;
363
364 payment = gsb_data_payment_get_structure ( payment_number );
365
366 if (!payment)
367 return 0;
368
369 payment -> payment_number = new_no_payment;
370 return new_no_payment;
371 }
372
373
374 /**
375 * return the account_number of the method of payment
376 *
377 * \param payment_number the number of the method of payment
378 *
379 * \return the name of the payment or 0 if fail
380 * */
gsb_data_payment_get_account_number(gint payment_number)381 gint gsb_data_payment_get_account_number ( gint payment_number )
382 {
383 struct_payment *payment;
384
385 payment = gsb_data_payment_get_structure ( payment_number );
386
387 if (!payment)
388 return 0;
389
390 return payment -> account_number;
391 }
392
393
394 /**
395 * set the account_number of the method of payment
396 *
397 * \param payment_number the number of the method of payment
398 * \param account_number the account_number of the method of payment
399 *
400 * \return TRUE if ok or FALSE if problem
401 * */
gsb_data_payment_set_account_number(gint payment_number,gint account_number)402 gboolean gsb_data_payment_set_account_number ( gint payment_number,
403 gint account_number )
404 {
405 struct_payment *payment;
406
407 payment = gsb_data_payment_get_structure ( payment_number );
408
409 if (!payment)
410 return FALSE;
411
412 payment -> account_number = account_number;
413
414 return TRUE;
415 }
416
417
418 /**
419 * return the name of the payment
420 *
421 * \param payment_number the number of the payment
422 *
423 * \return the name of the payment or NULL if fail
424 * */
gsb_data_payment_get_name(gint payment_number)425 const gchar *gsb_data_payment_get_name ( gint payment_number )
426 {
427 struct_payment *payment;
428
429 payment = gsb_data_payment_get_structure ( payment_number );
430
431 if (!payment)
432 return NULL;
433
434 return payment -> payment_name;
435 }
436
437
438 /**
439 * set the name of the payment
440 * the value is dupplicate in memory
441 *
442 * \param payment_number the number of the payment
443 * \param name the name of the payment
444 *
445 * \return TRUE if ok or FALSE if problem
446 * */
gsb_data_payment_set_name(gint payment_number,const gchar * name)447 gboolean gsb_data_payment_set_name ( gint payment_number,
448 const gchar *name )
449 {
450 struct_payment *payment;
451
452 payment = gsb_data_payment_get_structure ( payment_number );
453
454 if (!payment)
455 return FALSE;
456
457 /* we free the last name */
458 if ( payment -> payment_name )
459 g_free (payment -> payment_name);
460
461 /* and copy the new one */
462 payment -> payment_name = my_strdup (name);
463
464 return TRUE;
465 }
466
467
468 /**
469 * return the sign of the method of payment
470 * GSB_PAYMENT_NEUTRAL : neutral sign (can be negative or positive)
471 * GSB_PAYMENT_DEBIT : debit
472 * GSB_PAYMENT_CREDIT : credit
473 *
474 * \param payment_number the number of the method of payment
475 *
476 * \return the sign of the payment or -1 if fail
477 * */
gsb_data_payment_get_sign(gint payment_number)478 gint gsb_data_payment_get_sign ( gint payment_number )
479 {
480 struct_payment *payment;
481
482 payment = gsb_data_payment_get_structure ( payment_number );
483
484 if (!payment)
485 return -1;
486
487 return payment -> payment_sign;
488 }
489
490
491 /**
492 * set the sign of the method of payment
493 *
494 * \param payment_number the number of the method of payment
495 * \param sign the sign of the method of payment
496 *
497 * \return TRUE if ok or FALSE if problem
498 * */
gsb_data_payment_set_sign(gint payment_number,gint sign)499 gboolean gsb_data_payment_set_sign ( gint payment_number,
500 gint sign )
501 {
502 struct_payment *payment;
503
504 payment = gsb_data_payment_get_structure ( payment_number );
505
506 if (!payment)
507 return FALSE;
508
509 payment -> payment_sign = sign;
510
511 return TRUE;
512 }
513
514
515 /**
516 * return the show_entry flag of the method of payment
517 * if TRUE, choosing that method of payment will show an entry in the form
518 * to set a number (cheque, transfer...)
519 *
520 * \param payment_number the number of the method of payment
521 *
522 * \return the show_entry flag of the payment or -1 if fail
523 * */
gsb_data_payment_get_show_entry(gint payment_number)524 gint gsb_data_payment_get_show_entry ( gint payment_number )
525 {
526 struct_payment *payment;
527
528 payment = gsb_data_payment_get_structure ( payment_number );
529
530 if (!payment)
531 return -1;
532
533 return payment -> show_entry;
534 }
535
536
537 /**
538 * set the show_entry of the method of payment
539 *
540 * \param payment_number the number of the method of payment
541 * \param show_entry the show_entry of the method of payment
542 *
543 * \return TRUE if ok or FALSE if problem
544 * */
gsb_data_payment_set_show_entry(gint payment_number,gint show_entry)545 gboolean gsb_data_payment_set_show_entry ( gint payment_number,
546 gint show_entry )
547 {
548 struct_payment *payment;
549
550 payment = gsb_data_payment_get_structure ( payment_number );
551
552 if (!payment)
553 return FALSE;
554
555 payment -> show_entry = show_entry;
556
557 return TRUE;
558 }
559
560
561 /**
562 * return the automatic_numbering of the method of payment
563 * if automatic_numbering is set and if show_entry is set,
564 * when choosing the method of payment in the form, an entry
565 * is showed and the content contains automatically the
566 * last_number for that method of payment + 1
567 *
568 * \param payment_number the number of the method of payment
569 *
570 * \return the automatic_numbering of the payment or -1 if fail
571 * */
gsb_data_payment_get_automatic_numbering(gint payment_number)572 gint gsb_data_payment_get_automatic_numbering ( gint payment_number )
573 {
574 struct_payment *payment;
575
576 payment = gsb_data_payment_get_structure ( payment_number );
577
578 if (!payment)
579 return -1;
580
581 return payment -> automatic_numbering;
582 }
583
584
585 /**
586 * set the automatic_numbering of the method of payment
587 *
588 * \param payment_number the number of the method of payment
589 * \param automatic_numbering the automatic_numbering of the method of payment
590 *
591 * \return TRUE if ok or FALSE if problem
592 * */
gsb_data_payment_set_automatic_numbering(gint payment_number,gint automatic_numbering)593 gboolean gsb_data_payment_set_automatic_numbering ( gint payment_number,
594 gint automatic_numbering )
595 {
596 struct_payment *payment;
597
598 payment = gsb_data_payment_get_structure ( payment_number );
599
600 if (!payment)
601 return FALSE;
602
603 payment -> automatic_numbering = automatic_numbering;
604
605 return TRUE;
606 }
607
608
609 /**
610 * used to find easily the transfer payment number for an account
611 * while importing transactions and if grisbi found a link between 2 transactions,
612 * it tries to set transfer as method of payment and use that function
613 * if necessary, we can modify that function to find any method of payment,
614 * but it's not usefull for now...
615 *
616 * \param account_number the account we want the transfer payment number
617 *
618 * \return the number of payment for transfer or 0 if not found
619 * */
gsb_data_payment_get_transfer_payment_number(gint account_number)620 gint gsb_data_payment_get_transfer_payment_number ( gint account_number )
621 {
622 GSList *tmp_list;
623
624 if (account_number < 0)
625 return 0;
626
627 tmp_list = payment_list;
628 while (tmp_list)
629 {
630 struct_payment *payment;
631
632 payment = tmp_list -> data;
633 if ( payment -> account_number == account_number )
634 if ( !my_strcasecmp (payment -> payment_name, _("Transfer") ) )
635 return payment -> payment_number;
636
637 tmp_list = tmp_list -> next;
638 }
639 return 0;
640 }
641
642 /**
643 * return the last_number of the method of payment
644 * this is the last number to set automatically that number + 1
645 * in the cheque entry ; nothing to deal with gsb_data_payment_max_number
646 * which give the last payment_number, internal number to count the method of payment
647 *
648 * \param payment_number the number of the method of payment
649 *
650 * \return the last_number of the payment or -1 if fail
651 * */
gsb_data_payment_get_last_number(gint payment_number)652 const gchar *gsb_data_payment_get_last_number ( gint payment_number )
653 {
654 struct_payment *payment;
655
656 payment = gsb_data_payment_get_structure ( payment_number );
657
658 if (!payment)
659 return NULL;
660
661 return payment -> last_number;
662 }
663
664
665 /**
666 * set the last_number of the method of payment
667 *
668 * \param payment_number the number of the method of payment
669 * \param last_number the last_number of the method of payment
670 *
671 * \return TRUE if ok or FALSE if problem
672 * */
gsb_data_payment_set_last_number(gint payment_number,const gchar * last_number)673 gboolean gsb_data_payment_set_last_number ( gint payment_number,
674 const gchar *last_number )
675 {
676 struct_payment *payment;
677
678 payment = gsb_data_payment_get_structure ( payment_number );
679
680 if (!payment)
681 return FALSE;
682
683 payment -> last_number = my_strdup ( last_number );
684
685 return TRUE;
686 }
687
688
689 /**
690 * create a set of preformated method of payment and associate
691 * them to the account given in param
692 * moreover, create a preformated list to sort the transaction list according to
693 * the method of payment, and set it in the account
694 *
695 * \param account_number
696 *
697 * \return TRUE ok, FALSE problem
698 * */
gsb_data_payment_create_default(gint account_number)699 gint gsb_data_payment_create_default ( gint account_number )
700 {
701 gint payment_number;
702 GSList *sort_list = NULL;
703 devel_debug_int ( account_number);
704 switch (gsb_data_account_get_kind (account_number))
705 {
706 case GSB_TYPE_BALANCE:
707 break;
708
709 case GSB_TYPE_CASH:
710 break;
711
712 case GSB_TYPE_ASSET:
713 break;
714
715 case GSB_TYPE_BANK:
716
717 /* create the method of payment for a bank account */
718 payment_number = gsb_data_payment_new (_("Transfer"));
719 gsb_data_payment_set_account_number ( payment_number, account_number );
720 gsb_data_payment_set_show_entry ( payment_number, 1 );
721 sort_list = g_slist_append ( sort_list, GINT_TO_POINTER (payment_number));
722
723 payment_number = gsb_data_payment_new (_("Deposit"));
724 gsb_data_payment_set_account_number ( payment_number, account_number );
725 gsb_data_payment_set_sign ( payment_number, 2 );
726 sort_list = g_slist_append ( sort_list, GINT_TO_POINTER (payment_number));
727
728 /* the deposit is the default credit for that account */
729 gsb_data_account_set_default_credit ( account_number,
730 payment_number );
731
732 payment_number = gsb_data_payment_new (_("Credit card"));
733 gsb_data_payment_set_account_number ( payment_number, account_number );
734 gsb_data_payment_set_sign ( payment_number, 1 );
735 sort_list = g_slist_append ( sort_list, GINT_TO_POINTER (payment_number));
736
737 /* the credit card is the default debit for that account */
738 gsb_data_account_set_default_debit ( account_number,
739 payment_number );
740
741 payment_number = gsb_data_payment_new (_("Direct debit"));
742 gsb_data_payment_set_account_number ( payment_number, account_number );
743 gsb_data_payment_set_sign ( payment_number, 1 );
744 sort_list = g_slist_append ( sort_list, GINT_TO_POINTER (payment_number));
745
746 payment_number = gsb_data_payment_new (_("Cheque"));
747 gsb_data_payment_set_account_number ( payment_number, account_number );
748 gsb_data_payment_set_sign ( payment_number, 1 );
749 gsb_data_payment_set_show_entry ( payment_number, 1 );
750 gsb_data_payment_set_automatic_numbering ( payment_number, 1 );
751 sort_list = g_slist_append ( sort_list, GINT_TO_POINTER (payment_number));
752 break;
753
754 case GSB_TYPE_LIABILITIES:
755
756 /* create the method of payment for a liabilities account */
757 payment_number = gsb_data_payment_new (_("Transfer"));
758 gsb_data_payment_set_account_number ( payment_number, account_number );
759 gsb_data_payment_set_show_entry ( payment_number, 1 );
760 sort_list = g_slist_append ( sort_list, GINT_TO_POINTER (payment_number));
761
762 gsb_data_account_set_default_debit ( account_number,
763 payment_number );
764 gsb_data_account_set_default_credit ( account_number,
765 payment_number );
766 }
767 if (sort_list)
768 gsb_data_account_set_sort_list ( account_number, sort_list );
769
770 return TRUE;
771 }
772
773
774 /**
775 * try to find a method of payment similar to the origin method of payment
776 *
777 * \param origin_payment the method of payment we try to find a similar other
778 * \param target_account_number the account we want to search into for the new method of payment
779 *
780 * \return the similar method of payment or default method of payment if nothing found
781 * */
gsb_data_payment_get_similar(gint origin_payment,gint target_account_number)782 gint gsb_data_payment_get_similar ( gint origin_payment,
783 gint target_account_number )
784 {
785 struct_payment *payment;
786 GSList *tmp_list;
787
788 payment = gsb_data_payment_get_structure (origin_payment);
789
790 if (!payment)
791 return 0;
792
793 tmp_list = payment_list;
794
795 while (tmp_list)
796 {
797 struct_payment *tmp_payment;
798
799 tmp_payment = tmp_list -> data;
800
801 if (tmp_payment -> account_number == target_account_number
802 &&
803 payment -> payment_name
804 &&
805 tmp_payment -> payment_name
806 &&
807 !strcmp (payment -> payment_name, tmp_payment -> payment_name)
808 &&
809 payment -> payment_sign == tmp_payment -> payment_sign)
810 return tmp_payment -> payment_number;
811
812 tmp_list = tmp_list -> next;
813 }
814
815 if (payment -> payment_sign == 1)
816 return gsb_data_account_get_default_debit (target_account_number);
817 else
818 return gsb_data_account_get_default_credit (target_account_number);
819 }
820
821
gsb_data_payment_incremente_last_number(gint payment_number,gint increment)822 gchar *gsb_data_payment_incremente_last_number ( gint payment_number,
823 gint increment )
824 {
825 const gchar *last_number;
826 gchar *new_number;
827
828 last_number = gsb_data_payment_get_last_number ( payment_number );
829 new_number = utils_str_incremente_number_from_str ( last_number, increment );
830
831 return new_number;
832 }
833
834
835 /**
836 * return the last_number of the method of payment to int
837 * this is the last number to set automatically that number + 1
838 * in the cheque entry ; nothing to deal with gsb_data_payment_max_number
839 * which give the last payment_number, internal number to count the method of payment
840 *
841 * \param payment_number the number of the method of payment
842 *
843 * \return the int_last_number of the payment or -1 if fail
844 * */
gsb_data_payment_get_last_number_to_int(gint payment_number)845 gint gsb_data_payment_get_last_number_to_int ( gint payment_number )
846 {
847 struct_payment *payment;
848
849 payment = gsb_data_payment_get_structure ( payment_number );
850
851 if (!payment)
852 return -1;
853
854 return utils_str_atoi ( payment -> last_number );
855 }
856
857
858 /**
859 * set the last_number of the method of payment from an int
860 *
861 * \param payment_number the number of the method of payment
862 * \param last_number the last_number of the method of payment
863 *
864 * \return TRUE if ok or FALSE if problem
865 * */
gsb_data_payment_set_last_number_from_int(gint payment_number,gint last_number)866 gboolean gsb_data_payment_set_last_number_from_int ( gint payment_number,
867 gint last_number )
868 {
869 struct_payment *payment;
870 const gchar *old_number = NULL;
871 gchar *new_number;
872 gchar *prefix = NULL;
873 gint i = 0;
874
875 payment = gsb_data_payment_get_structure ( payment_number );
876
877 if ( !payment )
878 return FALSE;
879
880 old_number = gsb_data_payment_get_last_number ( payment_number );
881 if ( old_number )
882 {
883 while ( old_number[i] == '0' )
884 {
885 i++;
886 }
887 if ( i > 0 )
888 prefix = g_strndup ( old_number, i );
889 }
890
891 new_number = utils_str_itoa ( last_number );
892 if ( prefix && strlen ( prefix ) )
893 new_number = g_strconcat ( prefix, new_number, NULL );
894
895 payment -> last_number = new_number;
896
897 return TRUE;
898 }
899
900
901 /**
902 * permet de trouver pour un autre compte le moyen de paiement
903 * ayant le même nom.
904 *
905 * \param number initial
906 * \ numéro du nouveau compte
907 *
908 * \ return the numéro de paiement si trouvé ou celui par défaut pour
909 * le compte concerné.
910 * */
gsb_data_payment_search_number_other_account_by_name(gint payment_number,gint account_number)911 gint gsb_data_payment_search_number_other_account_by_name ( gint payment_number,
912 gint account_number )
913 {
914
915 const gchar *name;
916 GSList *tmp_list;
917 gint new_payment_number;
918 gint sign;
919
920 name = gsb_data_payment_get_name ( payment_number );
921
922 tmp_list = payment_list;
923
924 while ( tmp_list )
925 {
926 struct_payment *payment;
927
928 payment = tmp_list -> data;
929
930 if ( payment -> account_number == account_number )
931 {
932 if ( my_strcasecmp ( (gchar *)name, payment -> payment_name ) == 0 )
933 return payment -> payment_number;
934 }
935 tmp_list = tmp_list -> next;
936 }
937
938 sign = gsb_data_payment_get_sign ( payment_number );
939
940 if ( sign == GSB_PAYMENT_CREDIT)
941 new_payment_number = gsb_data_account_get_default_credit ( account_number );
942 else
943 new_payment_number = gsb_data_account_get_default_debit ( account_number );
944
945 return new_payment_number;
946 }
947
948
949 /**
950 * This function looks for a method of payment which matches signe_type' and returns its number.
951 *
952 * \param account_number The account to process.
953 * \param signe_type A payment method sign to match against payment
954 * methods of specified account.
955 * (GSB_PAYMENT_NEUTRAL, GSB_PAYMENT_DEBIT, GSB_PAYMENT_CREDIT)
956 * \param exclude A payment method that should not be checked,
957 * as it may be the one which is to be removed.
958 *
959 * \return The matching payment method number on success,
960 * 0 otherwise (for transfer).
961 **/
gsb_data_payment_get_other_number_from_sign(gint account_number,gint signe_type,gint exclude_number)962 gint gsb_data_payment_get_other_number_from_sign (gint account_number,
963 gint signe_type,
964 gint exclude_number)
965 {
966 GSList *tmp_list;
967
968 tmp_list = gsb_data_payment_get_payments_list ();
969 while (tmp_list)
970 {
971 gint payment_number;
972
973 payment_number = gsb_data_payment_get_number (tmp_list -> data);
974
975 if (gsb_data_payment_get_account_number (payment_number) == account_number
976 && payment_number != exclude_number
977 && gsb_data_payment_get_sign (payment_number) == signe_type)
978 {
979 return payment_number;
980 }
981
982 tmp_list = tmp_list -> next;
983 };
984
985 /* Defaults to first method_ptr, whatever it may be */
986 return 0;
987 }
988
989 /**
990 *
991 *
992 * \param
993 * \param
994 * \param
995 *
996 * \return
997 **/
gsb_data_payment_change_default_payment_method(gint payment_number,gint account_number)998 void gsb_data_payment_change_default_payment_method (gint payment_number,
999 gint account_number)
1000 {
1001 switch (gsb_data_payment_get_sign (payment_number))
1002 {
1003 case GSB_PAYMENT_DEBIT:
1004 if ( gsb_data_account_get_default_debit (account_number) == payment_number)
1005 {
1006 gsb_data_account_set_default_debit (account_number,
1007 gsb_data_payment_get_other_number_from_sign
1008 (account_number, GSB_PAYMENT_DEBIT, payment_number));
1009 }
1010 break;
1011
1012 case GSB_PAYMENT_CREDIT:
1013 if ( gsb_data_account_get_default_credit (account_number) == payment_number)
1014 {
1015 gsb_data_account_set_default_credit (account_number,
1016 gsb_data_payment_get_other_number_from_sign
1017 (account_number, GSB_PAYMENT_CREDIT, payment_number));
1018 }
1019 break;
1020 }
1021 }
1022
1023 /**
1024 *
1025 *
1026 * \param
1027 *
1028 * \return
1029 **/
1030 /* Local Variables: */
1031 /* c-basic-offset: 4 */
1032 /* End: */
1033