/** used to compare 2 iters and sort the by reconcile number first, and
* by date and no transaction after
* always put the white line below
* \param model the GtkTreeModel
* \param iter_1
* \param iter_2
* \return -1 if iter_1 is above iter_2
* */
gint gsb_transactions_list_sort_by_reconcile_nb ( gint transaction_number_1,
gint transaction_number_2 )
{
gint return_value;
if ( gsb_data_transaction_get_reconcile_number ( transaction_number_1) == gsb_data_transaction_get_reconcile_number ( transaction_number_2))
return gsb_transactions_list_sort_by_date_and_no ( transaction_number_1, transaction_number_2 );
else
{
const gchar *temp_1;
const gchar *temp_2;
temp_1 = gsb_data_reconcile_get_name ( gsb_data_transaction_get_reconcile_number ( transaction_number_1));
temp_2 = gsb_data_reconcile_get_name ( gsb_data_transaction_get_reconcile_number ( transaction_number_2));
/* g_utf8_collate is said not very fast, must try with big big account to check
* if it's enough, for me it's ok (cedric), eventually, change with gsb_strcasecmp */
return_value = g_utf8_collate ( g_utf8_casefold ( temp_1 ? temp_1 : "",
-1 ),
g_utf8_casefold ( temp_2 ? temp_2 : "",
-1 ));
}
if ( return_value )
return return_value;
else
return gsb_transactions_list_sort_by_date_and_no ( transaction_number_1, transaction_number_2 );
}
/**
* callback called when the user click on 'Delete the reconciliation'
* this will delete the selected reconciliation and will mark all the concerned
* transactions as P
*
* \param button
* \param tree_view
*
* \return FALSE
* */
gboolean gsb_reconcile_config_delete ( GtkWidget *button,
GtkWidget *tree_view )
{
GtkTreeIter iter;
GtkTreeModel *model;
GtkTreeSelection *selection;
gboolean good;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
good = gtk_tree_selection_get_selected (selection, &model, &iter);
if (good)
{
gint reconcile_number;
gint account_number;
gtk_tree_model_get (model, &iter,
RECONCILIATION_RECONCILE_COLUMN, &reconcile_number,
-1 );
if (reconcile_number)
{
/* we are on a reconcile,
* we ask if the user want to continue and warn him */
gchar* tmpstr = g_strdup_printf (_("Caution, you are about to delete a reconciliation.\nIf you continue, the reconciliation %s will be erased and all the transactions marked by this reconciliation will be un-reconciled and marked P.\nAre you sure you want to continue?"),
gsb_data_reconcile_get_name (reconcile_number));
if (!question_yes_no (tmpstr, _("Delete reconciliation"),
GTK_RESPONSE_NO ))
{
g_free ( tmpstr );
return FALSE;
}
/* ok we delete the reconcile
* this will automatickly remove it from the marked transactions */
gtk_tree_store_remove ( GTK_TREE_STORE (model),
&iter );
gsb_data_reconcile_remove (reconcile_number);
/* if we are on an account, we update the list */
account_number = gsb_gui_navigation_get_current_account ();
if (account_number != -1)
{
gsb_transactions_list_update_tree_view (account_number, TRUE);
/* update the last statement for that account */
gsb_gui_navigation_update_statement_label (account_number);
}
gsb_file_set_modified ( TRUE );
}
}
return FALSE;
}
/**
* callback called when something change in the entries of the configuration of the reconcile
*
* \param tree_view
*
* \return FALSE
* */
gboolean gsb_reconcile_config_update_line ( GtkWidget *entry,
GtkWidget *tree_view )
{
GtkTreeIter iter;
GtkTreeModel *model;
GtkTreeSelection *selection;
gboolean good;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
good = gtk_tree_selection_get_selected (selection, &model, &iter);
if (good)
{
gint reconcile_number;
gtk_tree_model_get (model, &iter,
RECONCILIATION_RECONCILE_COLUMN, &reconcile_number,
-1 );
if (reconcile_number)
{
/* we are on a reconcile, change the line with the new values */
gchar *init_date, *final_date;
gchar *init_balance, *final_balance;
init_date = gsb_format_gdate (gsb_data_reconcile_get_init_date (reconcile_number));
final_date = gsb_format_gdate (gsb_data_reconcile_get_final_date (reconcile_number));
init_balance = utils_real_get_string (gsb_data_reconcile_get_init_balance (reconcile_number));
final_balance = utils_real_get_string (gsb_data_reconcile_get_final_balance (reconcile_number));
gtk_tree_store_set ( GTK_TREE_STORE (model),
&iter,
RECONCILIATION_NAME_COLUMN, gsb_data_reconcile_get_name (reconcile_number),
RECONCILIATION_INIT_DATE_COLUMN, init_date,
RECONCILIATION_FINAL_DATE_COLUMN, final_date,
RECONCILIATION_INIT_BALANCE_COLUMN, init_balance,
RECONCILIATION_FINAL_BALANCE_COLUMN, final_balance,
-1 );
g_free (init_date);
g_free (final_date);
g_free (init_balance);
g_free (final_balance);
}
}
return FALSE;
}
/**
* callback called when select a line in the tree
* fill the entry of the name, dates and balances
*
* \param selection the GtkTreeSelection
* \param table the GtkTable containing the widgets to set the value of the selection
*
* \return FALSE
*/
gboolean gsb_reconcile_config_select ( GtkTreeSelection *selection,
GtkWidget *table )
{
GtkTreeIter iter;
GtkTreeModel *model;
gboolean good;
good = gtk_tree_selection_get_selected (selection, &model, &iter);
if (good)
{
gint reconcile_number;
gtk_tree_model_get (model, &iter,
RECONCILIATION_RECONCILE_COLUMN, &reconcile_number,
-1 );
if (reconcile_number)
{
/* we are on a payment method, we fill the fields */
gsb_autofunc_entry_set_value ( reconcile_name_entry,
gsb_data_reconcile_get_name (reconcile_number),
reconcile_number );
gsb_autofunc_date_set ( reconcile_init_date_entry,
gsb_data_reconcile_get_init_date (reconcile_number),
reconcile_number);
gsb_autofunc_date_set ( reconcile_final_date_entry,
gsb_data_reconcile_get_final_date (reconcile_number),
reconcile_number );
gsb_autofunc_real_set ( reconcile_init_balance_entry,
gsb_data_reconcile_get_init_balance (reconcile_number),
reconcile_number );
gsb_autofunc_real_set ( reconcile_final_balance_entry,
gsb_data_reconcile_get_final_balance (reconcile_number),
reconcile_number );
/* we make the table sensitive */
gtk_widget_set_sensitive ( table, TRUE );
}
else
gtk_widget_set_sensitive ( table, FALSE );
}
else
gtk_widget_set_sensitive ( table, FALSE );
return FALSE;
}
/**
* Build the new label for the reconciliation, given the old one.
* The expected format is NAME+NUMBER, so this function returns
* a newly allocated string whose format is NAME+(NUMBER+1). It
* preserves leading '0' for the NUMBER string.
*
* If this is the first label building (first reconciliation for
* this account), then the function returns a standard string
* of the account name (lower case) + '-1'.
*
* \param reconcile_number
*
* \return the new string label
*/
gchar *gsb_reconcile_build_label ( int reconcile_number )
{
gchar *tmp;
gchar *old_label;
gchar *new_label;
gchar format[6] = "%s%0d";
int __reconcile_number;
int __size;
int __expand;
/* old_label = NAME + NUMBER */
old_label = g_strdup ( gsb_data_reconcile_get_name ( reconcile_number ) );
/* return account NAME + '1' */
if ( !old_label )
{
tmp = gsb_data_account_get_name ( gsb_gui_navigation_get_current_account () );
new_label = g_strconcat ( tmp, "-1", NULL );
tmp = new_label;
while ( *tmp != '\0' )
{
if ( *tmp == ' ' )
*tmp = '-';
else
*tmp = tolower ( *tmp );
tmp ++;
}
return new_label;
}
/* we try to find some digits at the end of the name,
* if found, get the biggest number until we find a non digit character */
__expand = 1;
tmp = old_label + ( strlen ( old_label ) - 1 ) * sizeof ( gchar );
while ( isdigit ( *tmp ) && tmp >= old_label )
{
if ( *tmp != '9' )
__expand = 0;
tmp--;
}
tmp ++; /* step forward to the first digit */
__reconcile_number = utils_str_atoi ( tmp ) + 1;
/* if stage 99 -> 100 for example,
* then we have to allocate one more byte */
__size = strlen ( tmp ) + __expand;
/* format string for the output (according NUMBER string length) */
format[3] = 48 + __size;
/* close the NAME string */
*tmp = 0;
/* NAME + NUMBER + '\0' */
__size += strlen ( old_label ) * sizeof ( gchar ) + 1;
new_label = g_malloc0 ( __size * sizeof ( gchar ) );
sprintf ( new_label, format, old_label, __reconcile_number );
/* replace ' ' by '0' in number */
tmp = new_label + strlen ( old_label ) * sizeof ( gchar );
while ( *tmp == ' ' )
*tmp++ = '0';
g_free ( old_label );
return new_label;
}
/**
* called when the user click on the button 'create the new reconciliation'
* check the entries and create the corresponding reconciliation
*
* \param button
* \param label a message label, hidden at the beginning, that will say ok the reconciliation is created
* or if there is a problem...
*
* \return FALSE
* */
static gboolean gsb_assistant_reconcile_config_page_add_new_reconcile ( GtkWidget *button,
GtkWidget *label )
{
gint reconcile_number;
gchar *string;
/* first, we check the date are valid */
if ( !gsb_date_check_entry ( reconcile_init_date_entry ) )
{
string = make_red ( _("The initial date is not valid, please check it.") );
gtk_label_set_markup ( GTK_LABEL ( label) , string );
gtk_widget_grab_focus (reconcile_init_date_entry);
g_free ( string );
return FALSE;
}
if ( !gsb_date_check_entry ( reconcile_final_date_entry ) )
{
string = make_red ( _("The final date is not valid, please check it.") );
gtk_label_set_markup ( GTK_LABEL ( label) , string );
gtk_widget_grab_focus ( reconcile_final_date_entry );
g_free ( string );
return FALSE;
}
/* check there is a name */
if ( !strlen (gtk_entry_get_text ( GTK_ENTRY ( reconcile_name_entry ) ) ) )
{
string = make_red ( _("Please give a name to the new reconciliation.") );
gtk_label_set_markup ( GTK_LABEL ( label) , string );
gtk_widget_grab_focus ( reconcile_name_entry );
g_free ( string );
return FALSE;
}
/* check if already exist the name */
if ( gsb_data_reconcile_get_number_by_name (
gtk_entry_get_text (GTK_ENTRY (reconcile_name_entry) ) ) )
{
string = make_red ( _("That name already exists, please find another one.") );
gtk_label_set_markup ( GTK_LABEL ( label) , string );
gtk_widget_grab_focus ( reconcile_name_entry );
g_free ( string );
return FALSE;
}
/* ok, now we can create the reconcile */
reconcile_number = gsb_data_reconcile_new (
gtk_entry_get_text ( GTK_ENTRY ( reconcile_name_entry ) ) );
if ( !reconcile_number )
if (gsb_data_reconcile_get_number_by_name ( gtk_entry_get_text (
GTK_ENTRY ( reconcile_name_entry ) ) ) )
{
string = make_red ( _("Cannot allocate memory : Bad things will happen soon.") );
gtk_label_set_markup ( GTK_LABEL ( label) , string );
gtk_widget_grab_focus ( reconcile_name_entry );
g_free ( string );
return FALSE;
}
gsb_data_reconcile_set_init_date ( reconcile_number,
gsb_calendar_entry_get_date ( reconcile_init_date_entry ) );
gsb_data_reconcile_set_final_date ( reconcile_number,
gsb_calendar_entry_get_date ( reconcile_final_date_entry ) );
gsb_data_reconcile_set_init_balance ( reconcile_number,
utils_real_get_from_string ( gtk_entry_get_text (
GTK_ENTRY (reconcile_init_balance_entry ) ) ) );
gsb_data_reconcile_set_final_balance ( reconcile_number,
utils_real_get_from_string ( gtk_entry_get_text (
GTK_ENTRY ( reconcile_final_balance_entry ) ) ) );
gsb_data_reconcile_set_account ( reconcile_number,
gsb_account_get_combo_account_number ( reconcile_account_button ) );
/* erase the entries but not the account wich can be used again */
gtk_entry_set_text ( GTK_ENTRY (reconcile_name_entry), "" );
gtk_entry_set_text ( GTK_ENTRY (reconcile_init_date_entry), "" );
gtk_entry_set_text ( GTK_ENTRY (reconcile_final_date_entry), "" );
gtk_entry_set_text ( GTK_ENTRY (reconcile_init_balance_entry), "" );
gtk_entry_set_text ( GTK_ENTRY (reconcile_final_balance_entry), "" );
string = make_blue ( g_strdup_printf ( _("Reconciliation %s successfully appended!"),
gsb_data_reconcile_get_name ( reconcile_number ) ) );
gtk_label_set_markup ( GTK_LABEL ( label ), string );
g_free ( string );
/* update the list of reconcile in the configuration list */
gsb_reconcile_config_fill ( );
gtk_widget_grab_focus ( reconcile_name_entry );
return FALSE;
}
/**
* callback called by the button to launch the automatic association
* between transactions and reconcile
*
* \param button
* \param assistant
*
* \return FALSE
* */
static gboolean gsb_assistant_reconcile_config_lauch_manu_asso ( GtkWidget *button,
GtkWidget *assistant )
{
GList *tmp_list;
GtkTreeIter iter;
GtkTreeModel *model;
GtkTreeSelection *selection;
GList *path_list;
gint account_number = -1;
GtkWidget *dialog;
GtkWidget *label;
GtkWidget *scrolled_window;
GtkWidget *dialog_tree_view;
GtkListStore *dialog_store;
gint return_value;
gint i;
enum dialog_column {
DIALOG_NAME = 0,
DIALOG_INIT_DATE,
DIALOG_FINAL_DATE,
DIALOG_RECONCILE_NUMBER,
DIALOG_NB_COL
};
gint selected_reconcile_number;
gint transaction_number;
/* get the selection */
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview_transactions_to_link));
/* get the selected transactions */
path_list = gtk_tree_selection_get_selected_rows ( GTK_TREE_SELECTION (selection),
&model );
if (!path_list)
return FALSE;
/* ok, we have a selection, before continuing,
* we check that all the transactions are on the same account */
tmp_list = path_list;
while (tmp_list)
{
GtkTreePath *path;
path = tmp_list -> data;
if (gtk_tree_model_get_iter ( GTK_TREE_MODEL (model),
&iter,
path ))
{
gtk_tree_model_get ( GTK_TREE_MODEL (model),
&iter,
TRANSACTION_NUMBER, &transaction_number,
-1 );
if (account_number == -1)
account_number = gsb_data_transaction_get_account_number (transaction_number);
else
{
if (gsb_data_transaction_get_account_number (transaction_number) != account_number)
{
dialogue_error (_("All the selected transactions have to belong to the same account !"));
/* erase the path_list */
g_list_foreach (path_list, (GFunc) gtk_tree_path_free, NULL);
g_list_free (path_list);
return FALSE;
}
}
}
tmp_list = tmp_list -> next;
}
if (account_number == -1)
{
/* erase the path_list */
g_list_foreach (path_list, (GFunc) gtk_tree_path_free, NULL);
g_list_free (path_list);
return FALSE;
}
/* ok, all the transactions belong to the same account, we can
* show a dialog to select the reconcile */
dialog = gtk_dialog_new_with_buttons ( _("Selection of a reconciliation"),
GTK_WINDOW ( assistant ),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
"gtk-cancel", GTK_RESPONSE_CANCEL,
"gtk-ok", GTK_RESPONSE_OK,
NULL );
gtk_window_set_default_size ( GTK_WINDOW ( dialog ), 770, 412 );
gtk_window_set_position ( GTK_WINDOW ( dialog ), GTK_WIN_POS_CENTER_ON_PARENT );
gtk_window_set_resizable ( GTK_WINDOW ( dialog ), TRUE );
gtk_container_set_border_width ( GTK_CONTAINER ( dialog ), 12 );
label = gtk_label_new ( _("Select the reconciliation to associate to the selected transactions: ") );
gtk_misc_set_alignment ( GTK_MISC ( label ), 0.0, 0.0 );
gtk_box_pack_start ( GTK_BOX ( dialog_get_content_area ( dialog ) ),
label,
FALSE, FALSE,
10 );
/* make the list */
scrolled_window = gtk_scrolled_window_new (FALSE, FALSE);
gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC );
gtk_box_pack_start ( GTK_BOX ( dialog_get_content_area ( dialog ) ),
scrolled_window,
TRUE, TRUE,
0 );
dialog_store = gtk_list_store_new ( DIALOG_NB_COL,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_INT );
dialog_tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (dialog_store));
g_object_unref (G_OBJECT(dialog_store));
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (dialog_tree_view), TRUE);
gtk_container_add ( GTK_CONTAINER (scrolled_window),
dialog_tree_view );
/* set the columns */
for (i=DIALOG_NAME ; i<DIALOG_RECONCILE_NUMBER ; i++)
{
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
gchar *titles[] = {
_("Reconciliation reference"), _("Initial date"), _("Final date")
};
gfloat alignment[] = {
COLUMN_LEFT, COLUMN_CENTER, COLUMN_CENTER
};
cell = gtk_cell_renderer_text_new ();
g_object_set ( G_OBJECT (cell),
"xalign", alignment[i],
NULL );
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_sizing ( column,
GTK_TREE_VIEW_COLUMN_AUTOSIZE );
gtk_tree_view_column_set_alignment ( column,
alignment[i] );
gtk_tree_view_column_pack_start ( column, cell, TRUE );
gtk_tree_view_column_set_title ( column, titles[i] );
gtk_tree_view_column_set_attributes (column, cell,
"text", i,
NULL);
gtk_tree_view_column_set_expand ( column, TRUE );
gtk_tree_view_column_set_resizable ( column,
TRUE );
gtk_tree_view_append_column ( GTK_TREE_VIEW(dialog_tree_view), column);
}
/* fill the tree view */
tmp_list = gsb_data_reconcile_get_reconcile_list ();
while (tmp_list)
{
gint reconcile_number;
reconcile_number = gsb_data_reconcile_get_no_reconcile (tmp_list -> data);
if (gsb_data_reconcile_get_account (reconcile_number) == account_number)
{
gchar *init_date_str;
gchar *final_date_str;
init_date_str = gsb_format_gdate (gsb_data_reconcile_get_init_date (reconcile_number));
final_date_str = gsb_format_gdate (gsb_data_reconcile_get_final_date (reconcile_number));
gtk_list_store_append ( GTK_LIST_STORE (dialog_store),
&iter );
gtk_list_store_set ( GTK_LIST_STORE (dialog_store),
&iter,
DIALOG_NAME, gsb_data_reconcile_get_name (reconcile_number),
DIALOG_INIT_DATE, init_date_str,
DIALOG_FINAL_DATE, final_date_str,
DIALOG_RECONCILE_NUMBER, reconcile_number,
-1 );
g_free (init_date_str);
g_free (final_date_str);
}
tmp_list = tmp_list -> next;
}
gtk_widget_show_all (dialog);
/* launch the dialog */
return_value = gtk_dialog_run (GTK_DIALOG (dialog));
if (return_value != GTK_RESPONSE_OK)
{
gtk_widget_destroy (dialog);
return FALSE;
}
/* we get the selected reconcile */
if (!gtk_tree_selection_get_selected ( gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog_tree_view)),
NULL,
&iter ))
{
dialogue_warning (_("No selection found, the transactions are not modified."));
gtk_widget_destroy (dialog);
return FALSE;
}
gtk_tree_model_get ( GTK_TREE_MODEL (dialog_store),
&iter,
DIALOG_RECONCILE_NUMBER, &selected_reconcile_number,
-1 );
/* ok we have the reconcile number, we can destroy the dialog */
gtk_widget_destroy (dialog);
/* and now, fill the selected transactions with that reconcile number */
tmp_list = g_list_last (path_list);
while (tmp_list)
{
GtkTreePath *path;
path = tmp_list -> data;
if (gtk_tree_model_get_iter ( GTK_TREE_MODEL (model),
&iter,
path ))
{
gtk_tree_model_get ( GTK_TREE_MODEL (model),
&iter,
TRANSACTION_NUMBER, &transaction_number,
-1 );
gtk_list_store_remove ( GTK_LIST_STORE (model),
&iter );
gsb_data_transaction_set_reconcile_number ( transaction_number,
selected_reconcile_number );
transactions_to_link--;
}
tmp_list = tmp_list -> prev;
}
/* erase the path_list */
g_list_foreach (path_list, (GFunc) gtk_tree_path_free, NULL);
g_list_free (path_list);
/* now there is 2 way :
* either transactions_to_link is 0, we go directly to the succes page
* either it's not null, and the user should create more reconciles */
if (transactions_to_link)
{
gchar *string;
/* update the labels */
string = g_strdup_printf (_("Still %d transactions to link with a reconciliation."),
transactions_to_link);
gtk_label_set_text ( GTK_LABEL (label_transactions_to_link_1),
string);
gtk_label_set_text ( GTK_LABEL (label_transactions_to_link_3),
string);
g_free (string);
gtk_widget_grab_focus (treeview_transactions_to_link);
}
else
{
/* go to the success page */
gsb_assistant_set_next ( assistant,
RECONCILE_ASSISTANT_MANUALLY_ASSOCIATE,
RECONCILE_ASSISTANT_SUCCESS );
gsb_assistant_next_page (assistant);
}
return FALSE;
}
/**
* export a transaction given in param in the file given in param
*
* \param transaction_number
* \param csv_file
* \param print_balance will set a balance for each transaction in the csv file
* not set for archive export, set (but usefull ?) for account export
*
* \return TRUE ok, FALSE problem
* */
static gboolean gsb_csv_export_transaction ( gint transaction_number,
FILE *csv_file,
gboolean print_balance )
{
gsb_real amount;
gint return_exponent;
gint account_number;
gchar* tmpstr;
const GDate *value_date, *date;
gint payment_method;
account_number = gsb_data_transaction_get_account_number (transaction_number);
/* Si c'est une ventilation d'opération (càd une opération fille),
elle n'est pas traitée à la base du "if" mais plus loin, quand
son opé ventilée sera exportée */
if ( gsb_data_transaction_get_mother_transaction_number (transaction_number) )
return TRUE;
return_exponent = gsb_data_currency_get_floating_point (
gsb_data_account_get_currency (account_number));
/* met la date */
date = gsb_data_transaction_get_date ( transaction_number );
if ( date )
{
CSV_CLEAR_FIELD (csv_field_date);
csv_field_date = g_strdup_printf ("%d/%d/%d",
g_date_get_day ( date ),
g_date_get_month ( date ),
g_date_get_year ( date ) );
}
value_date = gsb_data_transaction_get_value_date ( transaction_number );
if ( value_date )
{
CSV_CLEAR_FIELD (csv_field_date_val);
csv_field_date_val = g_strdup_printf ("%d/%d/%d",
g_date_get_day ( value_date ),
g_date_get_month ( value_date ),
g_date_get_year ( value_date ) );
}
/* met le pointage */
CSV_CLEAR_FIELD (csv_field_pointage);
switch ( gsb_data_transaction_get_marked_transaction ( transaction_number ) )
{
case OPERATION_NORMALE:
csv_field_pointage = my_strdup ("");
break;
case OPERATION_POINTEE:
csv_field_pointage = my_strdup ("P");
break;
case OPERATION_TELERAPPROCHEE:
csv_field_pointage = my_strdup ("T");
break;
case OPERATION_RAPPROCHEE:
csv_field_pointage = my_strdup ("R");
break;
}
/* met les notes */
CSV_CLEAR_FIELD(csv_field_notes);
if ( gsb_data_transaction_get_notes ( transaction_number ) )
csv_field_notes = my_strdup (gsb_data_transaction_get_notes ( transaction_number ));
/* met le tiers */
CSV_CLEAR_FIELD(csv_field_tiers);
csv_field_tiers = g_strdup ( gsb_data_payee_get_name ( gsb_data_transaction_get_party_number ( transaction_number ), FALSE ) );
/* met le numero du rapprochement */
if ( gsb_data_transaction_get_reconcile_number ( transaction_number ) )
{
CSV_CLEAR_FIELD (csv_field_rappro);
csv_field_rappro = my_strdup ( gsb_data_reconcile_get_name ( gsb_data_transaction_get_reconcile_number ( transaction_number ) ) );
}
/* Met les informations bancaires de l'opération. Elles n'existent
qu'au niveau de l'opération mère */
CSV_CLEAR_FIELD(csv_field_info_bank);
if ( gsb_data_transaction_get_bank_references ( transaction_number ) )
{
csv_field_info_bank = my_strdup ( gsb_data_transaction_get_bank_references ( transaction_number ) );
}
/* met le montant, transforme la devise si necessaire */
amount = gsb_data_transaction_get_adjusted_amount ( transaction_number,
return_exponent);
CSV_CLEAR_FIELD (csv_field_credit);
if (amount.mantissa >= 0 )
csv_field_credit = utils_real_get_string (amount);
else
csv_field_debit = utils_real_get_string (gsb_real_abs (amount));
/* met le cheque si c'est un type à numerotation automatique */
payment_method = gsb_data_transaction_get_method_of_payment_number ( transaction_number );
CSV_CLEAR_FIELD (csv_field_cheque);
if (gsb_data_payment_get_automatic_numbering (payment_method))
csv_field_cheque = my_strdup ( gsb_data_transaction_get_method_of_payment_content ( transaction_number ) );
if ( gsb_data_transaction_get_budgetary_number ( transaction_number ) != -1 )
{
CSV_CLEAR_FIELD (csv_field_imput);
csv_field_imput = my_strdup ( gsb_data_budget_get_name ( gsb_data_transaction_get_budgetary_number ( transaction_number ), 0, "" ) );
if ( gsb_data_transaction_get_sub_budgetary_number ( transaction_number ) != -1 )
{
CSV_CLEAR_FIELD (csv_field_sous_imput);
csv_field_sous_imput = my_strdup ( gsb_data_budget_get_sub_budget_name ( gsb_data_transaction_get_budgetary_number ( transaction_number ),
gsb_data_transaction_get_sub_budgetary_number ( transaction_number ),
NULL ) );
}
}
/* Piece comptable */
CSV_CLEAR_FIELD (csv_field_piece);
csv_field_piece = my_strdup ( gsb_data_transaction_get_voucher ( transaction_number ) );
/* Balance */
if (print_balance)
{
current_balance = gsb_real_add ( current_balance,
amount );
CSV_CLEAR_FIELD (csv_field_solde);
csv_field_solde = utils_real_get_string (current_balance);
}
/* Number */
CSV_CLEAR_FIELD (csv_field_operation);
csv_field_operation = g_strdup_printf("%d", transaction_number );
/* Account name */
CSV_CLEAR_FIELD (csv_field_account);
csv_field_account = my_strdup (gsb_data_account_get_name (account_number));
/* Financial Year */
if ( gsb_data_transaction_get_financial_year_number ( transaction_number ) != -1 )
{
CSV_CLEAR_FIELD (csv_field_exercice );
csv_field_exercice = my_strdup (gsb_data_fyear_get_name(gsb_data_transaction_get_financial_year_number ( transaction_number )));
}
/* on met soit un virement, soit une ventilation, soit les catégories */
/* Si c'est une opération ventilée, on recherche toutes les ventilations
de cette opération et on les traite immédiatement. */
/* et les met à la suite */
/* la catégorie de l'opé sera celle de la première opé de ventilation */
if ( gsb_data_transaction_get_split_of_transaction ( transaction_number ) )
{
GSList *pSplitTransactionList;
CSV_CLEAR_FIELD (csv_field_categ);
csv_field_categ = my_strdup (_("Split of transaction"));
csv_add_record(csv_file,FALSE, print_balance);
pSplitTransactionList = gsb_data_transaction_get_transactions_list ();
while ( pSplitTransactionList )
{
gint pSplitTransaction;
pSplitTransaction = gsb_data_transaction_get_transaction_number (
pSplitTransactionList -> data );
if ( gsb_data_transaction_get_account_number (
pSplitTransaction ) == gsb_data_transaction_get_account_number (transaction_number)
&&
gsb_data_transaction_get_mother_transaction_number (
pSplitTransaction ) == transaction_number )
{
/* on commence par mettre la catég et sous categ de l'opé et de l'opé de ventilation */
CSV_CLEAR_FIELD (csv_field_ventil);
csv_field_ventil = my_strdup (_("B")); /* -> mark */
CSV_CLEAR_FIELD (csv_field_operation);
csv_field_operation = g_strdup_printf("%d", pSplitTransaction );
if ( gsb_data_transaction_get_contra_transaction_number ( pSplitTransaction ) > 0)
{
/* c'est un virement */
CSV_CLEAR_FIELD (csv_field_categ);
csv_field_categ = my_strdup (_("Transfer"));
tmpstr = g_strconcat ( "[", gsb_data_account_get_name ( gsb_data_transaction_get_contra_transaction_account ( pSplitTransaction ) ), "]", NULL );
/* TODO dOm : is it necessary to duplicate memory with my_strdup since it was already newly allocated memory ? */
CSV_CLEAR_FIELD (csv_field_sous_categ);
csv_field_sous_categ = my_strdup (tmpstr);
g_free ( tmpstr );
}
else
{
if ( gsb_data_transaction_get_category_number ( pSplitTransaction ) != -1 )
{
CSV_CLEAR_FIELD (csv_field_categ);
csv_field_categ = my_strdup ( gsb_data_category_get_name ( gsb_data_transaction_get_category_number ( pSplitTransaction ), 0, "" ) );
if ( gsb_data_transaction_get_sub_category_number ( pSplitTransaction ) != -1 )
{
CSV_CLEAR_FIELD (csv_field_sous_categ);
csv_field_sous_categ = my_strdup ( gsb_data_category_get_sub_category_name ( gsb_data_transaction_get_category_number ( pSplitTransaction ),
gsb_data_transaction_get_sub_category_number ( pSplitTransaction ),
NULL ) );
}
}
}
/* met les notes de la ventilation */
if ( gsb_data_transaction_get_notes ( pSplitTransaction ) )
{
CSV_CLEAR_FIELD (csv_field_notes);
csv_field_notes = my_strdup (gsb_data_transaction_get_notes ( pSplitTransaction ));
}
/* met le montant de la ventilation */
amount = gsb_data_transaction_get_adjusted_amount ( pSplitTransaction, return_exponent );
CSV_CLEAR_FIELD (csv_field_montant);
csv_field_montant = utils_real_get_string (amount);
/* met le rapprochement */
if ( gsb_data_transaction_get_reconcile_number ( pSplitTransaction ) )
{
CSV_CLEAR_FIELD (csv_field_rappro);
csv_field_rappro = my_strdup ( gsb_data_reconcile_get_name ( gsb_data_transaction_get_reconcile_number ( pSplitTransaction ) ) );
}
/* met le chèque si c'est un type à numéotation automatique */
payment_method = gsb_data_transaction_get_method_of_payment_number ( pSplitTransaction );
if (gsb_data_payment_get_automatic_numbering (payment_method))
{
CSV_CLEAR_FIELD (csv_field_cheque);
csv_field_cheque = my_strdup ( gsb_data_transaction_get_method_of_payment_content ( pSplitTransaction ) );
}
/* Budgetary lines */
if ( gsb_data_transaction_get_budgetary_number ( pSplitTransaction ) != -1 )
{
CSV_CLEAR_FIELD (csv_field_imput);
csv_field_imput = my_strdup ( gsb_data_budget_get_name ( gsb_data_transaction_get_budgetary_number ( pSplitTransaction ), 0, "" ) );
if ( gsb_data_transaction_get_sub_budgetary_number ( pSplitTransaction ) != -1 )
{
CSV_CLEAR_FIELD (csv_field_sous_imput);
csv_field_sous_imput = my_strdup ( gsb_data_budget_get_sub_budget_name ( gsb_data_transaction_get_budgetary_number ( pSplitTransaction ),
gsb_data_transaction_get_sub_budgetary_number ( pSplitTransaction ),
NULL ) );
}
}
/* Piece comptable */
CSV_CLEAR_FIELD (csv_field_piece);
csv_field_piece = my_strdup ( gsb_data_transaction_get_voucher ( pSplitTransaction ) );
/* Financial Year */
if ( gsb_data_transaction_get_financial_year_number ( pSplitTransaction ) != -1 )
{
CSV_CLEAR_FIELD (csv_field_exercice );
csv_field_exercice = my_strdup (gsb_data_fyear_get_name(gsb_data_transaction_get_financial_year_number ( pSplitTransaction )));
}
csv_add_record(csv_file,FALSE, print_balance);
}
pSplitTransactionList = pSplitTransactionList -> next;
}
csv_clear_fields(TRUE);
}
else
{
gchar *tmpstr;
gint contra_transaction_number = gsb_data_transaction_get_contra_transaction_number ( transaction_number );
switch (contra_transaction_number)
{
case 0:
/* normal category */
if ( gsb_data_transaction_get_category_number ( transaction_number ) != -1 )
{
CSV_CLEAR_FIELD (csv_field_categ);
csv_field_categ = my_strdup ( gsb_data_category_get_name ( gsb_data_transaction_get_category_number ( transaction_number ), 0, "" ) );
if ( gsb_data_transaction_get_sub_category_number ( transaction_number ) != -1 )
{
CSV_CLEAR_FIELD (csv_field_sous_categ);
csv_field_sous_categ = my_strdup ( gsb_data_category_get_sub_category_name ( gsb_data_transaction_get_category_number ( transaction_number ),
gsb_data_transaction_get_sub_category_number ( transaction_number ),
NULL ) );
}
}
break;
case -1:
/* transfer to deleted account */
CSV_CLEAR_FIELD (csv_field_categ);
csv_field_categ = my_strdup (_("Transfer"));
tmpstr = g_strconcat ( "[", _("Deleted account"), "]", NULL );
/* TODO dOm : is it necessary to duplicate memory with my_strdup since it was already newly allocated memory ? */
CSV_CLEAR_FIELD (csv_field_sous_categ);
csv_field_sous_categ = my_strdup (tmpstr);
g_free ( tmpstr );
break;
default:
/* transfer */
CSV_CLEAR_FIELD (csv_field_categ);
csv_field_categ = my_strdup (_("Transfer"));
tmpstr = g_strconcat ( "[", gsb_data_account_get_name ( gsb_data_transaction_get_contra_transaction_account ( transaction_number ) ), "]", NULL );
/* TODO dOm : is it necessary to duplicate memory with my_strdup since it was already newly allocated memory ? */
CSV_CLEAR_FIELD (csv_field_sous_categ);
csv_field_sous_categ = my_strdup (tmpstr);
g_free ( tmpstr );
}
csv_add_record(csv_file,TRUE, print_balance);
}
return TRUE;
}
/**
* fill the reconcile list,
* sort each reconcile in its account
*
* \param
*
* \return
* */
void gsb_reconcile_config_fill ( void )
{
GtkTreeModel *model;
GSList *tmp_list;
GrisbiWinEtat *w_etat;
if (!reconcile_treeview)
return;
w_etat = (GrisbiWinEtat *) grisbi_win_get_w_etat ();
model = gtk_tree_view_get_model ( GTK_TREE_VIEW (reconcile_treeview));
gtk_tree_store_clear (GTK_TREE_STORE(model));
/* we make a tree_model containing the accounts,
* and for each account, all the reconciles */
tmp_list = gsb_data_account_get_list_accounts ();
while (tmp_list)
{
gint account_number;
GtkTreeIter account_iter;
GList *reconcile_list;
account_number = gsb_data_account_get_no_account (tmp_list -> data);
gtk_tree_store_append ( GTK_TREE_STORE (model),
&account_iter,
NULL );
gtk_tree_store_set ( GTK_TREE_STORE (model),
&account_iter,
RECONCILIATION_NAME_COLUMN, gsb_data_account_get_name (account_number),
RECONCILIATION_WEIGHT_COLUMN, 800,
RECONCILIATION_ACCOUNT_COLUMN, account_number,
-1 );
/* for each account, get the concerned reconciles */
reconcile_list = gsb_data_reconcile_get_sort_reconcile_list (account_number);
if (w_etat->reconcile_sort)
reconcile_list = g_list_reverse (reconcile_list);
while (reconcile_list)
{
gint reconcile_number;
reconcile_number = GPOINTER_TO_INT (reconcile_list->data);
if (gsb_data_reconcile_get_account (reconcile_number) == account_number)
{
GtkTreeIter reconcile_iter;
gchar *init_date, *final_date;
gchar *init_balance, *final_balance;
init_date = gsb_format_gdate (gsb_data_reconcile_get_init_date (reconcile_number));
final_date = gsb_format_gdate (gsb_data_reconcile_get_final_date (reconcile_number));
init_balance = utils_real_get_string (gsb_data_reconcile_get_init_balance (reconcile_number));
final_balance = utils_real_get_string (gsb_data_reconcile_get_final_balance (reconcile_number));
gtk_tree_store_append ( GTK_TREE_STORE (model),
&reconcile_iter,
&account_iter );
gtk_tree_store_set ( GTK_TREE_STORE (model),
&reconcile_iter,
RECONCILIATION_NAME_COLUMN, gsb_data_reconcile_get_name (reconcile_number),
RECONCILIATION_WEIGHT_COLUMN, 400,
RECONCILIATION_INIT_DATE_COLUMN, init_date,
RECONCILIATION_FINAL_DATE_COLUMN, final_date,
RECONCILIATION_INIT_BALANCE_COLUMN, init_balance,
RECONCILIATION_FINAL_BALANCE_COLUMN, final_balance,
RECONCILIATION_RECONCILE_COLUMN, reconcile_number,
RECONCILIATION_ACCOUNT_COLUMN, account_number,
-1 );
g_free (init_date);
g_free (final_date);
g_free (init_balance);
g_free (final_balance);
}
reconcile_list = reconcile_list -> next;
}
tmp_list = tmp_list -> next;
}
}
