/* HomeBank -- Free, easy, personal accounting for everyone.
* Copyright (C) 1995-2019 Maxime DOYEN
*
* This file is part of HomeBank.
*
* HomeBank is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* HomeBank is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#include "homebank.h"
#include "hb-category.h"
/****************************************************************************/
/* Debug macros */
/****************************************************************************/
#define MYDEBUG 0
#if MYDEBUG
#define DB(x) (x);
#else
#define DB(x);
#endif
/* our global datas */
extern struct HomeBank *GLOBALS;
/* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
Category *
da_cat_clone(Category *src_item)
{
Category *new_item = g_memdup(src_item, sizeof(Category));
DB( g_print("da_cat_clone\n") );
if(new_item)
{
//duplicate the string
new_item->name = g_strdup(src_item->name);
new_item->fullname = g_strdup(src_item->fullname);
}
return new_item;
}
void
da_cat_free(Category *item)
{
DB( g_print("da_cat_free\n") );
if(item != NULL)
{
DB( g_print(" => %d, %s\n", item->key, item->name) );
g_free(item->name);
g_free(item->fullname);
g_free(item);
}
}
Category *
da_cat_malloc(void)
{
DB( g_print("da_cat_malloc\n") );
return g_malloc0(sizeof(Category));
}
void
da_cat_destroy(void)
{
DB( g_print("da_cat_destroy\n") );
g_hash_table_destroy(GLOBALS->h_cat);
}
void
da_cat_new(void)
{
Category *item;
DB( g_print("da_cat_new\n") );
GLOBALS->h_cat = g_hash_table_new_full(g_int_hash, g_int_equal, (GDestroyNotify)g_free, (GDestroyNotify)da_cat_free);
// insert our 'no category'
item = da_cat_malloc();
item->key = 0;
item->name = g_strdup("");
item->fullname = g_strdup("");
da_cat_insert(item);
}
/* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
/**
* da_cat_length:
*
* Return value: the number of elements
*/
guint
da_cat_length(void)
{
return g_hash_table_size(GLOBALS->h_cat);
}
static void
da_cat_max_key_ghfunc(gpointer key, Category *cat, guint32 *max_key)
{
*max_key = MAX(*max_key, cat->key);
}
/**
* da_cat_get_max_key:
*
* Get the biggest key from the GHashTable
*
* Return value: the biggest key value
*
*/
guint32
da_cat_get_max_key(void)
{
guint32 max_key = 0;
g_hash_table_foreach(GLOBALS->h_cat, (GHFunc)da_cat_max_key_ghfunc, &max_key);
return max_key;
}
static gboolean
da_cat_remove_grfunc(gpointer key, Category *cat, guint32 *remkey)
{
if(cat->key == *remkey || cat->parent == *remkey)
return TRUE;
return FALSE;
}
/**
* da_cat_remove:
*
* delete a category from the GHashTable
*
* Return value: TRUE if the key was found and deleted
*
*/
guint
da_cat_remove(guint32 key)
{
DB( g_print("\nda_cat_remove %d\n", key) );
return g_hash_table_foreach_remove(GLOBALS->h_cat, (GHRFunc)da_cat_remove_grfunc, &key);
}
static void
da_cat_build_fullname(Category *item)
{
Category *parent;
g_free(item->fullname);
if( item->parent == 0 )
item->fullname = g_strdup(item->name);
else
{
parent = da_cat_get(item->parent);
if( parent != NULL )
item->fullname = g_strconcat(parent->name, ":", item->name, NULL);
}
DB( g_print("- updated %d:'%s' fullname='%s'\n", item->key, item->name, item->fullname) );
}
static void
da_cat_rename(Category *item, gchar *newname)
{
DB( g_print("- renaming %s' => '%s'\n", item->name, newname) );
g_free(item->name);
item->name = g_strdup(newname);
da_cat_build_fullname(item);
if( item->parent == 0 )
{
GHashTableIter iter;
gpointer value;
DB( g_print("- updating subcat fullname\n") );
g_hash_table_iter_init (&iter, GLOBALS->h_cat);
while (g_hash_table_iter_next (&iter, NULL, &value))
{
Category *subcat = value;
if( subcat->parent == item->key )
da_cat_build_fullname(subcat);
}
}
}
/**
* da_cat_insert:
*
* insert a category into the GHashTable
*
* Return value: TRUE if inserted
*
*/
gboolean
da_cat_insert(Category *item)
{
guint32 *new_key;
DB( g_print("\nda_cat_insert\n") );
DB( g_print("- '%s'\n", item->name) );
new_key = g_new0(guint32, 1);
*new_key = item->key;
g_hash_table_insert(GLOBALS->h_cat, new_key, item);
da_cat_build_fullname(item);
return TRUE;
}
/**
* da_cat_append:
*
* append a category into the GHashTable
*
* Return value: TRUE if inserted
*
*/
// used only to add cat/subcat from ui_category with the 2 inputs
gboolean
da_cat_append(Category *cat)
{
Category *existitem;
DB( g_print("\nda_cat_append\n") );
if( !cat->fullname )
da_cat_build_fullname(cat);
existitem = da_cat_get_by_fullname( cat->fullname );
if( existitem == NULL )
{
cat->key = da_cat_get_max_key() + 1;
da_cat_insert(cat);
return TRUE;
}
DB( g_print(" -> %s already exist\n", cat->name) );
return FALSE;
}
/* fullname i.e. car:refuel */
struct fullcatcontext
{
guint32 parent;
gchar *name;
};
static gboolean
da_cat_fullname_grfunc(gpointer key, Category *item, struct fullcatcontext *ctx)
{
//DB( g_print("'%s' == '%s'\n", ctx->name, item->name) );
if( item->parent == ctx->parent )
{
if( ctx->name && item->name )
if(!strcasecmp(ctx->name, item->name))
return TRUE;
}
return FALSE;
}
static Category *da_cat_get_by_name_find_internal(guint32 parent, gchar *name)
{
struct fullcatcontext ctx;
ctx.parent = parent;
ctx.name = name;
DB( g_print("- searching %s %d '%s'\n", (parent == 0) ? "lv1cat" : "lv2cat", parent, name) );
return g_hash_table_find(GLOBALS->h_cat, (GHRFunc)da_cat_fullname_grfunc, &ctx);
}
static gchar **da_cat_get_by_fullname_split_clean(gchar *rawfullname, guint *outlen)
{
gchar **partstr = g_strsplit(rawfullname, ":", 2);
guint len = g_strv_length(partstr);
gboolean valid = TRUE;
DB( g_print("- spliclean '%s' - %d parts\n", rawfullname, g_strv_length(partstr)) );
if( outlen != NULL )
*outlen = len;
if(len >= 1)
{
g_strstrip(partstr[0]);
if( strlen(partstr[0]) == 0 )
valid = FALSE;
if(len == 2)
{
g_strstrip(partstr[1]);
if( strlen(partstr[1]) == 0 )
valid = FALSE;
}
}
if(valid == TRUE)
return partstr;
DB( g_print("- is invalid\n") );
g_strfreev(partstr);
return NULL;
}
Category *
da_cat_get_by_fullname(gchar *rawfullname)
{
gchar **partstr;
Category *parent = NULL;
Category *retval = NULL;
guint len;
DB( g_print("\nda_cat_get_by_fullname\n") );
if( rawfullname )
{
if( (partstr = da_cat_get_by_fullname_split_clean(rawfullname, &len)) != NULL )
{
if( len >= 1 )
{
parent = da_cat_get_by_name_find_internal(0, partstr[0]);
retval = parent;
}
if( len == 2 && parent != NULL )
{
retval = da_cat_get_by_name_find_internal(parent->key, partstr[1]);
}
g_strfreev(partstr);
}
}
return retval;
}
/**
* da_cat_append_ifnew_by_fullname:
*
* append a category if it is new by fullname
*
* Return value:
*
*/
Category *
da_cat_append_ifnew_by_fullname(gchar *rawfullname)
{
gchar **partstr;
Category *parent = NULL;
Category *newcat = NULL;
Category *retval = NULL;
guint len;
DB( g_print("\nda_cat_append_ifnew_by_fullname\n") );
if( rawfullname )
{
if( (partstr = da_cat_get_by_fullname_split_clean(rawfullname, &len)) != NULL )
{
if( len >= 1 )
{
parent = da_cat_get_by_name_find_internal(0, partstr[0]);
if( parent == NULL )
{
parent = da_cat_malloc();
parent->key = da_cat_get_max_key() + 1;
parent->name = g_strdup(partstr[0]);
da_cat_insert(parent);
}
retval = parent;
}
/* if we have a subcategory - xxx:xxx */
if( len == 2 && parent != NULL )
{
newcat = da_cat_get_by_name_find_internal(parent->key, partstr[1]);
if( newcat == NULL )
{
newcat = da_cat_malloc();
newcat->key = da_cat_get_max_key() + 1;
newcat->parent = parent->key;
newcat->name = g_strdup(partstr[1]);
newcat->flags |= GF_SUB;
//#1713413 take parent type into account
if(parent->flags & GF_INCOME)
newcat->flags |= GF_INCOME;
da_cat_insert(newcat);
}
retval = newcat;
}
g_strfreev(partstr);
}
}
return retval;
}
/**
* da_cat_get:
*
* Get a category structure by key
*
* Return value: Category * or NULL if not found
*
*/
Category *
da_cat_get(guint32 key)
{
//DB( g_print("da_cat_get\n") );
return g_hash_table_lookup(GLOBALS->h_cat, &key);
}
gchar *da_cat_get_name(Category *item)
{
gchar *name = NULL;
if(item != NULL)
{
name = item->key == 0 ? _("(no category)") : item->fullname;
}
return name;
}
void da_cat_consistency(Category *item)
{
gboolean isIncome;
if((item->flags & GF_SUB) && item->key > 0)
{
//check for existing parent
if( da_cat_get(item->parent) == NULL )
{
Category *parent = da_cat_append_ifnew_by_fullname ("orphaned");
item->parent = parent->key;
da_cat_build_fullname(item);
g_warning("category consistency: fixed missing parent %d", item->parent);
}
}
// ensure type equal for categories and its children
if(!(item->flags & GF_SUB) && item->key > 0)
{
isIncome = (item->flags & GF_INCOME) ? TRUE : FALSE;
if( category_change_type(item, isIncome) > 0 )
{
g_warning("category consistency: fixed type for child");
GLOBALS->changes_count++;
}
}
if( item->name != NULL )
g_strstrip(item->name);
else
{
item->name = g_strdup("void");
da_cat_build_fullname(item);
g_warning("category consistency: fixed null name");
GLOBALS->changes_count++;
}
}
/* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
#if MYDEBUG
static void
da_cat_debug_list_ghfunc(gpointer key, gpointer value, gpointer user_data)
{
guint32 *id = key;
Category *cat = value;
DB( g_print(" %d :: %s (parent=%d\n", *id, cat->name, cat->parent) );
}
static void
da_cat_debug_list(void)
{
DB( g_print("\n** debug **\n") );
g_hash_table_foreach(GLOBALS->h_cat, da_cat_debug_list_ghfunc, NULL);
DB( g_print("\n** end debug **\n") );
}
#endif
/* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
guint32 category_report_id(guint32 key, gboolean subcat)
{
guint32 retval = 0;
if(subcat == FALSE)
{
Category *catentry = da_cat_get(key);
if(catentry)
retval = (catentry->flags & GF_SUB) ? catentry->parent : catentry->key;
}
else
{
retval = key;
}
//DB( g_print("- cat '%s' reportid = %d\n", catentry->name, retval) );
return retval;
}
void
category_delete_unused(void)
{
GList *lcat, *list;
lcat = list = g_hash_table_get_values(GLOBALS->h_cat);
while (list != NULL)
{
Category *entry = list->data;
if(entry->usage_count <= 0 && entry->key > 0)
da_cat_remove (entry->key);
list = g_list_next(list);
}
g_list_free(lcat);
}
static void
category_fill_usage_count(guint32 kcat)
{
Category *cat = da_cat_get (kcat);
Category *parent;
if(cat)
{
cat->usage_count++;
if( cat->parent > 0 )
{
parent = da_cat_get(cat->parent);
if( parent )
{
parent->usage_count++;
}
}
}
}
void
category_fill_usage(void)
{
GList *lcat;
GList *lst_acc, *lnk_acc;
GList *lnk_txn;
GList *lpay, *lrul, *list;
guint i, nbsplit;
lcat = list = g_hash_table_get_values(GLOBALS->h_cat);
while (list != NULL)
{
Category *entry = list->data;
entry->usage_count = 0;
list = g_list_next(list);
}
g_list_free(lcat);
lst_acc = g_hash_table_get_values(GLOBALS->h_acc);
lnk_acc = g_list_first(lst_acc);
while (lnk_acc != NULL)
{
Account *acc = lnk_acc->data;
lnk_txn = g_queue_peek_head_link(acc->txn_queue);
while (lnk_txn != NULL)
{
Transaction *txn = lnk_txn->data;
//#1689308 count split as well
if( txn->flags & OF_SPLIT )
{
nbsplit = da_splits_length(txn->splits);
for(i=0;isplits, i);
category_fill_usage_count(split->kcat);
}
}
else
category_fill_usage_count(txn->kcat);
lnk_txn = g_list_next(lnk_txn);
}
lnk_acc = g_list_next(lnk_acc);
}
g_list_free(lst_acc);
lpay = list = g_hash_table_get_values(GLOBALS->h_pay);
while (list != NULL)
{
Payee *entry = list->data;
category_fill_usage_count(entry->kcat);
list = g_list_next(list);
}
g_list_free(lpay);
list = g_list_first(GLOBALS->arc_list);
while (list != NULL)
{
Archive *entry = list->data;
//#1689308 count split as well
if( entry->flags & OF_SPLIT )
{
nbsplit = da_splits_length(entry->splits);
for(i=0;isplits, i);
category_fill_usage_count(split->kcat);
}
}
else
category_fill_usage_count(entry->kcat);
list = g_list_next(list);
}
lrul = list = g_hash_table_get_values(GLOBALS->h_rul);
while (list != NULL)
{
Assign *entry = list->data;
category_fill_usage_count(entry->kcat);
list = g_list_next(list);
}
g_list_free(lrul);
}
void
category_move(guint32 key1, guint32 key2)
{
GList *lst_acc, *lnk_acc;
GList *lnk_txn;
GList *lrul, *list;
guint i, nbsplit;
lst_acc = g_hash_table_get_values(GLOBALS->h_acc);
lnk_acc = g_list_first(lst_acc);
while (lnk_acc != NULL)
{
Account *acc = lnk_acc->data;
lnk_txn = g_queue_peek_head_link(acc->txn_queue);
while (lnk_txn != NULL)
{
Transaction *txn = lnk_txn->data;
if(txn->kcat == key1)
{
txn->kcat = key2;
txn->flags |= OF_CHANGED;
}
// move split category #1340142
nbsplit = da_splits_length(txn->splits);
for(i=0;isplits, i);
if( split->kcat == key1 )
{
split->kcat = key2;
txn->flags |= OF_CHANGED;
}
}
lnk_txn = g_list_next(lnk_txn);
}
lnk_acc = g_list_next(lnk_acc);
}
g_list_free(lst_acc);
list = g_list_first(GLOBALS->arc_list);
while (list != NULL)
{
Archive *entry = list->data;
if(entry->kcat == key1)
{
entry->kcat = key2;
}
list = g_list_next(list);
}
lrul = list = g_hash_table_get_values(GLOBALS->h_rul);
while (list != NULL)
{
Assign *entry = list->data;
if(entry->kcat == key1)
{
entry->kcat = key2;
}
list = g_list_next(list);
}
g_list_free(lrul);
}
gboolean
category_rename(Category *item, const gchar *newname)
{
Category *parent, *existitem;
gchar *fullname = NULL;
gchar *stripname;
gboolean retval;
DB( g_print("\n(category) rename\n") );
stripname = g_strdup(newname);
g_strstrip(stripname);
if( item->parent == 0)
fullname = g_strdup(stripname);
else
{
parent = da_cat_get(item->parent);
if( parent )
{
fullname = g_strdup_printf("%s:%s", parent->name, stripname);
}
}
DB( g_print(" - search: %s\n", fullname) );
existitem = da_cat_get_by_fullname( fullname );
if( existitem != NULL && existitem->key != item->key)
{
DB( g_print("- error, same name already exist with other key %d <> %d\n",existitem->key, item->key) );
retval = FALSE;
}
else
{
DB( g_print("- renaming\n") );
da_cat_rename (item, stripname);
retval = TRUE;
}
g_free(fullname);
g_free(stripname);
return retval;
}
static gint
category_glist_name_compare_func(Category *c1, Category *c2)
{
gint retval = 0;
if( c1 != NULL && c2 != NULL )
{
retval = hb_string_utf8_compare(c1->fullname, c2->fullname);
}
return retval;
}
static gint
category_glist_key_compare_func(Category *a, Category *b)
{
gint ka, kb, retval = 0;
if(a->parent == 0 && b->parent == a->key)
retval = -1;
else
if(b->parent == 0 && a->parent == b->key)
retval = 1;
else
{
ka = a->parent != 0 ? a->parent : a->key;
kb = b->parent != 0 ? b->parent : b->key;
retval = ka - kb;
}
#if MYDEBUG == 1
gchar *str;
if(retval < 0)
str = "a < b";
else
if(retval ==0)
str = "a = b";
else
if(retval > 0)
str = "a > b";
DB( g_print("compare a=%2d:%2d to b=%2d:%2d :: %d [%s]\n", a->key, a->parent, b->key, b->parent, retval, str ) );
#endif
return retval;
}
GList *
category_glist_sorted(gint column)
{
GList *list = g_hash_table_get_values(GLOBALS->h_cat);
if(column == 0)
return g_list_sort(list, (GCompareFunc)category_glist_key_compare_func);
else
return g_list_sort(list, (GCompareFunc)category_glist_name_compare_func);
}
gboolean
category_load_csv(gchar *filename, gchar **error)
{
gboolean retval;
GIOChannel *io;
gchar *tmpstr;
gint io_stat;
gchar **str_array;
gchar *lastcatname = NULL;
gchar *fullcatname;
GError *err = NULL;
Category *item;
gint type = 0;
const gchar *encoding;
encoding = homebank_file_getencoding(filename);
DB( g_print(" -> encoding should be %s\n", encoding) );
retval = TRUE;
*error = NULL;
io = g_io_channel_new_file(filename, "r", NULL);
if(io != NULL)
{
if( encoding != NULL )
{
g_io_channel_set_encoding(io, encoding, NULL);
}
for(;;)
{
if( *error != NULL )
break;
io_stat = g_io_channel_read_line(io, &tmpstr, NULL, NULL, &err);
DB( g_print(" + iostat %d\n", io_stat) );
if( io_stat == G_IO_STATUS_ERROR )
{
DB (g_print(" + ERROR %s\n",err->message));
break;
}
if( io_stat == G_IO_STATUS_EOF)
break;
if( io_stat == G_IO_STATUS_NORMAL)
{
if( tmpstr != NULL )
{
DB( g_print(" + strip %s\n", tmpstr) );
hb_string_strip_crlf(tmpstr);
DB( g_print(" + split\n") );
str_array = g_strsplit (tmpstr, ";", 3);
// type; sign; name
if( g_strv_length (str_array) != 3 )
{
*error = _("invalid CSV format");
retval = FALSE;
DB( g_print(" + error %s\n", *error) );
}
else
{
DB( g_print(" + read %s : %s : %s\n", str_array[0], str_array[1], str_array[2]) );
fullcatname = NULL;
if( g_str_has_prefix(str_array[0], "1") )
{
fullcatname = g_strdup(str_array[2]);
g_free(lastcatname);
lastcatname = g_strdup(str_array[2]);
type = g_str_has_prefix(str_array[1], "+") ? GF_INCOME : 0;
DB( g_print(" + type = %d\n", type) );
}
else
if( g_str_has_prefix(str_array[0], "2") )
{
fullcatname = g_strdup_printf("%s:%s", lastcatname, str_array[2]);
}
item = da_cat_append_ifnew_by_fullname(fullcatname);
DB( g_print(" + item %p\n", item) );
if( item != NULL)
{
DB( g_print(" + assign flags: '%c'\n", type) );
item->flags |= type;
}
g_free(fullcatname);
g_strfreev (str_array);
}
}
}
g_free(tmpstr);
}
g_io_channel_unref (io);
}
g_free(lastcatname);
return retval;
}
gboolean
category_save_csv(gchar *filename, gchar **error)
{
gboolean retval = FALSE;
GIOChannel *io;
gchar *outstr;
GList *lcat, *list;
io = g_io_channel_new_file(filename, "w", NULL);
if(io != NULL)
{
lcat = list = category_glist_sorted(1);
while (list != NULL)
{
Category *item = list->data;
if(item->key != 0)
{
gchar lvel, type;
if( item->parent == 0)
{
lvel = '1';
type = (item->flags & GF_INCOME) ? '+' : '-';
}
else
{
lvel = '2';
type = ' ';
}
outstr = g_strdup_printf("%c;%c;%s\n", lvel, type, item->name);
DB( g_print(" + export %s\n", outstr) );
g_io_channel_write_chars(io, outstr, -1, NULL, NULL);
g_free(outstr);
}
list = g_list_next(list);
}
retval = TRUE;
g_list_free(lcat);
g_io_channel_unref (io);
}
return retval;
}
gint
category_type_get(Category *item)
{
if( (item->flags & (GF_INCOME)) )
return 1;
return -1;
}
gchar
category_get_type_char(Category *item)
{
return (item->flags & GF_INCOME) ? '+' : '-';
}
static gint
category_change_type_eval(Category *item, gboolean isIncome)
{
if( (item->flags & (GF_INCOME)) && !isIncome )
return 1;
return 0;
}
gint
category_change_type(Category *item, gboolean isIncome)
{
gint changes = 0;
GList *lcat, *list;
changes += category_change_type_eval(item, isIncome);
item->flags &= ~(GF_INCOME); //delete flag
if(isIncome == TRUE)
item->flags |= GF_INCOME;
// change also childs
lcat = list = g_hash_table_get_values(GLOBALS->h_cat);
while (list != NULL)
{
Category *child = list->data;
if(child->parent == item->key)
{
changes += category_change_type_eval(child, isIncome);
child->flags &= ~(GF_INCOME); //delete flag
if(isIncome == TRUE)
child->flags |= GF_INCOME;
}
list = g_list_next(list);
}
g_list_free(lcat);
return changes;
}
/**
* category_find_preset:
*
* find a user language compatible file for category preset
*
* Return value: a pathname to the file or NULL
*
*/
gchar *
category_find_preset(gchar **lang)
{
gchar **langs;
gchar *filename;
gboolean exists;
guint i;
DB( g_print("** category_find_preset **\n") );
langs = (gchar **)g_get_language_names ();
DB( g_print(" -> %d languages detected\n", g_strv_length(langs)) );
for(i=0;i %d '%s'\n", i, langs[i]) );
filename = g_strdup_printf("hb-categories-%s.csv", langs[i]);
gchar *pathfilename = g_build_filename(homebank_app_get_datas_dir(), filename, NULL);
exists = g_file_test(pathfilename, G_FILE_TEST_EXISTS);
DB( g_print(" -> '%s' exists=%d\n", pathfilename, exists) );
if(exists)
{
g_free(filename);
*lang = langs[i];
return pathfilename;
}
g_free(filename);
g_free(pathfilename);
}
DB( g_print("return NULL\n") );
*lang = NULL;
return NULL;
}