1 /* ************************************************************************** */
2 /* */
3 /* Copyright (C) 2000-2008 Cédric Auger (cedric@grisbi.org) */
4 /* 2003-2008 Benjamin Drieu (bdrieu@april.org) */
5 /* 2008-2018 Pierre Biava (grisbi@pierre.biava.name) */
6 /* https://www.grisbi.org/ */
7 /* */
8 /* This program is free software; you can redistribute it and/or modify */
9 /* it under the terms of the GNU General Public License as published by */
10 /* the Free Software Foundation; either version 2 of the License, or */
11 /* (at your option) any later version. */
12 /* */
13 /* This program is distributed in the hope that it will be useful, */
14 /* but WITHOUT ANY WARRANTY; without even the implied warranty of */
15 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
16 /* GNU General Public License for more details. */
17 /* */
18 /* You should have received a copy of the GNU General Public License */
19 /* along with this program; if not, write to the Free Software */
20 /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
21 /* */
22 /* ************************************************************************** */
23
24 /**
25 * \file gsb_data_account.c
26 * work with the account structure, no GUI here
27 */
28
29
30 #ifdef HAVE_CONFIG_H
31 #include "config.h"
32 #endif
33
34 #include "include.h"
35 #include <glib/gi18n.h>
36
37 /*START_INCLUDE*/
38 #include "gsb_data_account.h"
39 #include "bet_data.h"
40 #include "custom_list.h"
41 #include "dialog.h"
42 #include "grisbi_app.h"
43 #include "gsb_data_currency.h"
44 #include "gsb_data_form.h"
45 #include "gsb_data_import_rule.h"
46 #include "gsb_data_partial_balance.h"
47 #include "gsb_data_payment.h"
48 #include "gsb_data_report.h"
49 #include "gsb_data_reconcile.h"
50 #include "gsb_data_scheduled.h"
51 #include "gsb_data_transaction.h"
52 #include "gsb_dirs.h"
53 #include "gsb_file.h"
54 #include "gsb_select_icon.h"
55 #include "gsb_transactions_list.h"
56 #include "navigation.h"
57 #include "structures.h"
58 #include "traitement_variables.h"
59 #include "utils.h"
60 #include "utils_dates.h"
61 #include "utils_real.h"
62 #include "utils_str.h"
63 #include "erreur.h"
64 /*END_INCLUDE*/
65
66 typedef struct _AccountStruct AccountStruct; /* struct_account describe an account */
67
68 struct _AccountStruct {
69 /** @name general stuff */
70 gint account_number;
71 gchar *account_id; /**< for ofx import, invisible for the user */
72 KindAccount account_kind;
73 gchar *account_name;
74 gint currency;
75 gint closed_account; /**< if 1 => closed */
76 gchar *comment;
77 gchar *holder_name;
78 gchar *holder_address;
79 gboolean has_pointed; /* TRUE if one transaction is pointed */
80
81 /** @name account_icon */
82 gchar *name_icon; /* path for not standard icon */
83 GdkPixbuf *pixbuf; /* pixbuf for the account */
84
85 /** @name method of payment */
86 gint default_debit;
87 gint default_credit;
88
89 /** @name showed list stuff */
90 gint show_r; /**< 1 : reconciled transactions are showed */
91 gint nb_rows_by_transaction; /**< 1, 2, 3, 4 */
92 gint show_l; /** 1 archived lines are showed */
93
94 /** @name remaining of the balances */
95 GsbReal init_balance;
96 GsbReal mini_balance_wanted;
97 GsbReal mini_balance_authorized;
98 gboolean balances_are_dirty;
99 GsbReal current_balance;
100 GsbReal marked_balance;
101
102 /** @name remaining of the minimun balance message */
103 gint mini_balance_wanted_message;
104 gint mini_balance_authorized_message;
105
106 /** @name number of the transaction selectionned, or -1 for the white line */
107 gint current_transaction_number;
108
109 /** @name bank stuff */
110 gint bank_number;
111 gchar *bank_branch_code;
112 gchar *bank_account_number;
113 gchar *bank_account_key;
114 gchar *bank_account_iban;
115
116 /** @name reconcile sort */
117 gint reconcile_sort_type; /**< 1 : sort by method of payment ; 0 : let the user sort by himself */
118 GSList *sort_list; /**< the method of payment numbers sorted in a list
119 (if split neutral, the negative method has a negative method of payment number)*/
120 gint split_neutral_payment; /**< if 1 : neutral payments are splitted into debits/credits */
121
122 /** @name tree_view sort stuff */
123 gint sort_type; /**< GTK_SORT_DESCENDING / GTK_SORT_ASCENDING */
124 gint sort_column; /**< used to hide the arrow when change the column */
125 gint column_element_sort[CUSTOM_MODEL_VISIBLE_COLUMNS]; /**< contains for each column the element number used to sort the list */
126
127 /** @name current graphic position in the list (the row_align used with gtk_tree_view_scroll_to_cell) */
128 gfloat row_align;
129
130 /** @name bet data */
131 gint bet_use_budget; /* -1 = pas de module possible 0 = non utilisé 1 = utilisé */
132 gint bet_credit_card; /* 1 = compte type CB à débit différé */
133 BetTypeOnglets bet_show_onglets; /* enum des onglets à afficher pour le module budgetaire */
134 GDate *bet_start_date; /* date de début */
135 gint bet_months; /* nombre de mois ou d'années */
136 gint bet_spin_range; /* echelle de la période 0 = mois 1 = années */
137 gint bet_auto_inc_month; /* incrémente automatiquement le mois */
138 gint bet_select_transaction_label; /* fixe le label pour les opérations */
139 gint bet_select_scheduled_label; /* fixe le label pour les opérations planifiées */
140 gint bet_select_futur_label; /* fixe le label pour les données futures */
141 gint bet_hist_data; /* origine des données 0 = catégories 1 = IB */
142 gint bet_hist_fyear; /* numéro d'exercice */
143 gint bet_maj; /* MAJ du module estiamte balance */
144 gdouble bet_capital; /* capital emprunté */
145 gdouble bet_taux_annuel; /* taux d'interet annuel */
146 gdouble bet_frais; /* frais par echeance */
147 gint bet_type_taux; /* type de taux : actuariel ou proportionnel */
148 gboolean bet_init_sch_with_loan; /* Initialise l'opération planifiée avec le tableau d'amortissement */
149 gboolean bet_split_transaction; /* crée une opération ventilée dans le compte principal */
150 };
151
152
153 /*START_STATIC*/
154 static void _gsb_data_account_free ( AccountStruct* account );
155 static void gsb_data_account_delete_all_accounts (void);
156 static gchar *gsb_data_account_get_account_standard_pixbuf_filename ( KindAccount account_kind );
157 static AccountStruct *gsb_data_account_get_structure ( gint no );
158 static gint gsb_data_account_max_number ( void );
159 static gboolean gsb_data_account_set_default_sort_values ( gint account_number );
160 static gboolean gsb_data_account_dup_sort_values ( gint origin_account,
161 gint target_account );
162 /*END_STATIC*/
163
164 /*START_EXTERN*/
165 /*END_EXTERN*/
166
167 /** contains a g_slist of struct_account in the good order */
168 static GSList *list_accounts = NULL;
169
170 /** a pointer to the last account used (to increase the speed) */
171 static AccountStruct *account_buffer;
172
173 /******************************************************************************/
174 /* Private functions */
175 /******************************************************************************/
176 /**
177 *
178 *
179 * \param
180 *
181 * \return
182 **/
gsb_data_account_cmp_numbers(gconstpointer a,gconstpointer b)183 static gint gsb_data_account_cmp_numbers (gconstpointer a,
184 gconstpointer b)
185 {
186 gint a_num;
187 gint b_num;
188
189 if (a == NULL)
190 return -1;
191 if (b == NULL)
192 return 1;
193
194 a_num = GPOINTER_TO_INT (a);
195 b_num = GPOINTER_TO_INT (b);
196
197 if (a_num < b_num)
198 return -1;
199 else if (a_num == b_num)
200 return 0;
201 else
202 return 1;
203 }
204
205 /**
206 * This function close all opened accounts and free the memory
207 * used by them.
208 */
gsb_data_account_delete_all_accounts(void)209 void gsb_data_account_delete_all_accounts (void)
210 {
211 if ( list_accounts )
212 {
213 g_slist_free_full ( list_accounts, (GDestroyNotify) _gsb_data_account_free );
214 list_accounts = NULL;
215 }
216
217 account_buffer = NULL;
218 }
219
220 /**
221 * set the accounts global variables to NULL, usually when we init all the global variables
222 *
223 * \param none
224 *
225 * \return FALSE
226 * */
gsb_data_account_init_variables(void)227 gboolean gsb_data_account_init_variables ( void )
228 {
229 gsb_data_account_delete_all_accounts ();
230
231 return FALSE;
232 }
233
234 /**
235 * return a pointer on the g_slist of accounts
236 * carrefull : it's not a copy, so we must not free or change it
237 * if we want to change the list, use gsb_data_account_get_copy_list_accounts instead
238 *
239 * \param none
240 * \return a g_slist on the accounts
241 * */
gsb_data_account_get_list_accounts(void)242 GSList *gsb_data_account_get_list_accounts ( void )
243 {
244 return list_accounts;
245 }
246
247
248 /**
249 * create a new account and add to the list of accounts
250 *
251 * \param account_type the type of the account
252 *
253 * \return no of account, -1 if problem
254 * */
gsb_data_account_new(KindAccount account_kind)255 gint gsb_data_account_new ( KindAccount account_kind )
256 {
257 AccountStruct *account;
258 gint last_number;
259
260 account = g_malloc0 (sizeof ( AccountStruct ));
261
262 if ( !account )
263 {
264 dialogue_error_memory ();
265 return -1;
266 }
267
268 last_number = gsb_data_account_max_number ();
269 /* we have to append the account first because some functions later will
270 * look for that account */
271 list_accounts = g_slist_append ( list_accounts, account );
272
273 /* set the base */
274 account -> account_number = last_number + 1;
275 account -> account_name = g_strdup_printf ( _("No name %d"),
276 account -> account_number );
277 account -> currency = gsb_data_currency_get_default_currency ();
278
279 /* set the kind of account */
280 account -> account_kind = account_kind;
281
282 /* select the white line */
283 account -> current_transaction_number = -1;
284
285 /* if it's the first account, we set default conf (R not displayed and 3 lines per transaction) */
286 /* else we keep the conf of the last account */
287 /* same for the form organization
288 * same for sorting the transactions list */
289
290 if ( account -> account_number == 1 )
291 {
292 account -> nb_rows_by_transaction = 3;
293
294 /* sort the transactions by default */
295 gsb_data_account_set_default_sort_values (account -> account_number);
296 }
297 else
298 {
299 account -> show_r = gsb_data_account_get_r (last_number);
300 account -> nb_rows_by_transaction = gsb_data_account_get_nb_rows (last_number);
301
302 /* try to copy the sort values of the last account, else set default values */
303 if ( !gsb_data_account_dup_sort_values ( last_number,
304 account -> account_number ))
305 gsb_data_account_set_default_sort_values (account -> account_number);
306 }
307
308 return account -> account_number;
309 }
310
311 /**
312 * This internal function is called to free the memory used by a struct_account structure
313 */
_gsb_data_account_free(AccountStruct * account)314 static void _gsb_data_account_free ( AccountStruct* account )
315 {
316 if ( ! account )
317 return;
318 g_free ( account -> account_id );
319 g_free ( account -> account_name );
320 g_free ( account -> name_icon );
321 g_free ( account -> comment );
322 g_free ( account -> holder_name );
323 g_free ( account -> holder_address );
324 g_free ( account -> bank_branch_code );
325 g_free ( account -> bank_account_number );
326 g_free ( account -> bank_account_key );
327 g_free ( account -> bank_account_iban );
328 if ( account -> sort_list )
329 g_slist_free( account -> sort_list ) ;
330 if ( account -> bet_start_date )
331 g_date_free ( account -> bet_start_date );
332 if ( account -> pixbuf )
333 g_object_unref ( account -> pixbuf );
334 g_free ( account );
335 if ( account_buffer == account )
336 account_buffer = NULL;
337 }
338
339
340 /**
341 * delete and free the account given
342 *
343 * \param account_number the no of account
344 *
345 * \return TRUE if ok
346 * */
gsb_data_account_delete(gint account_number)347 gboolean gsb_data_account_delete ( gint account_number )
348 {
349 AccountStruct *account;
350
351 account = gsb_data_account_get_structure ( account_number );
352
353 if ( !account )
354 return FALSE;
355
356 list_accounts = g_slist_remove ( list_accounts, account );
357
358 _gsb_data_account_free ( account );
359
360 return TRUE;
361 }
362
363
364
365 /**
366 * return the amount of accounts
367 *
368 * \param none
369 *
370 * \return amount of accounts
371 * */
gsb_data_account_get_accounts_amount(void)372 gint gsb_data_account_get_accounts_amount ( void )
373 {
374 if ( !list_accounts )
375 return 0;
376
377 return g_slist_length ( list_accounts );
378 }
379
380
381
382 /**
383 * find and return the last number of account
384 *
385 * \param none
386 *
387 * \return last number of account
388 * */
gsb_data_account_max_number(void)389 gint gsb_data_account_max_number ( void )
390 {
391 GSList *tmp;
392 gint number_tmp = 0;
393
394 tmp = list_accounts;
395
396 while ( tmp )
397 {
398 AccountStruct *account;
399
400 account = tmp -> data;
401
402 /* Bulletproof, baby */
403 if ( ! account )
404 {
405 return 0;
406 }
407
408 if ( account -> account_number > number_tmp )
409 number_tmp = account -> account_number;
410
411 tmp = tmp -> next;
412 }
413 return number_tmp;
414 }
415
416
417 /**
418 * find and return the first number of account
419 *
420 * \param none
421 *
422 * \return first number of account, -1 if no accounts
423 * */
gsb_data_account_first_number(void)424 gint gsb_data_account_first_number ( void )
425 {
426 AccountStruct *account;
427
428 if ( !list_accounts )
429 return -1;
430
431 account = list_accounts -> data;
432
433 return account -> account_number;
434 }
435
436
437 /**
438 * ind and return the first no closed account
439 *
440 * \param none
441 *
442 * \return first number of account, -1 if no accounts
443 * */
gsb_data_account_first_no_closed_account(void)444 gint gsb_data_account_first_no_closed_account ( void )
445 {
446 AccountStruct *account = NULL;
447 GSList *list_tmp;
448
449 if ( !list_accounts )
450 return -1;
451
452 list_tmp = list_accounts;
453
454 while ( list_tmp )
455 {
456 account = list_tmp -> data;
457
458 if ( account -> closed_account == 0 )
459 break;
460
461 list_tmp = list_tmp -> next;
462 }
463
464 return account -> account_number;
465 }
466
467
468 /**
469 * find and return the number of the account which the struct is the param
470 *
471 * \param the struct of the account
472 *
473 * \return the number of account, -1 if pb
474 * */
gsb_data_account_get_no_account(gpointer account_ptr)475 gint gsb_data_account_get_no_account ( gpointer account_ptr )
476 {
477 AccountStruct *account;
478
479 if ( !account_ptr )
480 return -1;
481
482 account = account_ptr;
483 account_buffer = account;
484
485 return account -> account_number;
486 }
487
488
489 /**
490 * change the number of the account given in param
491 * it returns the new number (given in param also)
492 * it is called ONLY when loading a file to change the default
493 * number, given when we create the account
494 *
495 * \param account_number no of the account to change
496 * \param new_no new number to the account
497 *
498 * \return the new number, or -1 if failed
499 * */
gsb_data_account_set_account_number(gint account_number,gint new_no)500 gint gsb_data_account_set_account_number ( gint account_number,
501 gint new_no )
502 {
503 AccountStruct *account;
504
505 account = gsb_data_account_get_structure ( account_number );
506
507 if ( !account )
508 return -1;
509
510 account -> account_number = new_no;
511
512 return new_no;
513 }
514
515
516
517
518 /**
519 * find and return the structure of the account asked
520 *
521 * \param no number of account
522 *
523 * \return the adr of the struct of the account (NULL if doesn't exit)
524 * */
gsb_data_account_get_structure(gint no)525 AccountStruct *gsb_data_account_get_structure ( gint no )
526 {
527 GSList *tmp;
528
529 if ( no < 0 )
530 {
531 return NULL;
532 }
533
534 /* before checking all the accounts, we check the buffer */
535
536 if ( account_buffer
537 &&
538 account_buffer -> account_number == no )
539 return account_buffer;
540
541 tmp = list_accounts;
542
543 while ( tmp )
544 {
545 AccountStruct *account;
546
547 account = tmp -> data;
548
549 if ( account && account -> account_number == no )
550 {
551 account_buffer = account;
552 return account;
553 }
554
555 tmp = tmp -> next;
556 }
557 return NULL;
558 }
559
560
561
562 /**
563 * get the nb of rows displayed on the account given
564 *
565 * \param account_number no of the account
566 *
567 * \return nb of rows displayed (1, 2, 3 or 4), or 0 if the account doesn't exist
568 * */
gsb_data_account_get_nb_rows(gint account_number)569 gint gsb_data_account_get_nb_rows ( gint account_number )
570 {
571 AccountStruct *account;
572
573 account = gsb_data_account_get_structure ( account_number );
574
575 if ( !account )
576 return 0;
577
578 return account -> nb_rows_by_transaction;
579 }
580
581
582 /** set the nb of rows displayed in the account given
583 * \param account_number no of the account
584 * \param nb_rows number of rows per transaction (1, 2, 3 or 4)
585 * \return TRUE, ok ; FALSE, problem
586 * */
gsb_data_account_set_nb_rows(gint account_number,gint nb_rows)587 gboolean gsb_data_account_set_nb_rows ( gint account_number,
588 gint nb_rows )
589 {
590 AccountStruct *account;
591
592 if ( nb_rows < 1
593 ||
594 nb_rows > 4 )
595 {
596 devel_debug ( g_strdup_printf ( _("Bad nb rows to gsb_data_account_set_nb_rows in gsb_data_account.c: %d\n"),
597 nb_rows ) );
598 return FALSE;
599 }
600
601 account = gsb_data_account_get_structure ( account_number );
602
603 if ( !account )
604 return FALSE;
605
606 account -> nb_rows_by_transaction = nb_rows;
607
608 return TRUE;
609 }
610
611
612 /**
613 * return if archives Lines are displayed in the account asked
614 *
615 * \param account_number no of the account
616 *
617 * \return boolean show/not show L
618 * */
gsb_data_account_get_l(gint account_number)619 gboolean gsb_data_account_get_l ( gint account_number )
620 {
621 AccountStruct *account;
622
623 account = gsb_data_account_get_structure ( account_number );
624
625 if ( !account )
626 return 0;
627
628 return account -> show_l;
629 }
630
631 /**
632 * set if archives lines are displayed in the account asked
633 *
634 * \param account_number no of the account
635 * \param show_l boolean
636 *
637 * \return TRUE, ok ; FALSE, problem
638 * */
gsb_data_account_set_l(gint account_number,gboolean show_l)639 gboolean gsb_data_account_set_l ( gint account_number,
640 gboolean show_l )
641 {
642 AccountStruct *account;
643
644 account = gsb_data_account_get_structure ( account_number );
645
646 if ( !account )
647 return FALSE;
648
649 account -> show_l = show_l;
650 return TRUE;
651 }
652
653
654 /**
655 * return if R are displayed in the account asked
656 *
657 * \param account_number no of the account
658 *
659 * \return boolean show/not show R
660 * */
gsb_data_account_get_r(gint account_number)661 gboolean gsb_data_account_get_r ( gint account_number )
662 {
663 AccountStruct *account;
664
665 account = gsb_data_account_get_structure ( account_number );
666
667 if ( !account )
668 return 0;
669
670 return account -> show_r;
671 }
672
673 /**
674 * set if R are displayed in the account asked
675 *
676 * \param account_number no of the account
677 * \param show_r boolean
678 *
679 * \return TRUE, ok ; FALSE, problem
680 * */
gsb_data_account_set_r(gint account_number,gboolean show_r)681 gboolean gsb_data_account_set_r ( gint account_number,
682 gboolean show_r )
683 {
684 AccountStruct *account;
685
686 account = gsb_data_account_get_structure ( account_number );
687
688 if ( !account )
689 return FALSE;
690
691 account -> show_r = show_r;
692
693 return TRUE;
694 }
695
696
697 /** get the id of the account
698 * \param account_number no of the account
699 * \return id or 0 if the account doesn't exist
700 * */
gsb_data_account_get_id(gint account_number)701 gchar *gsb_data_account_get_id ( gint account_number )
702 {
703 AccountStruct *account;
704
705 account = gsb_data_account_get_structure ( account_number );
706
707 if ( !account )
708 return NULL;
709
710 return account -> account_id;
711 }
712
713
714 /**
715 * set the id of the account
716 * the id is copied in memory
717 *
718 * \param account_number no of the account
719 * \param id id to set
720 *
721 * \return TRUE, ok ; FALSE, problem
722 * */
gsb_data_account_set_id(gint account_number,const gchar * id)723 gboolean gsb_data_account_set_id ( gint account_number,
724 const gchar *id )
725 {
726 AccountStruct *account;
727
728 account = gsb_data_account_get_structure ( account_number );
729
730 if ( !account )
731 return FALSE;
732
733 if ( account -> account_id )
734 g_free ( account -> account_id );
735
736 account -> account_id = my_strdup (id);
737
738 return TRUE;
739 }
740
741
742 /**
743 * Test if account exist by id (// Modif Yoann )
744 * and return its number
745 *
746 * \param Account Id
747 *
748 * \return the account number or -1
749 */
gsb_data_account_get_account_by_id(const gchar * account_id)750 gint gsb_data_account_get_account_by_id ( const gchar *account_id )
751 {
752 GSList *list_tmp;
753
754 list_tmp = gsb_data_account_get_list_accounts ();
755 while ( list_tmp )
756 {
757 AccountStruct *account;
758
759 account = list_tmp -> data;
760
761 if ( account_id
762 && account -> account_number >= 0
763 && !account -> closed_account
764 && account -> account_id
765 && strlen ( account -> account_id ) > 0 )
766 {
767 if ( g_ascii_strcasecmp ( account_id, account -> account_id ) == 0 )
768 return account -> account_number;
769 }
770 list_tmp = list_tmp -> next;
771 }
772 return -1;
773 }
774
775
776
777 /** get the account kind of the account
778 * \param account_number no of the account
779 * \return account type or 0 if the account doesn't exist
780 * */
gsb_data_account_get_kind(gint account_number)781 KindAccount gsb_data_account_get_kind ( gint account_number )
782 {
783 AccountStruct *account;
784
785 account = gsb_data_account_get_structure ( account_number );
786
787 if ( !account )
788 return 0;
789
790 return account -> account_kind;
791 }
792
793
794 /** set the kind of the account
795 * \param account_number no of the account
796 * \param account_kind type to set
797 * \return TRUE, ok ; FALSE, problem
798 * */
gsb_data_account_set_kind(gint account_number,KindAccount account_kind)799 gboolean gsb_data_account_set_kind ( gint account_number,
800 KindAccount account_kind )
801 {
802 AccountStruct *account;
803
804 account = gsb_data_account_get_structure ( account_number );
805
806 if ( !account )
807 return FALSE;
808
809 account -> account_kind = account_kind;
810
811 return TRUE;
812 }
813
814
815
816 /** get the name of the account
817 * \param account_number no of the account
818 * \return name or NULL if the account doesn't exist
819 * */
gsb_data_account_get_name(gint account_number)820 gchar *gsb_data_account_get_name ( gint account_number )
821 {
822 AccountStruct *account;
823
824 account = gsb_data_account_get_structure ( account_number );
825
826 if ( !account )
827 return NULL;
828
829 return account -> account_name;
830 }
831
832
833 /**
834 * set the name of the account
835 * the name is copied in memory
836 *
837 * \param account_number no of the account
838 * \param name name to set
839 *
840 * \return TRUE, ok ; FALSE, problem
841 * */
gsb_data_account_set_name(gint account_number,const gchar * name)842 gboolean gsb_data_account_set_name ( gint account_number,
843 const gchar *name )
844 {
845 AccountStruct *account;
846
847 account = gsb_data_account_get_structure ( account_number );
848
849 if ( !account )
850 return FALSE;
851
852 g_free ( account -> account_name );
853
854 if (!name || !strlen (name))
855 account -> account_name = NULL;
856 else
857 account -> account_name = my_strdup (name);
858
859 return TRUE;
860 }
861
862
863 /**
864 * find and return the number of account which
865 * have the name given in param
866 *
867 * \param account_name
868 *
869 * \return the number of account or -1
870 * */
gsb_data_account_get_no_account_by_name(const gchar * account_name)871 gint gsb_data_account_get_no_account_by_name ( const gchar *account_name )
872 {
873 GSList *list_tmp;
874
875 if ( !account_name )
876 return -1;
877
878 list_tmp = list_accounts;
879
880 while ( list_tmp )
881 {
882 AccountStruct *account;
883
884 account = list_tmp -> data;
885 if ( !strcmp ( account -> account_name,
886 account_name ))
887 return account -> account_number;
888
889 list_tmp = list_tmp -> next;
890 }
891
892 return -1;
893 }
894
895
896
897 /**
898 * get the init balance of the account
899 *
900 * \param account_number no of the account
901 * \param floating_point give the number of digits after the separator we want, -1 for no limit
902 *
903 * \return balance or NULL if the account doesn't exist
904 * */
gsb_data_account_get_init_balance(gint account_number,gint floating_point)905 GsbReal gsb_data_account_get_init_balance ( gint account_number,
906 gint floating_point )
907 {
908 AccountStruct *account;
909
910 account = gsb_data_account_get_structure ( account_number );
911
912 if ( !account )
913 return null_real;
914
915 /* fix bug 2149 si le nombre est en erreur on renvoie error_real et non null_real */
916 if (account->init_balance.mantissa == G_MININT64)
917 return account -> init_balance;
918 else
919 return gsb_real_adjust_exponent (account->init_balance, floating_point);
920 }
921
922
923 /**
924 * set the init balance of the account
925 *
926 * \param account_number no of the account
927 * \param balance balance to set
928 *
929 * \return TRUE, ok ; FALSE, problem
930 * */
gsb_data_account_set_init_balance(gint account_number,GsbReal balance)931 gboolean gsb_data_account_set_init_balance ( gint account_number,
932 GsbReal balance )
933 {
934 AccountStruct *account;
935
936 account = gsb_data_account_get_structure ( account_number );
937
938 if ( !account )
939 return FALSE;
940
941 account -> init_balance = balance;
942 account -> balances_are_dirty = TRUE;
943
944 return TRUE;
945 }
946
947
948
949 /**
950 * get the minimum balance wanted of the account
951 *
952 * \param account_number no of the account
953 *
954 * \return balance or NULL if the account doesn't exist
955 * */
gsb_data_account_get_mini_balance_wanted(gint account_number)956 GsbReal gsb_data_account_get_mini_balance_wanted ( gint account_number )
957 {
958 AccountStruct *account;
959
960 account = gsb_data_account_get_structure ( account_number );
961
962 if ( !account )
963 return null_real;
964
965 return account -> mini_balance_wanted;
966 }
967
968
969 /**
970 * set the minimum balance wanted of the account
971 *
972 * \param account_number no of the account
973 * \param balance balance to set
974 *
975 * \return TRUE, ok ; FALSE, problem
976 * */
gsb_data_account_set_mini_balance_wanted(gint account_number,GsbReal balance)977 gboolean gsb_data_account_set_mini_balance_wanted ( gint account_number,
978 GsbReal balance )
979 {
980 AccountStruct *account;
981
982 account = gsb_data_account_get_structure ( account_number );
983
984 if ( !account )
985 return FALSE;
986
987 account -> mini_balance_wanted = balance;
988
989 return TRUE;
990 }
991
992 /**
993 * get the minimum balance authorized of the account
994 *
995 * \param account_number no of the account
996 *
997 * \return balance or 0 if the account doesn't exist
998 * */
gsb_data_account_get_mini_balance_authorized(gint account_number)999 GsbReal gsb_data_account_get_mini_balance_authorized ( gint account_number )
1000 {
1001 AccountStruct *account;
1002
1003 account = gsb_data_account_get_structure ( account_number );
1004
1005 if ( !account )
1006 return null_real;
1007
1008 return account -> mini_balance_authorized;
1009 }
1010
1011
1012 /**
1013 * set the minimum balance authorized of the account
1014 *
1015 * \param account_number no of the account
1016 * \param balance balance to set
1017 *
1018 * \return TRUE, ok ; FALSE, problem
1019 * */
gsb_data_account_set_mini_balance_authorized(gint account_number,GsbReal balance)1020 gboolean gsb_data_account_set_mini_balance_authorized ( gint account_number,
1021 GsbReal balance )
1022 {
1023 AccountStruct *account;
1024
1025 account = gsb_data_account_get_structure ( account_number );
1026
1027 if ( !account )
1028 return FALSE;
1029
1030 account -> mini_balance_authorized = balance;
1031
1032 return TRUE;
1033 }
1034
1035
1036 /**
1037 * flag the current and marked balance dirty to force recompute
1038 *
1039 * \param account_number no of the account
1040 *
1041 * \return TRUE, ok ; FALSE, problem
1042 * */
gsb_data_account_set_balances_are_dirty(gint account_number)1043 gboolean gsb_data_account_set_balances_are_dirty ( gint account_number )
1044 {
1045 AccountStruct *account;
1046
1047 account = gsb_data_account_get_structure ( account_number );
1048
1049 if ( !account )
1050 return FALSE;
1051
1052 account -> balances_are_dirty = TRUE;
1053
1054 return TRUE;
1055 }
1056
1057
1058
1059 /**
1060 * calculate and fill in the account the current and marked balance of that account
1061 * it's faster than calling gsb_data_account_privatecalculate_current_balance and
1062 * gsb_data_account_private_calculate_marked_balance because throw the list only one time
1063 * called especially to init that values
1064 * the value calculated will have the same exponent of the currency account
1065 *
1066 * \param account_number
1067 *
1068 * \return the current balance
1069 * */
gsb_data_account_calculate_current_and_marked_balances(gint account_number)1070 GsbReal gsb_data_account_calculate_current_and_marked_balances ( gint account_number )
1071 {
1072 AccountStruct *account;
1073 GDate *date_jour;
1074 GSList *tmp_list;
1075 GsbReal current_balance;
1076 GsbReal current_balance_later = null_real;
1077 GsbReal marked_balance;
1078 GsbReal marked_balance_later = null_real;
1079 gint floating_point;
1080 gboolean has_pointed = FALSE;
1081 GrisbiAppConf *a_conf;
1082
1083 /* devel_debug_int ( account_number ); */
1084 account = gsb_data_account_get_structure ( account_number );
1085
1086 if ( !account )
1087 return null_real;
1088
1089 floating_point = gsb_data_currency_get_floating_point (account -> currency);
1090
1091 /* fix bug 2149 si le nombre est en erreur on renvoie error_real et non null_real */
1092 if (account->init_balance.mantissa == G_MININT64)
1093 {
1094 account->current_balance = account->init_balance;
1095 account->marked_balance = account->init_balance;
1096
1097 return account->current_balance;
1098 }
1099 else
1100 {
1101 current_balance = gsb_real_adjust_exponent (account->init_balance, floating_point);
1102 marked_balance = gsb_real_adjust_exponent (account->init_balance, floating_point);
1103 }
1104
1105 date_jour = gdate_today ( );
1106
1107 a_conf = (GrisbiAppConf *) grisbi_app_get_a_conf ();
1108
1109 tmp_list = gsb_data_transaction_get_complete_transactions_list ();
1110 while (tmp_list)
1111 {
1112 gint transaction_number;
1113 gint res = 0;
1114
1115 transaction_number = gsb_data_transaction_get_transaction_number (tmp_list->data);
1116 /* on regarde si on tient compte ou pas des échéances pour les soldes */
1117 if ( a_conf->balances_with_scheduled )
1118 res = 0;
1119 else
1120 {
1121 const GDate *date;
1122
1123 date = gsb_data_transaction_get_value_date_or_date ( transaction_number );
1124 res = g_date_compare ( date_jour, date );
1125 }
1126
1127 if ( gsb_data_transaction_get_account_number (transaction_number) == account_number
1128 &&
1129 !gsb_data_transaction_get_mother_transaction_number (transaction_number)
1130 && res >= 0 )
1131 {
1132 gint marked_transaction;
1133 GsbReal adjusted_amout;
1134 GsbReal tmp_balance;
1135
1136 adjusted_amout = gsb_data_transaction_get_adjusted_amount (transaction_number, floating_point);
1137 tmp_balance = gsb_real_add ( current_balance, adjusted_amout );
1138 if( tmp_balance.mantissa != error_real.mantissa )
1139 {
1140 current_balance = tmp_balance;
1141 }
1142 else
1143 {
1144 current_balance_later = gsb_real_add ( current_balance_later, adjusted_amout);
1145 }
1146 marked_transaction = gsb_data_transaction_get_marked_transaction (transaction_number);
1147 if (marked_transaction)
1148 {
1149 tmp_balance = gsb_real_add ( marked_balance, adjusted_amout );
1150 if( tmp_balance.mantissa != error_real.mantissa )
1151 marked_balance = tmp_balance;
1152 else
1153 marked_balance_later = gsb_real_add ( marked_balance_later, adjusted_amout);
1154 if (marked_transaction == OPERATION_POINTEE)
1155 has_pointed = TRUE;
1156 }
1157 }
1158 tmp_list = tmp_list -> next;
1159 }
1160
1161 g_date_free ( date_jour );
1162 account -> current_balance = gsb_real_add ( current_balance, current_balance_later );
1163 account -> marked_balance = gsb_real_add ( marked_balance, marked_balance_later );
1164 account->has_pointed = has_pointed;
1165
1166 return account -> current_balance;
1167 }
1168
1169
1170 /**
1171 * get the current balance of the account
1172 *
1173 * \param account_number no of the account
1174 *
1175 * \return balance or 0 if the account doesn't exist
1176 * */
gsb_data_account_get_current_balance(gint account_number)1177 GsbReal gsb_data_account_get_current_balance ( gint account_number )
1178 {
1179 AccountStruct *account;
1180
1181 account = gsb_data_account_get_structure ( account_number );
1182
1183 if ( !account )
1184 return null_real;
1185
1186 if ( account -> balances_are_dirty )
1187 {
1188 gsb_data_account_calculate_current_and_marked_balances ( account_number );
1189 account -> balances_are_dirty = FALSE;
1190 }
1191 return account -> current_balance;
1192 }
1193
1194
1195 /**
1196 * get the marked balance of the account
1197 * this is the total of all marked transactions (R, P and T)
1198 *
1199 * \param account_number no of the account
1200 *
1201 * \return balance or 0 if the account doesn't exist
1202 * */
gsb_data_account_get_marked_balance(gint account_number)1203 GsbReal gsb_data_account_get_marked_balance ( gint account_number )
1204 {
1205 AccountStruct *account;
1206
1207 account = gsb_data_account_get_structure ( account_number );
1208
1209 if ( !account )
1210 return null_real;
1211
1212 if( account -> balances_are_dirty )
1213 {
1214 gsb_data_account_calculate_current_and_marked_balances( account_number );
1215 account -> balances_are_dirty = FALSE;
1216 }
1217 return account -> marked_balance;
1218 }
1219
1220
1221 /**
1222 * calculate the amount of the marked T and P transactions, don't take care of R transactions
1223 * the value calculated will have the same exponent of the currency account
1224 *
1225 * \param account_number
1226 *
1227 * \return the amount
1228 * */
gsb_data_account_calculate_waiting_marked_balance(gint account_number)1229 GsbReal gsb_data_account_calculate_waiting_marked_balance ( gint account_number )
1230 {
1231 AccountStruct *account;
1232 GSList *tmp_list;
1233 GsbReal marked_balance = null_real;
1234 gint floating_point;
1235
1236 account = gsb_data_account_get_structure ( account_number );
1237
1238 if ( !account )
1239 return null_real;
1240
1241 floating_point = gsb_data_currency_get_floating_point (account -> currency);
1242
1243 tmp_list = gsb_data_transaction_get_complete_transactions_list ();
1244
1245 while (tmp_list)
1246 {
1247 gint transaction_number;
1248
1249 transaction_number = gsb_data_transaction_get_transaction_number (tmp_list->data);
1250
1251 if ( gsb_data_transaction_get_account_number (transaction_number) == account_number
1252 &&
1253 !gsb_data_transaction_get_mother_transaction_number (transaction_number)
1254 &&
1255 ( gsb_data_transaction_get_marked_transaction (transaction_number) == OPERATION_POINTEE
1256 ||
1257 gsb_data_transaction_get_marked_transaction (transaction_number) == OPERATION_TELEPOINTEE))
1258 marked_balance = gsb_real_add ( marked_balance,
1259 gsb_data_transaction_get_adjusted_amount (transaction_number, floating_point));
1260 tmp_list = tmp_list -> next;
1261 }
1262 return marked_balance;
1263 }
1264
1265
1266 /**
1267 * get the element number used to sort the list in a column
1268 *
1269 * \param account_number no of the account
1270 * \param no_column no of the column
1271 *
1272 * \return the element_number used to sort or 0 if the account doesn't exist
1273 * */
gsb_data_account_get_element_sort(gint account_number,gint no_column)1274 gint gsb_data_account_get_element_sort ( gint account_number,
1275 gint no_column )
1276 {
1277 AccountStruct *account;
1278
1279 if ( no_column < 0
1280 ||
1281 no_column >= CUSTOM_MODEL_VISIBLE_COLUMNS )
1282 {
1283 gchar* tmpstr;
1284
1285 /* TODO dOm : the return value of g_strdup_printf was not used !
1286 I add the devel_debug to print it. Is it OK to do that ? */
1287 tmpstr = g_strdup_printf ( _("Bad no column to gsb_data_account_get_element_sort () "
1288 "in data_account.c\nno_column = %d\n" ),
1289 no_column );
1290 devel_debug (tmpstr);
1291 g_free(tmpstr);
1292
1293 return FALSE;
1294 }
1295
1296 account = gsb_data_account_get_structure ( account_number );
1297
1298 if ( !account )
1299 return 0;
1300
1301 return account -> column_element_sort[no_column];
1302 }
1303
1304
1305 /**
1306 * set the element number used to sort the column given in param
1307 *
1308 * \param account_number no of the account
1309 * \param no_column no of the column
1310 * \param element_number element number used to set
1311 *
1312 * \return TRUE, ok ; FALSE, problem
1313 * */
gsb_data_account_set_element_sort(gint account_number,gint no_column,gint element_number)1314 gboolean gsb_data_account_set_element_sort ( gint account_number,
1315 gint no_column,
1316 gint element_number )
1317 {
1318 AccountStruct *account;
1319
1320 if ( no_column < 0
1321 ||
1322 no_column >= CUSTOM_MODEL_VISIBLE_COLUMNS )
1323 {
1324 gchar* tmpstr;
1325
1326 /* TODO dOm : the value of g_strdup_printf was not used.
1327 I add the devel_debug function to print it. Is it OK ? */
1328 tmpstr = g_strdup_printf ( _("Bad no column to gsb_data_account_set_element_sort () "
1329 "in data_account.c\nno_column = %d\n" ),
1330 no_column );
1331 devel_debug ( tmpstr );
1332 g_free (tmpstr);
1333
1334 return FALSE;
1335 }
1336
1337 account = gsb_data_account_get_structure ( account_number );
1338 if (account == NULL)
1339 return FALSE;
1340
1341 account -> column_element_sort[no_column] = element_number;
1342
1343 return TRUE;
1344 }
1345
1346
1347
1348
1349 /**
1350 * get the number of the current transaction in the given account
1351 *
1352 * \param account_number
1353 *
1354 * \return the number of the transaction or 0 if problem
1355 * */
gsb_data_account_get_current_transaction_number(gint account_number)1356 gint gsb_data_account_get_current_transaction_number ( gint account_number )
1357 {
1358 AccountStruct *account;
1359
1360 account = gsb_data_account_get_structure ( account_number );
1361
1362 if ( !account )
1363 return 0;
1364
1365 return account -> current_transaction_number;
1366 }
1367
1368
1369
1370 /**
1371 * set the current transaction of the account
1372 *
1373 * \param account_number no of the account
1374 * \param transaction_number number of the transaction selection
1375 *
1376 * \return TRUE, ok ; FALSE, problem
1377 * */
gsb_data_account_set_current_transaction_number(gint account_number,gint transaction_number)1378 gboolean gsb_data_account_set_current_transaction_number ( gint account_number,
1379 gint transaction_number )
1380 {
1381 AccountStruct *account;
1382
1383 account = gsb_data_account_get_structure ( account_number );
1384
1385 if ( !account )
1386 return FALSE;
1387
1388 account -> current_transaction_number = transaction_number;
1389
1390 return TRUE;
1391 }
1392
1393
1394
1395 /**
1396 * get the value of mini_balance_wanted_message on the account given
1397 *
1398 * \param account_number no of the account
1399 *
1400 * \return mini_balance_wanted_message or 0 if the account doesn't exist
1401 * */
gsb_data_account_get_mini_balance_wanted_message(gint account_number)1402 gboolean gsb_data_account_get_mini_balance_wanted_message ( gint account_number )
1403 {
1404 AccountStruct *account;
1405
1406 account = gsb_data_account_get_structure ( account_number );
1407
1408 if ( !account )
1409 return 0;
1410
1411 return account -> mini_balance_wanted_message;
1412 }
1413
1414
1415 /**
1416 * set the value of mini_balance_wanted_message in the account given
1417 *
1418 * \param account_number no of the account
1419 * \param value
1420 *
1421 * \return TRUE, ok ; FALSE, problem
1422 * */
gsb_data_account_set_mini_balance_wanted_message(gint account_number,gboolean value)1423 gboolean gsb_data_account_set_mini_balance_wanted_message ( gint account_number,
1424 gboolean value )
1425 {
1426 AccountStruct *account;
1427
1428 account = gsb_data_account_get_structure ( account_number );
1429
1430 if ( !account )
1431 return FALSE;
1432
1433 account -> mini_balance_wanted_message = value;
1434
1435 return TRUE;
1436 }
1437
1438
1439 /** get the value of mini_balance_authorized_message on the account given
1440 * \param account_number no of the account
1441 * \return mini_balance_authorized_message or 0 if the account doesn't exist
1442 * */
gsb_data_account_get_mini_balance_authorized_message(gint account_number)1443 gboolean gsb_data_account_get_mini_balance_authorized_message ( gint account_number )
1444 {
1445 AccountStruct *account;
1446
1447 account = gsb_data_account_get_structure ( account_number );
1448
1449 if ( !account )
1450 return 0;
1451
1452 return account -> mini_balance_authorized_message;
1453 }
1454
1455
1456 /**
1457 * set the value of mini_balance_authorized_message in the account given
1458 *
1459 * \param account_number no of the account
1460 * \param value
1461 *
1462 * \return TRUE, ok ; FALSE, problem
1463 * */
gsb_data_account_set_mini_balance_authorized_message(gint account_number,gboolean value)1464 gboolean gsb_data_account_set_mini_balance_authorized_message ( gint account_number,
1465 gboolean value )
1466 {
1467 AccountStruct *account;
1468
1469 account = gsb_data_account_get_structure ( account_number );
1470
1471 if ( !account )
1472 return FALSE;
1473
1474 account -> mini_balance_authorized_message = value;
1475
1476 return TRUE;
1477 }
1478
1479
1480 /**
1481 * get the currency on the account given
1482 *
1483 * \param account_number no of the account
1484 *
1485 * \return currency or 0 if the account doesn't exist
1486 * */
gsb_data_account_get_currency(gint account_number)1487 gint gsb_data_account_get_currency ( gint account_number )
1488 {
1489 AccountStruct *account;
1490
1491 account = gsb_data_account_get_structure ( account_number );
1492
1493 if ( !account )
1494 return 0;
1495
1496 return account -> currency;
1497 }
1498
1499
1500 /** set the currency in the account given
1501 * \param account_number no of the account
1502 * \param currency the currency to set
1503 * \return TRUE, ok ; FALSE, problem
1504 * */
gsb_data_account_set_currency(gint account_number,gint currency)1505 gboolean gsb_data_account_set_currency ( gint account_number,
1506 gint currency )
1507 {
1508 AccountStruct *account;
1509
1510 account = gsb_data_account_get_structure ( account_number );
1511
1512 if ( !account )
1513 return FALSE;
1514
1515 account -> currency = currency;
1516
1517 return TRUE;
1518 }
1519
1520
1521 /** get the bank on the account given
1522 * \param account_number no of the account
1523 * \return last number of reconciliation or 0 if the account doesn't exist
1524 * */
gsb_data_account_get_bank(gint account_number)1525 gint gsb_data_account_get_bank ( gint account_number )
1526 {
1527 AccountStruct *account;
1528
1529 account = gsb_data_account_get_structure ( account_number );
1530
1531 if ( !account )
1532 return 0;
1533
1534 return account -> bank_number;
1535 }
1536
1537
1538 /** set the bank in the account given
1539 * \param account_number no of the account
1540 * \param bank the bank to set
1541 * \return TRUE, ok ; FALSE, problem
1542 * */
gsb_data_account_set_bank(gint account_number,gint bank)1543 gboolean gsb_data_account_set_bank ( gint account_number,
1544 gint bank )
1545 {
1546 AccountStruct *account;
1547
1548 account = gsb_data_account_get_structure ( account_number );
1549
1550 if ( !account )
1551 return FALSE;
1552
1553 account -> bank_number = bank;
1554
1555 return TRUE;
1556 }
1557
1558
1559 /** get the bank_branch_code of the account
1560 * \param account_number no of the account
1561 * \return id or NULL if the account doesn't exist
1562 * */
gsb_data_account_get_bank_branch_code(gint account_number)1563 gchar *gsb_data_account_get_bank_branch_code ( gint account_number )
1564 {
1565 AccountStruct *account;
1566
1567 account = gsb_data_account_get_structure ( account_number );
1568
1569 if ( !account )
1570 return NULL;
1571
1572 return account -> bank_branch_code;
1573 }
1574
1575
1576 /**
1577 * set the bank_branch_code of the account
1578 * the code is copied in memory
1579 *
1580 * \param account_number no of the account
1581 * \param bank_branch_code bank_branch_code to set
1582 *
1583 * \return TRUE, ok ; FALSE, problem
1584 * */
gsb_data_account_set_bank_branch_code(gint account_number,const gchar * bank_branch_code)1585 gboolean gsb_data_account_set_bank_branch_code ( gint account_number,
1586 const gchar *bank_branch_code )
1587 {
1588 AccountStruct *account;
1589
1590 account = gsb_data_account_get_structure ( account_number );
1591
1592 if ( !account )
1593 return FALSE;
1594
1595 g_free ( account -> bank_branch_code );
1596
1597 if (!bank_branch_code || !strlen (bank_branch_code))
1598 account -> bank_branch_code = NULL;
1599 else
1600 account -> bank_branch_code = my_strdup (bank_branch_code);
1601
1602 return TRUE;
1603 }
1604
1605
1606 /** get the bank_account_number of the account
1607 * \param account_number no of the account
1608 * \return id or NULL if the account doesn't exist
1609 * */
gsb_data_account_get_bank_account_number(gint account_number)1610 gchar *gsb_data_account_get_bank_account_number ( gint account_number )
1611 {
1612 AccountStruct *account;
1613
1614 account = gsb_data_account_get_structure ( account_number );
1615
1616 if ( !account )
1617 return NULL;
1618
1619 return account -> bank_account_number;
1620 }
1621
1622
1623 /**
1624 * set the bank_account_number of the account
1625 * the number is copied in memory
1626 *
1627 * \param account_number no of the account
1628 * \param bank_account_number bank_account_number to set
1629 *
1630 * \return TRUE, ok ; FALSE, problem
1631 * */
gsb_data_account_set_bank_account_number(gint account_number,const gchar * bank_account_number)1632 gboolean gsb_data_account_set_bank_account_number ( gint account_number,
1633 const gchar *bank_account_number )
1634 {
1635 AccountStruct *account;
1636
1637 account = gsb_data_account_get_structure ( account_number );
1638
1639 if ( !account )
1640 return FALSE;
1641
1642 if ( account -> bank_account_number )
1643 g_free ( account -> bank_account_number );
1644
1645 if (!bank_account_number || !strlen (bank_account_number))
1646 account -> bank_account_number = NULL;
1647 else
1648 account -> bank_account_number = my_strdup (bank_account_number);
1649
1650 return TRUE;
1651 }
1652
1653
1654
1655 /** get the bank_account_key of the account
1656 * \param account_number no of the account
1657 * \return id or NULL if the account doesn't exist
1658 * */
gsb_data_account_get_bank_account_key(gint account_number)1659 gchar *gsb_data_account_get_bank_account_key ( gint account_number )
1660 {
1661 AccountStruct *account;
1662
1663 account = gsb_data_account_get_structure ( account_number );
1664
1665 if ( !account )
1666 return NULL;
1667
1668 return account -> bank_account_key;
1669 }
1670
1671
1672 /**
1673 * set the bank_account_key of the account
1674 * the key is copied in memory
1675 *
1676 * \param account_number no of the account
1677 * \param bank_account_key bank_account_key to set
1678 *
1679 * \return TRUE, ok ; FALSE, problem
1680 * */
gsb_data_account_set_bank_account_key(gint account_number,const gchar * bank_account_key)1681 gboolean gsb_data_account_set_bank_account_key ( gint account_number,
1682 const gchar *bank_account_key )
1683 {
1684 AccountStruct *account;
1685
1686 account = gsb_data_account_get_structure ( account_number );
1687
1688 if ( !account )
1689 return FALSE;
1690
1691 if ( account -> bank_account_key )
1692 g_free ( account -> bank_account_key );
1693
1694 if (!bank_account_key || !strlen (bank_account_key))
1695 account -> bank_account_key = NULL;
1696 else
1697 account -> bank_account_key = my_strdup (bank_account_key);
1698
1699 return TRUE;
1700 }
1701
1702
1703 /** get closed_account on the account given
1704 * \param account_number no of the account
1705 * \return true if account is closed
1706 * */
gsb_data_account_get_closed_account(gint account_number)1707 gint gsb_data_account_get_closed_account ( gint account_number )
1708 {
1709 AccountStruct *account;
1710
1711 account = gsb_data_account_get_structure ( account_number );
1712
1713 if ( !account )
1714 return 0;
1715
1716 return account -> closed_account;
1717 }
1718
1719
1720 /** set closed_account in the account given
1721 * \param account_number no of the account
1722 * \param closed_account closed_account to set
1723 * \return TRUE, ok ; FALSE, problem
1724 * */
gsb_data_account_set_closed_account(gint account_number,gint closed_account)1725 gboolean gsb_data_account_set_closed_account ( gint account_number,
1726 gint closed_account )
1727 {
1728 AccountStruct *account;
1729
1730 account = gsb_data_account_get_structure ( account_number );
1731
1732 if ( !account )
1733 return FALSE;
1734
1735 account -> closed_account = closed_account;
1736
1737 return TRUE;
1738 }
1739
1740
1741 /** get the comment of the account
1742 * \param account_number no of the account
1743 * \return comment or NULL if the account doesn't exist
1744 * */
gsb_data_account_get_comment(gint account_number)1745 gchar *gsb_data_account_get_comment ( gint account_number )
1746 {
1747 AccountStruct *account;
1748
1749 account = gsb_data_account_get_structure ( account_number );
1750
1751 if ( !account )
1752 return NULL;
1753
1754 return account -> comment;
1755 }
1756
1757
1758 /**
1759 * set the comment of the account
1760 * the comment is copied in memory
1761 *
1762 * \param account_number no of the account
1763 * \param comment comment to set
1764 *
1765 * \return TRUE, ok ; FALSE, problem
1766 * */
gsb_data_account_set_comment(gint account_number,const gchar * comment)1767 gboolean gsb_data_account_set_comment ( gint account_number,
1768 const gchar *comment )
1769 {
1770 AccountStruct *account;
1771
1772 account = gsb_data_account_get_structure ( account_number );
1773
1774 if ( !account )
1775 return FALSE;
1776
1777 g_free ( account -> comment );
1778 account -> comment = my_strdup (comment);
1779
1780 return TRUE;
1781 }
1782
1783
1784
1785 /**
1786 * get reconcile_sort_type on the account given
1787 * 1 if the list should be sorted by method of payment, 0 if normal sort
1788 *
1789 * \param account_number no of the account
1790 *
1791 * \return 1 if the list should be sorted by method of payment, 0 if normal sort
1792 * */
gsb_data_account_get_reconcile_sort_type(gint account_number)1793 gint gsb_data_account_get_reconcile_sort_type ( gint account_number )
1794 {
1795 AccountStruct *account;
1796
1797 account = gsb_data_account_get_structure ( account_number );
1798
1799 if ( !account )
1800 return 0;
1801
1802 return account -> reconcile_sort_type;
1803 }
1804
1805
1806 /**
1807 * set reconcile_sort_type in the account given
1808 * 1 if the list should be sorted by method of payment, 0 if normal sort
1809 *
1810 * \param account_number no of the account
1811 * \param sort_type
1812 *
1813 * \return TRUE, ok ; FALSE, problem
1814 * */
gsb_data_account_set_reconcile_sort_type(gint account_number,gint sort_type)1815 gboolean gsb_data_account_set_reconcile_sort_type ( gint account_number,
1816 gint sort_type )
1817 {
1818 AccountStruct *account;
1819
1820 account = gsb_data_account_get_structure ( account_number );
1821
1822 if ( !account )
1823 return FALSE;
1824
1825 account -> reconcile_sort_type = sort_type;
1826
1827 return TRUE;
1828 }
1829
1830
1831 /**
1832 * get the sort_list of the account
1833 * this is a sorted list containing the numbers of the method of payment
1834 * used to sort the list while reconciling, according to the method of payments
1835 *
1836 * \param account_number no of the account
1837 *
1838 * \return the g_slist or NULL if the account doesn't exist
1839 * */
gsb_data_account_get_sort_list(gint account_number)1840 GSList *gsb_data_account_get_sort_list ( gint account_number )
1841 {
1842 AccountStruct *account;
1843
1844 account = gsb_data_account_get_structure ( account_number );
1845
1846 if ( !account )
1847 return NULL;
1848
1849 return account -> sort_list;
1850 }
1851
1852 /**
1853 * set the sort_list list of the account
1854 * this is a sorted list containing the numbers of the method of payment
1855 * used to sort the list while reconciling, according to the method of payments
1856 *
1857 * \param account_number no of the account
1858 * \param list g_slist to set
1859 *
1860 * \return TRUE, ok ; FALSE, problem
1861 * */
gsb_data_account_set_sort_list(gint account_number,GSList * list)1862 gboolean gsb_data_account_set_sort_list ( gint account_number,
1863 GSList *list )
1864 {
1865 AccountStruct *account;
1866
1867 account = gsb_data_account_get_structure ( account_number );
1868
1869 if ( !account )
1870 return FALSE;
1871
1872 account -> sort_list = list;
1873
1874 return TRUE;
1875 }
1876
1877
1878 /**
1879 * add a number of method of payment to the sort list of the account
1880 *
1881 * \param account_number
1882 * \param payment_number a gint which is the number of method of payment
1883 *
1884 * \return TRUE ok, FALSE problem
1885 * */
gsb_data_account_sort_list_add(gint account_number,gint payment_number)1886 gboolean gsb_data_account_sort_list_add ( gint account_number,
1887 gint payment_number )
1888 {
1889 AccountStruct *account;
1890
1891 account = gsb_data_account_get_structure ( account_number );
1892
1893 if ( !account )
1894 return FALSE;
1895
1896 account -> sort_list = g_slist_append ( account -> sort_list,
1897 GINT_TO_POINTER (payment_number));
1898
1899 return TRUE;
1900 }
1901
1902 /**
1903 * remove a number of method of payment to the sort list of the account
1904 *
1905 * \param account_number
1906 * \param payment_number a gint which is the number of method of payment
1907 *
1908 * \return TRUE ok, FALSE problem
1909 * */
gsb_data_account_sort_list_remove(gint account_number,gint payment_number)1910 gboolean gsb_data_account_sort_list_remove ( gint account_number,
1911 gint payment_number )
1912 {
1913 AccountStruct *account;
1914
1915 account = gsb_data_account_get_structure ( account_number );
1916
1917 if ( !account )
1918 return FALSE;
1919
1920 account -> sort_list = g_slist_remove ( account -> sort_list,
1921 GINT_TO_POINTER (payment_number));
1922
1923 return TRUE;
1924 }
1925
1926 /**
1927 * free the sort list of the account
1928 *
1929 * \param account_number
1930 *
1931 * \return TRUE ok, FALSE problem
1932 * */
gsb_data_account_sort_list_free(gint account_number)1933 gboolean gsb_data_account_sort_list_free ( gint account_number )
1934 {
1935 AccountStruct *account;
1936
1937 account = gsb_data_account_get_structure ( account_number );
1938
1939 if ( !account )
1940 return FALSE;
1941 if (!account -> sort_list)
1942 return TRUE;
1943
1944 g_slist_free (account -> sort_list);
1945 account -> sort_list = NULL;
1946 return TRUE;
1947 }
1948
1949
1950 /**
1951 * get split_neutral_payment on the account given
1952 *
1953 * \param account_number no of the account
1954 *
1955 * \return split_neutral_payment or 0 if the account doesn't exist
1956 * */
gsb_data_account_get_split_neutral_payment(gint account_number)1957 gint gsb_data_account_get_split_neutral_payment ( gint account_number )
1958 {
1959 AccountStruct *account;
1960
1961 account = gsb_data_account_get_structure ( account_number );
1962
1963 if ( !account )
1964 return 0;
1965
1966 return account -> split_neutral_payment;
1967 }
1968
1969
1970 /**
1971 * set split_neutral_payment in the account given
1972 *
1973 * \param account_number no of the account
1974 * \param split_neutral_payment split_neutral_payment to set
1975 *
1976 * \return TRUE, ok ; FALSE, problem
1977 * */
gsb_data_account_set_split_neutral_payment(gint account_number,gint split_neutral_payment)1978 gboolean gsb_data_account_set_split_neutral_payment ( gint account_number,
1979 gint split_neutral_payment )
1980 {
1981 AccountStruct *account;
1982
1983 account = gsb_data_account_get_structure ( account_number );
1984
1985 if ( !account )
1986 return FALSE;
1987
1988 account -> split_neutral_payment = split_neutral_payment;
1989
1990 return TRUE;
1991 }
1992
1993
1994 /**
1995 * get the holder_name of the account
1996 *
1997 * \param account_number no of the account
1998 *
1999 * \return holder_name or NULL if the account doesn't exist
2000 * */
gsb_data_account_get_holder_name(gint account_number)2001 gchar *gsb_data_account_get_holder_name ( gint account_number )
2002 {
2003 AccountStruct *account;
2004
2005 account = gsb_data_account_get_structure ( account_number );
2006
2007 if ( !account )
2008 return NULL;
2009
2010 return account -> holder_name;
2011 }
2012
2013
2014 /**
2015 * set the holder_name of the account
2016 * the name is copied in memory
2017 *
2018 * \param account_number no of the account
2019 * \param holder_name holder_name to set
2020 *
2021 * \return TRUE, ok ; FALSE, problem
2022 * */
gsb_data_account_set_holder_name(gint account_number,const gchar * holder_name)2023 gboolean gsb_data_account_set_holder_name ( gint account_number,
2024 const gchar *holder_name )
2025 {
2026 AccountStruct *account;
2027
2028 account = gsb_data_account_get_structure ( account_number );
2029
2030 if ( !account )
2031 return FALSE;
2032
2033 g_free ( account -> holder_name );
2034
2035 if (!holder_name || !strlen (holder_name))
2036 account -> holder_name = NULL;
2037 else
2038 account -> holder_name = my_strdup (holder_name);
2039
2040 return TRUE;
2041 }
2042
2043
2044 /** get the holder_address of the account
2045 * \param account_number no of the account
2046 * \return holder_address or NULL if the account doesn't exist
2047 * */
gsb_data_account_get_holder_address(gint account_number)2048 gchar *gsb_data_account_get_holder_address ( gint account_number )
2049 {
2050 AccountStruct *account;
2051
2052 account = gsb_data_account_get_structure ( account_number );
2053
2054 if ( !account )
2055 return NULL;
2056
2057 return account -> holder_address;
2058 }
2059
2060
2061 /**
2062 * set the holder_address of the account
2063 * the address is copied in memory
2064 *
2065 * \param account_number no of the account
2066 * \param holder_address holder_address to set
2067 *
2068 * \return TRUE, ok ; FALSE, problem
2069 * */
gsb_data_account_set_holder_address(gint account_number,const gchar * holder_address)2070 gboolean gsb_data_account_set_holder_address ( gint account_number,
2071 const gchar *holder_address )
2072 {
2073 AccountStruct *account;
2074
2075 account = gsb_data_account_get_structure ( account_number );
2076
2077 if ( !account )
2078 return FALSE;
2079
2080 g_free ( account -> holder_address );
2081
2082 if (!holder_address || !strlen (holder_address))
2083 account -> holder_address = NULL;
2084 else
2085 account -> holder_address = my_strdup (holder_address);
2086
2087 return TRUE;
2088 }
2089
2090
2091
2092 /**
2093 * get default_debit on the account given
2094 *
2095 * \param account_number no of the account
2096 *
2097 * \return default_debit or 0 if the account doesn't exist
2098 * */
gsb_data_account_get_default_debit(gint account_number)2099 gint gsb_data_account_get_default_debit ( gint account_number )
2100 {
2101 AccountStruct *account;
2102
2103 account = gsb_data_account_get_structure ( account_number );
2104
2105 if ( !account )
2106 return 0;
2107
2108 return account -> default_debit;
2109 }
2110
2111
2112 /**
2113 * set default_debit in the account given
2114 *
2115 * \param account_number no of the account
2116 * \param default_debit default_debit to set
2117 *
2118 * \return TRUE, ok ; FALSE, problem
2119 * */
gsb_data_account_set_default_debit(gint account_number,gint default_debit)2120 gboolean gsb_data_account_set_default_debit ( gint account_number,
2121 gint default_debit )
2122 {
2123 AccountStruct *account;
2124
2125 account = gsb_data_account_get_structure ( account_number );
2126
2127 if ( !account )
2128 return FALSE;
2129
2130 account -> default_debit = default_debit;
2131
2132 return TRUE;
2133 }
2134
2135
2136
2137 /**
2138 * get default_credit on the account given
2139 *
2140 * \param account_number no of the account
2141 *
2142 * \return default_credit or 0 if the account doesn't exist
2143 * */
gsb_data_account_get_default_credit(gint account_number)2144 gint gsb_data_account_get_default_credit ( gint account_number )
2145 {
2146 AccountStruct *account;
2147
2148 account = gsb_data_account_get_structure ( account_number );
2149
2150 if ( !account )
2151 return 0;
2152
2153 return account -> default_credit;
2154 }
2155
2156
2157 /**
2158 * set default_credit in the account given
2159 *
2160 * \param account_number no of the account
2161 * \param default_credit default_credit to set
2162 *
2163 * \return TRUE, ok ; FALSE, problem
2164 * */
gsb_data_account_set_default_credit(gint account_number,gint default_credit)2165 gboolean gsb_data_account_set_default_credit ( gint account_number,
2166 gint default_credit )
2167 {
2168 AccountStruct *account;
2169
2170 account = gsb_data_account_get_structure ( account_number );
2171
2172 if ( !account )
2173 return FALSE;
2174
2175 account -> default_credit = default_credit;
2176
2177 return TRUE;
2178 }
2179
2180
2181
2182 /**
2183 * get row_align on the account given
2184 *
2185 * \param account_number no of the account
2186 *
2187 * \return the row_align or 0
2188 * */
gsb_data_account_get_row_align(gint account_number)2189 gfloat gsb_data_account_get_row_align ( gint account_number )
2190 {
2191 AccountStruct *account;
2192
2193 account = gsb_data_account_get_structure ( account_number );
2194
2195 if ( !account )
2196 return 0.0;
2197
2198 return account -> row_align;
2199 }
2200
2201
2202 /**
2203 * set the row_align parameter for the account
2204 * use to place the list at the good place when changing account
2205 *
2206 * \param account_number no of the account
2207 * \param row_align the row_align to use with gtk_tree_view_scroll_to_cell
2208 *
2209 * \return TRUE, ok ; FALSE, problem
2210 * */
gsb_data_account_set_row_align(gint account_number,gfloat row_align)2211 gboolean gsb_data_account_set_row_align ( gint account_number,
2212 gfloat row_align )
2213 {
2214 AccountStruct *account;
2215
2216 account = gsb_data_account_get_structure ( account_number );
2217
2218 if ( !account )
2219 return FALSE;
2220
2221 account -> row_align = row_align;
2222 return TRUE;
2223 }
2224
2225
2226 /**
2227 * get sort_type on the account given
2228 * ie GTK_SORT_DESCENDING / GTK_SORT_ASCENDING
2229 *
2230 * \param account_number no of the account
2231 *
2232 * \return GTK_SORT_DESCENDING / GTK_SORT_ASCENDING
2233 * */
gsb_data_account_get_sort_type(gint account_number)2234 gint gsb_data_account_get_sort_type ( gint account_number )
2235 {
2236 AccountStruct *account;
2237
2238 account = gsb_data_account_get_structure ( account_number );
2239
2240 if ( !account )
2241 return 0;
2242
2243 return account -> sort_type;
2244 }
2245
2246
2247 /**
2248 * set sort_type in the account given
2249 * ie GTK_SORT_DESCENDING / GTK_SORT_ASCENDING
2250 *
2251 * \param account_number no of the account
2252 * \param sort_type sort_type to set (GTK_SORT_DESCENDING / GTK_SORT_ASCENDING)
2253 *
2254 * \return TRUE, ok ; FALSE, problem
2255 * */
gsb_data_account_set_sort_type(gint account_number,gint sort_type)2256 gboolean gsb_data_account_set_sort_type ( gint account_number,
2257 gint sort_type )
2258 {
2259 AccountStruct *account;
2260
2261 account = gsb_data_account_get_structure ( account_number );
2262
2263 if ( !account )
2264 return FALSE;
2265
2266 account -> sort_type = sort_type;
2267
2268 return TRUE;
2269 }
2270
2271
2272
2273
2274 /**
2275 * get sort_column on the account given
2276 *
2277 * \param account_number no of the account
2278 *
2279 * \return sort_column or 0 if the account doesn't exist
2280 * */
gsb_data_account_get_sort_column(gint account_number)2281 gint gsb_data_account_get_sort_column ( gint account_number )
2282 {
2283 AccountStruct *account;
2284
2285 account = gsb_data_account_get_structure ( account_number );
2286
2287 if ( !account )
2288 return 0;
2289
2290 return account -> sort_column;
2291 }
2292
2293
2294
2295 /**
2296 * set sort_column in the account given
2297 *
2298 * \param account_number no of the account
2299 * \param sort_column sort_column to set
2300 *
2301 * \return TRUE, ok ; FALSE, problem
2302 * */
gsb_data_account_set_sort_column(gint account_number,gint sort_column)2303 gboolean gsb_data_account_set_sort_column ( gint account_number,
2304 gint sort_column )
2305 {
2306 AccountStruct *account;
2307
2308 account = gsb_data_account_get_structure ( account_number );
2309
2310 if ( !account )
2311 return FALSE;
2312
2313 account -> sort_column = sort_column;
2314
2315 return TRUE;
2316 }
2317
2318
2319
2320 /**
2321 * set a new order in the list of accounts
2322 * all the accounts which are not in the new order are appened at the end of the new list
2323 * should be used only when loading a file before the 0.6 version
2324 *
2325 * \param new_order a g_slist which contains the number of accounts in the new order
2326 *
2327 * \return FALSE
2328 * */
gsb_data_account_reorder(GSList * new_order)2329 gboolean gsb_data_account_reorder ( GSList *new_order )
2330 {
2331 GSList *last_list, *new_list_accounts = NULL, *list_tmp;
2332
2333 while ( new_order )
2334 {
2335 new_list_accounts = g_slist_append ( new_list_accounts,
2336 gsb_data_account_get_structure ( GPOINTER_TO_INT (new_order -> data )));
2337 new_order = new_order -> next;
2338 }
2339
2340 last_list = list_accounts;
2341 list_accounts = new_list_accounts;
2342
2343 /* now we go to check if all accounts are in the list and
2344 * append the at the end */
2345 list_tmp = last_list;
2346
2347 while ( list_tmp )
2348 {
2349 AccountStruct *account = list_tmp -> data;
2350
2351 if ( ! g_slist_find ( list_accounts, account ) )
2352 {
2353 list_accounts = g_slist_append ( list_accounts, account );
2354 }
2355
2356 list_tmp = list_tmp -> next;
2357 }
2358
2359 g_slist_free (last_list);
2360
2361 gsb_file_set_modified ( TRUE );
2362
2363 return TRUE;
2364 }
2365
2366
2367 /**
2368 * check the position of the 2 accounts in the list and
2369 * return -1 if first account before second (and +1 else)
2370 *
2371 * \param account_number_1
2372 * \param account_number_2
2373 *
2374 * \return -1 if account_number_1 before, account_number_2, and +1 else, 0 if one of account doesn't exist
2375 * */
gsb_data_account_compare_position(gint account_number_1,gint account_number_2)2376 gint gsb_data_account_compare_position ( gint account_number_1,
2377 gint account_number_2 )
2378 {
2379 gint pos_1, pos_2;
2380 AccountStruct *account_1;
2381 AccountStruct *account_2;
2382
2383 account_1 = gsb_data_account_get_structure ( account_number_1 );
2384 account_2 = gsb_data_account_get_structure ( account_number_2 );
2385
2386 if (!account_1
2387 ||
2388 !account_2 )
2389 return 0;
2390
2391 pos_1 = g_slist_index (list_accounts, account_1);
2392 pos_2 = g_slist_index (list_accounts, account_2);
2393 if (pos_1 < pos_2)
2394 return -1;
2395 else
2396 return 1;
2397 }
2398
2399
2400 /**
2401 * change the position of an account in the list of accounts
2402 *
2403 * \param account_number the account we want to move
2404 * \param dest_account_number the account before we want to move, or -1 to set at the end of list
2405 *
2406 * \return FALSE
2407 * */
gsb_data_account_move_account(gint account_number,gint dest_account_number)2408 gboolean gsb_data_account_move_account ( gint account_number,
2409 gint dest_account_number )
2410 {
2411 AccountStruct *account;
2412
2413 account = gsb_data_account_get_structure ( account_number );
2414
2415 if ( !account )
2416 return FALSE;
2417
2418 /* first, remove the account from the list */
2419 list_accounts = g_slist_remove ( list_accounts,
2420 account );
2421
2422 if (dest_account_number != -1)
2423 {
2424 GSList *tmp_list;
2425
2426 tmp_list = list_accounts;
2427 while ( tmp_list )
2428 {
2429 AccountStruct *account_tmp;
2430
2431 account_tmp = tmp_list -> data;
2432
2433 if (account_tmp -> account_number == dest_account_number)
2434 {
2435 list_accounts = g_slist_insert_before ( list_accounts,
2436 tmp_list,
2437 account );
2438 return FALSE;
2439 }
2440 tmp_list = tmp_list -> next;
2441 }
2442 }
2443
2444 /* we move the account to the end */
2445 list_accounts = g_slist_append ( list_accounts,
2446 account );
2447
2448 return FALSE;
2449 }
2450
2451 /**
2452 * initalize the sort variables for an account to the default value
2453 * used normally only when creating a new account if it's the first one
2454 * in all others cases, we will take a copy of that values of the previous account
2455 *
2456 * \param account_number
2457 *
2458 * \return FALSE
2459 * */
gsb_data_account_set_default_sort_values(gint account_number)2460 gboolean gsb_data_account_set_default_sort_values ( gint account_number )
2461 {
2462 gint i, j;
2463 gint *ptr;
2464 AccountStruct *account;
2465
2466 account = gsb_data_account_get_structure ( account_number );
2467 ptr = gsb_transactions_list_get_tab_affichage_ope ();
2468
2469 if ( !account )
2470 return FALSE;
2471
2472 for ( i = 0 ; i<TRANSACTION_LIST_ROWS_NB ; i++ )
2473 for ( j = 0 ; j<CUSTOM_MODEL_VISIBLE_COLUMNS ; j++ )
2474 {
2475 gint element_number;
2476
2477 element_number = *(ptr + (i * CUSTOM_MODEL_VISIBLE_COLUMNS) + j);
2478 /* by default the sorting element will be the first found for each column */
2479 if (!account->column_element_sort[j] && element_number && element_number != ELEMENT_BALANCE)
2480 account -> column_element_sort[j] = element_number;
2481 }
2482
2483 /* the default sort is by date and ascending */
2484 account -> sort_type = GTK_SORT_ASCENDING;
2485 account -> sort_column = CUSTOM_MODEL_COL_1;
2486 return FALSE;
2487 }
2488
2489
2490 /**
2491 * copy the sort values from an account to another
2492 *
2493 * \param origin_account
2494 * \param target_account
2495 *
2496 * \return TRUE ok, FALSE problem
2497 * */
gsb_data_account_dup_sort_values(gint origin_account,gint target_account)2498 gboolean gsb_data_account_dup_sort_values ( gint origin_account,
2499 gint target_account )
2500 {
2501 gint j;
2502 AccountStruct *origin_account_ptr;
2503 AccountStruct *target_account_ptr;
2504
2505 origin_account_ptr = gsb_data_account_get_structure (origin_account);
2506 target_account_ptr = gsb_data_account_get_structure (target_account);
2507
2508 if (!origin_account_ptr
2509 ||
2510 !target_account_ptr)
2511 return FALSE;
2512
2513 for ( j = 0 ; j<CUSTOM_MODEL_VISIBLE_COLUMNS ; j++ )
2514 target_account_ptr -> column_element_sort[j] = origin_account_ptr -> column_element_sort[j];
2515
2516 target_account_ptr -> sort_type = origin_account_ptr -> sort_type;
2517 target_account_ptr -> sort_column = origin_account_ptr -> sort_column;
2518 return TRUE;
2519 }
2520
2521
2522 /**
2523 * get the icon_path of the account
2524 *
2525 * \param account_number no of the account
2526 *
2527 * \return icon_path or NULL if the account doesn't exist
2528 * */
gsb_data_account_get_name_icon(gint account_number)2529 gchar *gsb_data_account_get_name_icon (gint account_number)
2530 {
2531 AccountStruct *account;
2532
2533 account = gsb_data_account_get_structure ( account_number );
2534
2535 if ( !account )
2536 return NULL;
2537
2538 return account -> name_icon;
2539 }
2540
2541
2542 /**
2543 * set the icon_path of the account
2544 * the address is copied in memory
2545 *
2546 * \param account_number no of the account
2547 * \param filename name of file to set
2548 *
2549 * \return TRUE, ok ; FALSE, problem
2550 * */
gsb_data_account_set_name_icon(gint account_number,const gchar * filename)2551 gboolean gsb_data_account_set_name_icon ( gint account_number,
2552 const gchar *filename )
2553 {
2554 AccountStruct *account;
2555
2556 account = gsb_data_account_get_structure ( account_number );
2557
2558 if ( !account )
2559 return FALSE;
2560
2561 g_free ( account -> name_icon );
2562
2563 if ( !filename || !strlen ( filename ) )
2564 account -> name_icon = NULL;
2565 else
2566 {
2567 if ( !g_file_test ( filename, G_FILE_TEST_EXISTS ) )
2568 account -> name_icon = NULL;
2569 else
2570 account -> name_icon = my_strdup ( filename );
2571 }
2572
2573 return TRUE;
2574 }
2575
2576
2577 /**
2578 * get the image icon of the account
2579 *
2580 * \param account_number no of the account
2581 *
2582 * \return image icon
2583 * */
gsb_data_account_get_account_icon_image(gint account_number)2584 GtkWidget *gsb_data_account_get_account_icon_image ( gint account_number )
2585 {
2586 GdkPixbuf * pixbuf;
2587 GtkWidget *image;
2588
2589 pixbuf = gsb_data_account_get_account_icon_pixbuf ( account_number );
2590 image = gtk_image_new_from_pixbuf ( pixbuf );
2591 g_object_unref ( G_OBJECT ( pixbuf ) );
2592
2593 return image;
2594 }
2595
2596 /**
2597 * get the pixbuf icon of the account
2598 *
2599 * \param account_number no of the account
2600 *
2601 * \return pixbuf icon
2602 * */
gsb_data_account_get_account_icon_pixbuf(gint account_number)2603 GdkPixbuf *gsb_data_account_get_account_icon_pixbuf ( gint account_number )
2604 {
2605 AccountStruct *account;
2606
2607 account = gsb_data_account_get_structure ( account_number );
2608
2609 if ( !account )
2610 return NULL;
2611
2612 if ( account -> pixbuf )
2613 {
2614 g_object_ref ( account -> pixbuf );
2615 return account -> pixbuf;
2616 }
2617 else
2618 {
2619 GdkPixbuf *pixbuf = NULL;
2620
2621 pixbuf = gsb_data_account_get_account_standard_pixbuf ( account -> account_kind );
2622
2623 return pixbuf;
2624 }
2625 }
2626
2627
gsb_data_account_set_account_icon_pixbuf(gint account_number,GdkPixbuf * pixbuf)2628 gboolean gsb_data_account_set_account_icon_pixbuf ( gint account_number,
2629 GdkPixbuf *pixbuf )
2630 {
2631 AccountStruct *account;
2632
2633 account = gsb_data_account_get_structure ( account_number );
2634
2635 if ( !account )
2636 return FALSE;
2637
2638 if ( account -> pixbuf )
2639 g_object_unref ( account -> pixbuf );
2640
2641 if ( pixbuf )
2642 account -> pixbuf = pixbuf;
2643 else
2644 account -> pixbuf = NULL;
2645
2646 return TRUE;
2647 }
2648
2649
2650 /**
2651 * get the default pixbuf icon for the kind_account
2652 *
2653 * \param kind_account
2654 *
2655 * \return pixbuf icon
2656 * */
2657
gsb_data_account_get_account_standard_pixbuf(KindAccount account_kind)2658 GdkPixbuf *gsb_data_account_get_account_standard_pixbuf ( KindAccount account_kind )
2659 {
2660 GdkPixbuf * pixbuf = NULL;
2661 gchar *filename;
2662 GError *error = NULL;
2663
2664 filename = gsb_data_account_get_account_standard_pixbuf_filename ( account_kind );
2665
2666 pixbuf = gdk_pixbuf_new_from_file ( filename, &error );
2667 if ( pixbuf )
2668 g_object_set_data_full ( G_OBJECT ( pixbuf ), "name_icon", filename, g_free );
2669 else
2670 devel_debug ( error -> message );
2671
2672 return pixbuf;
2673 }
2674
2675
2676 /**
2677 * get the filename of the default pixbuf icon for the kind_account
2678 *
2679 * \param kind_account
2680 *
2681 * \return filename
2682 * */
2683
gsb_data_account_get_account_standard_pixbuf_filename(KindAccount account_kind)2684 gchar *gsb_data_account_get_account_standard_pixbuf_filename ( KindAccount account_kind )
2685 {
2686 const gchar *account_icon;
2687 gchar *filename;
2688
2689 switch ( account_kind )
2690 {
2691 case GSB_TYPE_BANK:
2692 account_icon = "gsb-ac-bank-32.png";
2693 break;
2694 case GSB_TYPE_CASH:
2695 account_icon = "gsb-ac-cash-32.png";
2696 break;
2697 case GSB_TYPE_ASSET:
2698 account_icon = "gsb-ac-asset-32.png";
2699 break;
2700 case GSB_TYPE_LIABILITIES:
2701 account_icon = "gsb-ac-liability-32.png";
2702 break;
2703 case GSB_TYPE_BALANCE:
2704 default:
2705 account_icon = "gsb-ac-bank-32.png";
2706 break;
2707 }
2708
2709 filename = g_build_filename ( gsb_dirs_get_pixmaps_dir ( ), account_icon, NULL );
2710
2711 return filename;
2712 }
2713
2714
2715 /**
2716 *
2717 *
2718 *
2719 *
2720 * */
gsb_data_account_change_account_icon(GtkWidget * button,gpointer data)2721 void gsb_data_account_change_account_icon ( GtkWidget *button, gpointer data )
2722 {
2723 gchar *std_pixbuf_filename;
2724 gchar *name_icon;
2725 gchar *new_icon;
2726 gint current_account;
2727
2728 devel_debug ( NULL );
2729
2730 current_account = gsb_gui_navigation_get_current_account ();
2731
2732 std_pixbuf_filename = gsb_data_account_get_account_standard_pixbuf_filename (
2733 gsb_data_account_get_kind ( current_account ) );
2734
2735 name_icon = gsb_data_account_get_name_icon ( current_account );
2736 if ( name_icon == NULL || g_file_test ( name_icon, G_FILE_TEST_EXISTS ) == FALSE )
2737 name_icon = std_pixbuf_filename;
2738
2739 new_icon = gsb_select_icon_create_window ( name_icon );
2740
2741 if ( new_icon && strcmp ( new_icon, name_icon ) != 0 )
2742 {
2743 GtkWidget *image;
2744
2745 if ( strcmp ( new_icon, std_pixbuf_filename ) == 0 )
2746 {
2747 gsb_data_account_set_name_icon ( current_account, NULL );
2748 gsb_data_account_set_account_icon_pixbuf ( current_account, NULL );
2749
2750 image = gsb_data_account_get_account_icon_image ( current_account );
2751 gtk_button_set_image ( GTK_BUTTON ( button ), image );
2752 gsb_gui_navigation_update_account ( current_account );
2753 }
2754 else
2755 {
2756 GdkPixbuf *pixbuf;
2757
2758 gsb_data_account_set_name_icon ( current_account, new_icon );
2759 pixbuf = gsb_select_icon_new_account_pixbuf_from_file (new_icon);
2760 gsb_data_account_set_account_icon_pixbuf ( current_account, pixbuf );
2761
2762 image = gsb_data_account_get_account_icon_image ( current_account );
2763 gtk_button_set_image ( GTK_BUTTON ( button ), image );
2764 gsb_gui_navigation_update_account ( current_account );
2765 }
2766
2767 gsb_file_set_modified ( TRUE );
2768 }
2769
2770 g_free ( std_pixbuf_filename );
2771 }
2772
2773
2774 /**
2775 *
2776 *
2777 *
2778 *
2779 * */
gsb_data_account_get_bank_account_iban(gint account_number)2780 gchar *gsb_data_account_get_bank_account_iban (gint account_number)
2781 {
2782 AccountStruct *account;
2783
2784 account = gsb_data_account_get_structure ( account_number );
2785
2786 if ( !account )
2787 return NULL;
2788
2789 return account -> bank_account_iban;
2790 }
2791
2792
2793 /**
2794 *
2795 *
2796 *
2797 *
2798 * */
gsb_data_account_set_bank_account_iban(gint account_number,const gchar * iban)2799 gboolean gsb_data_account_set_bank_account_iban ( gint account_number, const gchar *iban )
2800 {
2801 AccountStruct *account;
2802
2803 account = gsb_data_account_get_structure ( account_number );
2804
2805 if ( !account )
2806 return FALSE;
2807
2808 g_free ( account -> bank_account_iban );
2809
2810 if (!iban || !strlen (iban))
2811 account -> bank_account_iban = NULL;
2812 else
2813 account -> bank_account_iban = my_strdup ( iban );
2814
2815 return TRUE;
2816 }
2817
2818
2819 /**
2820 *
2821 *
2822 *
2823 *
2824 * */
gsb_data_account_colorize_current_balance(gint account_number)2825 void gsb_data_account_colorize_current_balance ( gint account_number )
2826 {
2827 gchar *string;
2828 gchar *tmpstr;
2829
2830 tmpstr = utils_real_get_string_with_currency (
2831 gsb_data_account_get_current_balance (account_number),
2832 gsb_data_account_get_currency (account_number),
2833 TRUE
2834 );
2835 string = tmpstr;
2836
2837 if ( gsb_data_account_get_current_balance (account_number).mantissa < 0 )
2838 {
2839 string = g_strdup_printf ( "<span color=\"red\">%s</span>", tmpstr );
2840 g_free ( tmpstr );
2841 }
2842
2843 if ( !string )
2844 string = g_strdup ( "" );
2845
2846 grisbi_win_headings_update_suffix ( string );
2847 g_free ( string );
2848 }
2849
2850
2851 /**
2852 * Calculates the balance at the date today for the bet module.
2853 * Excludes future transactions.
2854 *
2855 *
2856 * */
gsb_data_account_calculate_current_day_balance(gint account_number,GDate * day)2857 GsbReal gsb_data_account_calculate_current_day_balance ( gint account_number,
2858 GDate *day )
2859 {
2860 AccountStruct *account;
2861 GDate *date_jour;
2862 GSList *tmp_list;
2863 GsbReal current_balance;
2864 GsbReal current_balance_later = null_real;
2865 gint floating_point;
2866
2867 account = gsb_data_account_get_structure ( account_number );
2868
2869 if ( !account )
2870 return null_real;
2871
2872 floating_point = gsb_data_currency_get_floating_point ( account -> currency );
2873
2874 current_balance = gsb_real_adjust_exponent ( account -> init_balance,
2875 floating_point );
2876
2877 if ( day == NULL )
2878 date_jour = gdate_today ( );
2879 else
2880 date_jour = gsb_date_copy ( day );
2881
2882 tmp_list = gsb_data_transaction_get_complete_transactions_list ();
2883
2884 while (tmp_list)
2885 {
2886 gint transaction_number;
2887 gint res = 0;
2888 GsbReal adjusted_amout;
2889 GsbReal tmp_balance;
2890
2891 transaction_number = gsb_data_transaction_get_transaction_number ( tmp_list->data );
2892
2893 /* on ne tient pas compte des échéances futures pour le solde */
2894 res = g_date_compare ( date_jour,
2895 gsb_data_transaction_get_date ( transaction_number ) );
2896 if ( gsb_data_transaction_get_account_number (transaction_number) == account_number
2897 &&
2898 !gsb_data_transaction_get_mother_transaction_number (transaction_number)
2899 && res > 0 )
2900 {
2901 adjusted_amout = gsb_data_transaction_get_adjusted_amount (
2902 transaction_number, floating_point );
2903
2904 tmp_balance = gsb_real_add ( current_balance, adjusted_amout );
2905
2906 if( tmp_balance.mantissa != error_real.mantissa )
2907 current_balance = tmp_balance;
2908 else
2909 current_balance_later = gsb_real_add ( current_balance_later, adjusted_amout);
2910 }
2911 tmp_list = tmp_list -> next;
2912 }
2913
2914 g_date_free ( date_jour );
2915
2916 return gsb_real_add ( current_balance, current_balance_later );
2917 }
2918
2919
2920 /**
2921 *
2922 *
2923 *
2924 * */
gsb_data_account_get_bet_start_date(gint account_number)2925 GDate *gsb_data_account_get_bet_start_date ( gint account_number )
2926 {
2927 GDate *date = NULL;
2928 AccountStruct *account;
2929
2930 account = gsb_data_account_get_structure ( account_number );
2931
2932 if ( !account )
2933 return 0;
2934
2935 date = account -> bet_start_date;
2936
2937 if ( date && g_date_valid ( date ) )
2938 return gsb_date_copy ( date );
2939 else
2940 {
2941 date = gdate_today ( );
2942 if ( etat.bet_debut_period == 1 )
2943 g_date_set_day ( date, 1 );
2944
2945 return date;
2946 }
2947 }
2948
2949
2950 /**
2951 *
2952 *
2953 *
2954 * */
gsb_data_account_set_bet_start_date(gint account_number,const GDate * date)2955 gboolean gsb_data_account_set_bet_start_date ( gint account_number, const GDate *date )
2956 {
2957 AccountStruct *account;
2958
2959 account = gsb_data_account_get_structure ( account_number );
2960
2961 if ( !account )
2962 return FALSE;
2963
2964 if ( date && g_date_valid ( date ) )
2965 {
2966 account -> bet_start_date = gsb_date_copy ( date );
2967 return TRUE;
2968 }
2969 else
2970 {
2971 GDate *date_new;
2972
2973 date_new = gdate_today ( );
2974 if ( etat.bet_debut_period == 1 )
2975 g_date_set_day ( date_new, 1 );
2976 account -> bet_start_date = date_new;
2977 return FALSE;
2978 }
2979 }
2980
2981
2982 /**
2983 *
2984 *
2985 *
2986 * */
gsb_data_account_get_bet_spin_range(gint account_number)2987 gint gsb_data_account_get_bet_spin_range ( gint account_number )
2988 {
2989 AccountStruct *account;
2990
2991 account = gsb_data_account_get_structure ( account_number );
2992
2993 if ( !account )
2994 return 0;
2995
2996 return account -> bet_spin_range;
2997 }
2998
2999
3000 /**
3001 *
3002 *
3003 *
3004 * */
gsb_data_account_set_bet_spin_range(gint account_number,gint spin_range)3005 gboolean gsb_data_account_set_bet_spin_range ( gint account_number, gint spin_range )
3006 {
3007 AccountStruct *account;
3008
3009 account = gsb_data_account_get_structure ( account_number );
3010
3011 if ( !account )
3012 return FALSE;
3013
3014 account -> bet_spin_range = spin_range;
3015
3016 return TRUE;
3017 }
3018
3019
3020 /**
3021 *
3022 *
3023 *
3024 * */
gsb_data_account_get_bet_months(gint account_number)3025 gint gsb_data_account_get_bet_months ( gint account_number )
3026 {
3027 AccountStruct *account;
3028
3029 account = gsb_data_account_get_structure ( account_number );
3030
3031 if ( !account )
3032 return 0;
3033
3034 if ( account -> bet_months == 0 )
3035 return 1;
3036 else
3037 return account -> bet_months;
3038 }
3039
3040
3041 /**
3042 *
3043 *
3044 *
3045 * */
gsb_data_account_set_bet_months(gint account_number,gint months)3046 gboolean gsb_data_account_set_bet_months ( gint account_number, gint months )
3047 {
3048 AccountStruct *account;
3049
3050 account = gsb_data_account_get_structure ( account_number );
3051
3052 if ( !account )
3053 return FALSE;
3054
3055 account -> bet_months = months;
3056
3057 return TRUE;
3058 }
3059
3060
3061 /**
3062 * return the historical source of the data
3063 *
3064 *
3065 * */
gsb_data_account_get_bet_hist_data(gint account_number)3066 gint gsb_data_account_get_bet_hist_data ( gint account_number )
3067 {
3068 AccountStruct *account;
3069
3070 account = gsb_data_account_get_structure ( account_number );
3071
3072 if ( !account )
3073 return 0;
3074
3075 return account -> bet_hist_data;
3076 }
3077
3078
3079 /**
3080 *
3081 *
3082 *
3083 * */
gsb_data_account_set_bet_hist_data(gint account_number,gint hist_data)3084 gboolean gsb_data_account_set_bet_hist_data ( gint account_number, gint hist_data )
3085 {
3086 AccountStruct *account;
3087
3088 account = gsb_data_account_get_structure ( account_number );
3089
3090 if ( !account )
3091 return FALSE;
3092
3093 account -> bet_hist_data = hist_data;
3094
3095 return TRUE;
3096 }
3097
3098
3099 /**
3100 *
3101 *
3102 *
3103 * */
gsb_data_account_get_bet_hist_fyear(gint account_number)3104 gint gsb_data_account_get_bet_hist_fyear ( gint account_number )
3105 {
3106 AccountStruct *account;
3107
3108 account = gsb_data_account_get_structure ( account_number );
3109
3110 if ( !account )
3111 return 0;
3112
3113 return account -> bet_hist_fyear;
3114 }
3115
3116
3117 /**
3118 *
3119 *
3120 *
3121 * */
gsb_data_account_set_bet_hist_fyear(gint account_number,gint hist_fyear)3122 gboolean gsb_data_account_set_bet_hist_fyear ( gint account_number, gint hist_fyear )
3123 {
3124 AccountStruct *account;
3125
3126 account = gsb_data_account_get_structure ( account_number );
3127
3128 if ( !account )
3129 return FALSE;
3130
3131 account -> bet_hist_fyear = hist_fyear;
3132
3133 return TRUE;
3134 }
3135
3136
3137 /**
3138 *
3139 *
3140 *
3141 * */
gsb_data_account_get_bet_auto_inc_month(gint account_number)3142 gboolean gsb_data_account_get_bet_auto_inc_month ( gint account_number )
3143 {
3144 AccountStruct *account;
3145
3146 account = gsb_data_account_get_structure ( account_number );
3147
3148 if ( !account )
3149 return FALSE;
3150
3151 return account -> bet_auto_inc_month;
3152 }
3153
3154
3155 /**
3156 *
3157 *
3158 *
3159 * */
gsb_data_account_set_bet_auto_inc_month(gint account_number,gboolean auto_inc_month)3160 gboolean gsb_data_account_set_bet_auto_inc_month ( gint account_number,
3161 gboolean auto_inc_month )
3162 {
3163 AccountStruct *account;
3164
3165 account = gsb_data_account_get_structure ( account_number );
3166
3167 if ( !account )
3168 return FALSE;
3169
3170 account -> bet_auto_inc_month = auto_inc_month;
3171
3172 return TRUE;
3173 }
3174
3175
3176 /**
3177 *
3178 *
3179 *
3180 * */
gsb_data_account_get_bet_select_label(gint account_number,gint origine)3181 gint gsb_data_account_get_bet_select_label ( gint account_number, gint origine )
3182 {
3183 AccountStruct *account;
3184
3185 account = gsb_data_account_get_structure ( account_number );
3186
3187 if ( !account )
3188 return 0;
3189
3190 switch ( origine )
3191 {
3192 case SPP_ORIGIN_TRANSACTION:
3193 return account -> bet_select_transaction_label;
3194 break;
3195 case SPP_ORIGIN_SCHEDULED:
3196 return account -> bet_select_scheduled_label;
3197 break;
3198 case SPP_ORIGIN_FUTURE:
3199 return account -> bet_select_futur_label;
3200 break;
3201 }
3202
3203 return 0;
3204 }
3205
3206
3207 /**
3208 *
3209 *
3210 *
3211 * */
gsb_data_account_set_bet_select_label(gint account_number,gint origine,gint type)3212 gboolean gsb_data_account_set_bet_select_label ( gint account_number,
3213 gint origine,
3214 gint type )
3215 {
3216 AccountStruct *account;
3217
3218 account = gsb_data_account_get_structure ( account_number );
3219
3220 if ( !account )
3221 return FALSE;
3222
3223 switch ( origine )
3224 {
3225 case SPP_ORIGIN_TRANSACTION:
3226 account -> bet_select_transaction_label = type;
3227 break;
3228 case SPP_ORIGIN_SCHEDULED:
3229 account -> bet_select_scheduled_label = type;
3230 break;
3231 case SPP_ORIGIN_FUTURE:
3232 account -> bet_select_futur_label = type;
3233 break;
3234 }
3235
3236 return TRUE;
3237 }
3238
3239
3240 /**
3241 *
3242 *
3243 *
3244 * */
gsb_data_account_bet_update_initial_date_if_necessary(gint account_number)3245 gboolean gsb_data_account_bet_update_initial_date_if_necessary ( gint account_number )
3246 {
3247 GDate *date_jour;
3248 GDate *tmp_date;
3249
3250 date_jour = gdate_today ( );
3251 tmp_date = gsb_data_account_get_bet_start_date (account_number);
3252 g_date_add_months ( tmp_date, 1 );
3253
3254 if ( g_date_compare ( date_jour, tmp_date ) >= 0 )
3255 {
3256 if ( g_date_get_month ( date_jour ) == g_date_get_month ( tmp_date ) )
3257 gsb_data_account_set_bet_start_date ( account_number, tmp_date );
3258 else
3259 {
3260 g_date_set_day ( date_jour, g_date_get_day ( tmp_date ) );
3261 gsb_data_account_set_bet_start_date ( account_number, date_jour );
3262 }
3263 }
3264
3265 g_date_free ( tmp_date );
3266 g_date_free ( date_jour );
3267
3268 return FALSE;
3269 }
3270
3271
3272 /**
3273 * retourne le bit utilisation du module budget.
3274 *
3275 * -1 pas de module possible 0 non utilisé 1 utilisé
3276 * */
gsb_data_account_get_bet_use_budget(gint account_number)3277 gint gsb_data_account_get_bet_use_budget ( gint account_number )
3278 {
3279 AccountStruct *account;
3280 KindAccount kind;
3281
3282 account = gsb_data_account_get_structure ( account_number );
3283
3284 if ( !account )
3285 return 0;
3286
3287 kind = account -> account_kind;
3288
3289 switch ( kind )
3290 {
3291 case GSB_TYPE_BANK:
3292 case GSB_TYPE_CASH:
3293 case GSB_TYPE_LIABILITIES:
3294 return account -> bet_use_budget;
3295 break;
3296 case GSB_TYPE_ASSET:
3297 case GSB_TYPE_BALANCE:
3298 return -1;
3299 break;
3300 default:
3301 return -1;
3302 break;
3303 }
3304
3305 return -1;
3306 }
3307
3308
3309 /**
3310 *
3311 *
3312 *
3313 *
3314 * */
gsb_data_account_set_bet_use_budget(gint account_number,gint value)3315 gboolean gsb_data_account_set_bet_use_budget ( gint account_number, gint value )
3316 {
3317 AccountStruct *account;
3318
3319 account = gsb_data_account_get_structure ( account_number );
3320
3321 if ( !account )
3322 return FALSE;
3323
3324 account -> bet_use_budget = value;
3325
3326 return TRUE;
3327 }
3328
3329
3330 /**
3331 *
3332 *
3333 *
3334 *
3335 * */
gsb_data_account_get_bet_maj(gint account_number)3336 gint gsb_data_account_get_bet_maj ( gint account_number )
3337 {
3338 AccountStruct *account;
3339
3340 account = gsb_data_account_get_structure ( account_number );
3341
3342 if ( !account )
3343 return 0;
3344
3345 return account -> bet_maj;
3346 }
3347
3348
3349 /**
3350 *
3351 *
3352 *
3353 *
3354 * */
gsb_data_account_set_bet_maj(gint account_number,gint type_maj)3355 gboolean gsb_data_account_set_bet_maj ( gint account_number, gint type_maj )
3356 {
3357 AccountStruct *account;
3358
3359 account = gsb_data_account_get_structure ( account_number );
3360
3361 if ( !account )
3362 return FALSE;
3363
3364 account -> bet_maj = type_maj;
3365
3366 return TRUE;
3367 }
3368
3369
3370 /**
3371 *
3372 *
3373 *
3374 *
3375 * */
gsb_data_account_set_bet_finance_capital(gint account_number,gdouble capital)3376 gboolean gsb_data_account_set_bet_finance_capital ( gint account_number, gdouble capital )
3377 {
3378 AccountStruct *account;
3379
3380 account = gsb_data_account_get_structure ( account_number );
3381
3382 if ( !account )
3383 return FALSE;
3384
3385 account -> bet_capital = capital;
3386
3387 return TRUE;
3388 }
3389
3390
3391 /**
3392 *
3393 *
3394 *
3395 *
3396 * */
gsb_data_account_set_bet_finance_taux_annuel(gint account_number,gdouble taux_annuel)3397 gboolean gsb_data_account_set_bet_finance_taux_annuel ( gint account_number, gdouble taux_annuel )
3398 {
3399 AccountStruct *account;
3400
3401 account = gsb_data_account_get_structure ( account_number );
3402
3403 if ( !account )
3404 return FALSE;
3405
3406 account -> bet_taux_annuel = taux_annuel;
3407
3408 return TRUE;
3409 }
3410
3411
3412 /**
3413 *
3414 *
3415 *
3416 *
3417 * */
gsb_data_account_set_bet_finance_frais(gint account_number,gdouble frais)3418 gboolean gsb_data_account_set_bet_finance_frais ( gint account_number, gdouble frais )
3419 {
3420 AccountStruct *account;
3421
3422 account = gsb_data_account_get_structure ( account_number );
3423
3424 if ( !account )
3425 return FALSE;
3426
3427 account -> bet_frais = frais;
3428
3429 return TRUE;
3430 }
3431
3432
3433 /**
3434 *
3435 *
3436 *
3437 * */
gsb_data_account_set_bet_finance_type_taux(gint account_number,gint type_taux)3438 gboolean gsb_data_account_set_bet_finance_type_taux ( gint account_number, gint type_taux )
3439 {
3440 AccountStruct *account;
3441
3442 account = gsb_data_account_get_structure ( account_number );
3443
3444 if ( !account )
3445 return FALSE;
3446
3447 account -> bet_type_taux = type_taux;
3448
3449 return TRUE;
3450 }
3451
3452 /**
3453 *
3454 *
3455 * \param
3456 *
3457 * \return
3458 **/
gsb_data_account_get_bet_init_sch_with_loan(gint account_number)3459 gboolean gsb_data_account_get_bet_init_sch_with_loan (gint account_number)
3460 {
3461 AccountStruct *account;
3462
3463 account = gsb_data_account_get_structure (account_number);
3464
3465 if (!account)
3466 return 0;
3467
3468 return account->bet_init_sch_with_loan;
3469 }
3470
3471 /**
3472 *
3473 *
3474 * \param
3475 *
3476 * \return
3477 **/
gsb_data_account_set_bet_init_sch_with_loan(gint account_number,gboolean init_sch_with_loan)3478 gboolean gsb_data_account_set_bet_init_sch_with_loan (gint account_number,
3479 gboolean init_sch_with_loan)
3480 {
3481 AccountStruct *account;
3482
3483 account = gsb_data_account_get_structure (account_number);
3484
3485 if (!account)
3486 return FALSE;
3487
3488 account->bet_init_sch_with_loan = init_sch_with_loan;
3489
3490 return TRUE;
3491 }
3492
3493
3494 /**
3495 *
3496 *
3497 * \param
3498 *
3499 * \return
3500 **/
gsb_data_account_get_bet_split_transaction(gint account_number)3501 gboolean gsb_data_account_get_bet_split_transaction (gint account_number)
3502 {
3503 AccountStruct *account;
3504
3505 account = gsb_data_account_get_structure (account_number);
3506
3507 if (!account)
3508 return 0;
3509
3510 return account->bet_split_transaction;
3511 }
3512
3513 /**
3514 *
3515 *
3516 * \param
3517 *
3518 * \return
3519 **/
gsb_data_account_set_bet_split_transaction(gint account_number,gboolean split_transaction)3520 gboolean gsb_data_account_set_bet_split_transaction (gint account_number,
3521 gboolean split_transaction)
3522 {
3523 AccountStruct *account;
3524
3525 account = gsb_data_account_get_structure (account_number);
3526
3527 if (!account)
3528 return FALSE;
3529
3530 account->bet_split_transaction = split_transaction;
3531
3532 return TRUE;
3533 }
3534
3535
3536
3537 /**
3538 * get floating_point of the currency on the account given
3539 *
3540 * \param account_number no of the account
3541 *
3542 * \return floating_point or 0 if the account or the currency doesn't exist
3543 * */
gsb_data_account_get_currency_floating_point(gint account_number)3544 gint gsb_data_account_get_currency_floating_point ( gint account_number )
3545 {
3546 AccountStruct *account;
3547 gint floating_point;
3548
3549 account = gsb_data_account_get_structure ( account_number );
3550
3551 if ( !account )
3552 return 0;
3553 else
3554 {
3555 floating_point = gsb_data_currency_get_floating_point ( account -> currency );
3556 return floating_point;
3557 }
3558 }
3559
3560
3561 /**
3562 * retourne l'option carte CB à débit différé.
3563 *
3564 * \param account_number
3565 *
3566 * \return -1 pas de CB possible 0 non utilisé 1 utilisé
3567 * */
gsb_data_account_get_bet_credit_card(gint account_number)3568 gint gsb_data_account_get_bet_credit_card ( gint account_number )
3569 {
3570 AccountStruct *account;
3571 KindAccount kind;
3572
3573 account = gsb_data_account_get_structure ( account_number );
3574
3575 if ( !account )
3576 return 0;
3577
3578 kind = account -> account_kind;
3579
3580 switch ( kind )
3581 {
3582 case GSB_TYPE_BANK:
3583 case GSB_TYPE_CASH:
3584 case GSB_TYPE_LIABILITIES:
3585 return account->bet_credit_card;
3586 break;
3587 case GSB_TYPE_ASSET:
3588 case GSB_TYPE_BALANCE:
3589 return 0;
3590 break;
3591 default:
3592 return 0;
3593 break;
3594 }
3595
3596 return -1;
3597 }
3598
3599
3600 /**
3601 * positionne l'option bet_credit_card
3602 *
3603 * \param account_number
3604 * \param value
3605 *
3606 * \ return TRUE if OK
3607 * */
gsb_data_account_set_bet_credit_card(gint account_number,gint value)3608 gboolean gsb_data_account_set_bet_credit_card ( gint account_number,
3609 gint value )
3610 {
3611 AccountStruct *account;
3612
3613 account = gsb_data_account_get_structure ( account_number );
3614
3615 if ( !account )
3616 return FALSE;
3617
3618 account->bet_credit_card = value;
3619
3620 return TRUE;
3621 }
3622
3623
3624 /**
3625 * retourne le type d'onglet à afficher pour le module budgetaire.
3626 *
3627 * \param account_number
3628 *
3629 * \return enum BetTypeOnglets
3630 * */
gsb_data_account_get_bet_show_onglets(gint account_number)3631 BetTypeOnglets gsb_data_account_get_bet_show_onglets ( gint account_number )
3632 {
3633 AccountStruct *account;
3634
3635 account = gsb_data_account_get_structure ( account_number );
3636
3637 if ( !account )
3638 return BET_ONGLETS_SANS;
3639
3640 return account->bet_show_onglets;
3641 }
3642
3643
3644 /**
3645 * positionne l'option bet_show_onglets
3646 *
3647 * \param account_number
3648 *
3649 * \ return TRUE if OK
3650 * */
gsb_data_account_set_bet_show_onglets(gint account_number)3651 gboolean gsb_data_account_set_bet_show_onglets ( gint account_number )
3652 {
3653 AccountStruct *account;
3654 gint bet_use_budget;
3655 KindAccount kind;
3656 GrisbiWinEtat *w_etat;
3657
3658 w_etat = (GrisbiWinEtat *) grisbi_win_get_w_etat ();
3659 account = gsb_data_account_get_structure ( account_number );
3660
3661 if ( !account )
3662 return FALSE;
3663
3664 bet_use_budget = gsb_data_account_get_bet_use_budget ( account_number );
3665
3666 if ( bet_use_budget == 0 )
3667 {
3668 account->bet_show_onglets = BET_ONGLETS_SANS;
3669 return TRUE;
3670 }
3671
3672 kind = gsb_data_account_get_kind ( account_number );
3673
3674 switch ( kind )
3675 {
3676 case GSB_TYPE_BALANCE:
3677 account->bet_show_onglets = BET_ONGLETS_SANS;
3678 break;
3679 case GSB_TYPE_BANK:
3680 account->bet_show_onglets = BET_ONGLETS_PREV;
3681 break;
3682 case GSB_TYPE_CASH:
3683 if ( w_etat->bet_cash_account_option == 1 )
3684 account->bet_show_onglets = BET_ONGLETS_PREV;
3685 else
3686 account->bet_show_onglets = BET_ONGLETS_HIST;
3687 break;
3688 case GSB_TYPE_LIABILITIES:
3689 if ( account->bet_credit_card )
3690 {
3691 if ( w_etat->bet_cash_account_option == 1 )
3692 account->bet_show_onglets = BET_ONGLETS_PREV;
3693 else
3694 account->bet_show_onglets = BET_ONGLETS_HIST;
3695 }
3696 else
3697 account->bet_show_onglets = BET_ONGLETS_CAP;
3698 break;
3699 case GSB_TYPE_ASSET:
3700 account->bet_show_onglets = BET_ONGLETS_SANS;
3701 break;
3702 }
3703
3704 return TRUE;
3705 }
3706
3707
3708 /**
3709 * positionne l'option bet_show_onglets pour tous les comptes
3710 *
3711 * \param
3712 *
3713 * \return FALSE
3714 * */
gsb_data_account_set_bet_show_onglets_all_accounts(void)3715 gboolean gsb_data_account_set_bet_show_onglets_all_accounts ( void )
3716 {
3717 GSList *list_tmp;
3718
3719 list_tmp = gsb_data_account_get_list_accounts ();
3720
3721 while ( list_tmp )
3722 {
3723 gint account_number;
3724
3725 account_number = gsb_data_account_get_no_account ( list_tmp -> data );
3726 gsb_data_account_set_bet_show_onglets ( account_number );
3727
3728 list_tmp = list_tmp -> next;
3729 }
3730
3731 return FALSE;
3732 }
3733
3734
3735 /**
3736 * teste l'existence d'un compte
3737 *
3738 * \param account_number
3739 *
3740 * \ return TRUE if OK else FALSE
3741 * */
gsb_data_account_exists(gint account_number)3742 gboolean gsb_data_account_exists ( gint account_number )
3743 {
3744 AccountStruct *account;
3745 account = gsb_data_account_get_structure ( account_number );
3746
3747 if ( account )
3748 return TRUE;
3749 else
3750 return FALSE;
3751 }
3752
3753
3754 /**
3755 * calcule le solde d'un compte à une date donnée
3756 *
3757 * \param account_number numéro du compte concerné
3758 * \param date date de calcul du solde
3759 *
3760 * \return GsbReal le solde du compte
3761 * */
gsb_data_account_get_balance_at_date(gint account_number,GDate * date)3762 GsbReal gsb_data_account_get_balance_at_date ( gint account_number,
3763 GDate *date )
3764 {
3765 AccountStruct *account;
3766 GSList *tmp_list;
3767 GsbReal current_balance;
3768 gint floating_point;
3769
3770 account = gsb_data_account_get_structure ( account_number );
3771
3772 if ( !account )
3773 return null_real;
3774
3775 floating_point = gsb_data_currency_get_floating_point (account -> currency);
3776
3777 current_balance = gsb_real_adjust_exponent ( account->init_balance, floating_point );
3778
3779 tmp_list = gsb_data_transaction_get_complete_transactions_list ();
3780
3781 while (tmp_list)
3782 {
3783 gint transaction_number;
3784
3785 transaction_number = gsb_data_transaction_get_transaction_number ( tmp_list->data );
3786
3787 if ( gsb_data_transaction_get_account_number ( transaction_number ) != account_number )
3788 {
3789 tmp_list = tmp_list->next;
3790 continue;
3791 }
3792
3793 if ( g_date_compare ( gsb_data_transaction_get_value_date_or_date ( transaction_number ),
3794 date ) > 0 )
3795 {
3796 tmp_list = tmp_list->next;
3797 continue;
3798 }
3799
3800 if ( gsb_data_transaction_get_mother_transaction_number ( transaction_number ) == 0 )
3801 {
3802 GsbReal adjusted_amout;
3803 GsbReal tmp_balance;
3804
3805 adjusted_amout = gsb_data_transaction_get_adjusted_amount ( transaction_number, floating_point );
3806 tmp_balance = gsb_real_add ( current_balance, adjusted_amout );
3807
3808 if ( tmp_balance.mantissa == error_real.mantissa )
3809 return error_real;
3810 else
3811 current_balance = tmp_balance;
3812 }
3813 tmp_list = tmp_list->next;
3814 }
3815
3816 return current_balance;
3817 }
3818
3819 /**
3820 * set limits of current and authorized balance of all accounts
3821 *
3822 * \param
3823 *
3824 * \return
3825 * */
gsb_data_account_set_all_limits_of_balance(void)3826 void gsb_data_account_set_all_limits_of_balance (void)
3827 {
3828 GSList *tmp_list;
3829
3830 tmp_list = gsb_data_account_get_list_accounts ();
3831
3832 while (tmp_list)
3833 {
3834 gint account_number;
3835 volatile gint value;
3836
3837 account_number = gsb_data_account_get_no_account (tmp_list->data);
3838
3839 /* set the minimum balances to be shown or not */
3840 value = gsb_real_cmp (gsb_data_account_get_current_balance (account_number),
3841 gsb_data_account_get_mini_balance_authorized (account_number)) == -1;
3842 gsb_data_account_set_mini_balance_authorized_message (account_number, value);
3843 value = gsb_real_cmp (gsb_data_account_get_current_balance (account_number),
3844 gsb_data_account_get_mini_balance_wanted (account_number)) == -1;
3845 gsb_data_account_set_mini_balance_wanted_message (account_number, value);
3846
3847 tmp_list = tmp_list->next;
3848 }
3849 }
3850
3851 /**
3852 *
3853 *
3854 * \param
3855 *
3856 * \return
3857 **/
gsb_data_account_get_has_pointed(gint account_number)3858 gboolean gsb_data_account_get_has_pointed (gint account_number)
3859 {
3860 AccountStruct *account;
3861
3862 account = gsb_data_account_get_structure (account_number);
3863
3864 if (!account)
3865 return FALSE;
3866
3867 return account->has_pointed;
3868 }
3869
3870 /**
3871 *
3872 *
3873 * \param
3874 *
3875 * \return
3876 **/
gsb_data_account_renum_account_number_0(const gchar * filename)3877 gboolean gsb_data_account_renum_account_number_0 (const gchar *filename)
3878 {
3879 gint account_number;
3880 GSList *payment_list;
3881 GSList *tmp_list;
3882 GSList *number_list = NULL;
3883 gchar* tmp_str;
3884 gint i = 0;
3885 gint result;
3886
3887 devel_debug (NULL);
3888 tmp_list = list_accounts;
3889
3890 /* recherche le premier numéro de compte disponible */
3891 while (tmp_list)
3892 {
3893 AccountStruct *account;
3894
3895 account = tmp_list->data;
3896
3897 if (!account)
3898 {
3899 return FALSE;
3900 }
3901 else
3902 {
3903 account_number = account->account_number;
3904 }
3905 number_list = g_slist_append (number_list, GINT_TO_POINTER (account_number));
3906
3907 tmp_list = tmp_list->next;
3908 }
3909
3910 number_list = g_slist_sort (number_list, (GCompareFunc) gsb_data_account_cmp_numbers);
3911
3912 tmp_list = number_list;
3913
3914 while (tmp_list)
3915 {
3916 account_number = GPOINTER_TO_INT (tmp_list->data);
3917 if (account_number > i)
3918 {
3919 break;
3920 }
3921 i++;
3922 tmp_list = tmp_list->next;
3923 }
3924
3925 account_number = i;
3926
3927 g_slist_free (number_list);
3928
3929 /* Avertissement avant renommage du compte */
3930 tmp_str = g_strdup_printf (_("The account \"%s\" has the number 0 which creates a bug in certain situations."
3931 " It will be renumbered and will have the number \"%d\"."),
3932 gsb_data_account_get_name (0),
3933 account_number);
3934
3935 result = dialogue_yes_no (tmp_str, _("Rename account \"0\""), GTK_RESPONSE_YES );
3936 g_free (tmp_str);
3937 if (!result)
3938 {
3939 return FALSE;
3940 }
3941
3942 /* on fait une sauvegarde du fichier */
3943 gsb_file_copy_old_file (filename);
3944
3945 /* on traite les opérations */
3946 tmp_list = gsb_data_transaction_get_complete_transactions_list ();
3947
3948 while (tmp_list)
3949 {
3950 gint transaction_number;
3951
3952 transaction_number = gsb_data_transaction_get_transaction_number (tmp_list->data);
3953
3954 if (gsb_data_transaction_get_account_number (transaction_number) == 0)
3955 {
3956 gsb_data_transaction_set_account_number (transaction_number, account_number);
3957 }
3958 tmp_list = tmp_list->next;
3959 }
3960
3961 /* on traite les opérations planifiées*/
3962 tmp_list = gsb_data_scheduled_get_scheduled_list ();
3963
3964 while (tmp_list)
3965 {
3966 gint scheduled_number;
3967
3968 scheduled_number = gsb_data_scheduled_get_scheduled_number (tmp_list->data);
3969
3970 if (gsb_data_scheduled_get_account_number (scheduled_number) == 0)
3971 {
3972 gsb_data_scheduled_set_account_number (scheduled_number, account_number);
3973 }
3974 tmp_list = tmp_list->next;
3975 }
3976
3977 /* on traite les moyens de paiement */
3978 payment_list = gsb_data_payment_get_list_for_account (0);
3979 tmp_list = payment_list;
3980 while (tmp_list)
3981 {
3982 gint payment_number;
3983
3984 payment_number = GPOINTER_TO_INT (tmp_list->data);
3985 gsb_data_payment_set_account_number (payment_number, account_number);
3986 tmp_list = tmp_list->next;
3987 }
3988 g_slist_free (payment_list);
3989
3990 /* on traite les rapprochements */
3991 gsb_data_reconcile_renum_account_number_0 (account_number);
3992
3993 /* on traite les règles d'import des fichiers */
3994 gsb_data_import_rule_renum_account_number_0 (account_number);
3995
3996 /* on traite les états */
3997 gsb_data_report_renum_account_number_0 (account_number);
3998
3999 /* on traite les données budgetaires */
4000 bet_data_renum_account_number_0 (account_number);
4001
4002 /* On traite les soldes partiels */
4003 gsb_data_partial_balance_renum_account_number_0 (account_number);
4004
4005 /* set new numero for account */
4006 gsb_data_account_set_account_number (0, account_number);
4007
4008 gsb_file_set_modified (TRUE);
4009 return TRUE;
4010 }
4011
4012 /**
4013 *
4014 *
4015 * \param
4016 *
4017 * \return
4018 **/
4019 /* Local Variables: */
4020 /* c-basic-offset: 4 */
4021 /* End: */
4022