namespace administration

1 files changed, 169 insertions, 169 deletions

diff --git a/src/administration.cpp b/src/administration.cpp
index f9770bd..1de99b4 100644
--- a/src/administration.cpp
+++ b/src/administration.cpp
@@ -27,17 +27,17 @@
 #include "administration.hpp"
 #include "administration_writer.hpp"
 
-administration g_administration;
+static ledger g_administration;
 
-data_changed_event          data_changed_event_callback = 0;
-data_deleted_event          data_deleted_event_callback = 0;
-invoice_changed_event       invoice_changed_event_callback = 0;
-contact_changed_event       contact_changed_event_callback = 0;
-taxrate_changed_event       taxrate_changed_event_callback = 0;
-costcenter_changed_event    costcenter_changed_event_callback = 0;
-project_changed_event       project_changed_event_callback = 0;
+static data_changed_event          data_changed_event_callback = 0;
+static data_deleted_event          data_deleted_event_callback = 0;
+static invoice_changed_event       invoice_changed_event_callback = 0;
+static contact_changed_event       contact_changed_event_callback = 0;
+static taxrate_changed_event       taxrate_changed_event_callback = 0;
+static costcenter_changed_event    costcenter_changed_event_callback = 0;
+static project_changed_event       project_changed_event_callback = 0;
 
-static s32 administration_create_id()
+static s32 create_id()
 {
     return g_administration.next_id;
 }
@@ -49,19 +49,19 @@ static int compare_tax_countries(const void *a, const void *b)
     return strcmp(objA->country_code, objB->country_code);
 }
 
-time_t administration_get_default_invoice_expire_duration()
+time_t administration::get_default_invoice_expire_duration()
 {
     return (30 * 24 * 60 * 60); // 30 days
 }
 
-static char* administration_get_default_currency_for_country(char* country_code);
+static char* get_default_currency_for_country(char* country_code);
 
-static void administration_create_default_tax_rates()
+static void create_default_tax_rates()
 {
     #define ADD_BRACKET(_country, _rate, _code)\
     {\
         tax_rate* tb = (tax_rate*)malloc(sizeof(tax_rate));\
-        snprintf(tb->id, sizeof(tb->id), "T/%d", administration_create_id());\
+        snprintf(tb->id, sizeof(tb->id), "T/%d", create_id());\
         memcpy(tb->country_code, _country, sizeof(tb->country_code));\
         tb->rate = _rate;\
         memcpy(tb->category_code, _code, sizeof(tb->category_code));\
@@ -219,12 +219,12 @@ static void administration_create_default_tax_rates()
     list_sort(&g_administration.tax_rates, -1);
 }
 
-static void administration_create_default_cost_centers()
+static void create_default_cost_centers()
 {
     #define ADD_COSTCENTER(_description, _code)\
     {\
         cost_center* tb = (cost_center*)malloc(sizeof(cost_center));\
-        snprintf(tb->id, sizeof(tb->id), "E/%d", administration_create_id());\
+        snprintf(tb->id, sizeof(tb->id), "E/%d", create_id());\
         memcpy(tb->description, _description, sizeof(tb->description));\
         memcpy(tb->code, _code, sizeof(tb->code));\
         list_append(&g_administration.cost_centers, tb);\
@@ -246,44 +246,44 @@ static void administration_create_default_cost_centers()
     ADD_COSTCENTER("costcenter.other_specialized", "OTHR");
 }
 
-static s32 administration_create_sequence_number()
+static s32 create_sequence_number()
 {
     return g_administration.next_sequence_number;
 }
 
 // Callback functions.
 // =======================
-void administration_set_data_changed_event_callback(data_changed_event ev)
+void administration::set_data_changed_event_callback(data_changed_event ev)
 {
     data_changed_event_callback = ev;
 }
 
-void administration_set_data_deleted_event_callback(data_deleted_event ev)
+void administration::set_data_deleted_event_callback(data_deleted_event ev)
 {
     data_deleted_event_callback = ev;
 }
 
-void administration_set_invoice_changed_event_callback(invoice_changed_event ev)
+void administration::set_invoice_changed_event_callback(invoice_changed_event ev)
 {
     invoice_changed_event_callback = ev;
 }
 
-void administration_set_contact_changed_event_callback(contact_changed_event ev)
+void administration::set_contact_changed_event_callback(contact_changed_event ev)
 {
     contact_changed_event_callback = ev;
 }
 
-void administration_set_taxrate_changed_event_callback(taxrate_changed_event ev)
+void administration::set_taxrate_changed_event_callback(taxrate_changed_event ev)
 {
     taxrate_changed_event_callback = ev;
 }
 
-void administration_set_costcenter_changed_event_callback(costcenter_changed_event ev)
+void administration::set_costcenter_changed_event_callback(costcenter_changed_event ev)
 {
     costcenter_changed_event_callback = ev;
 }
 
-void administration_set_project_changed_event_callback(project_changed_event ev)
+void administration::set_project_changed_event_callback(project_changed_event ev)
 {
     project_changed_event_callback = ev;
 }
@@ -331,7 +331,7 @@ void administration_destroy()
     administration_destroy_list(&g_administration.cost_centers);
 }
 
-void administration_create_from_file(char* save_file)
+void administration::create_from_file(char* save_file)
 {
     if (is_initialized) administration_destroy();
     administration_create();
@@ -340,7 +340,7 @@ void administration_create_from_file(char* save_file)
     strops::copy(g_administration.program_version, config::PROGRAM_VERSION, sizeof(g_administration.program_version));
 }
 
-void administration_create_empty(char* save_file)
+void administration::create_empty(char* save_file)
 {
     if (is_initialized) administration_destroy();
     administration_create();
@@ -350,61 +350,61 @@ void administration_create_empty(char* save_file)
 
     strops::copy(g_administration.path, save_file, sizeof(g_administration.path));
     strops::copy(g_administration.program_version, config::PROGRAM_VERSION, sizeof(g_administration.program_version));
-    administration_company_info_set(administration_contact_create_empty());   
+    administration::company_info_set(administration::contact_create_empty());   
 }
 
-void administration_create_default(char* save_file)
+void administration::create_default(char* save_file)
 {
-    administration_create_empty(save_file);
-    administration_create_default_tax_rates();
-    administration_create_default_cost_centers();
-    //administration_create_debug_data();
+    administration::create_empty(save_file);
+    create_default_tax_rates();
+    create_default_cost_centers();
+    //administration::create_debug_data();
 }
 
 // Other functions.
 // =======================
-ai_service administration_get_ai_service()
+ai_service administration::get_ai_service()
 {
     return g_administration.ai_service;
 }
 
-void administration_set_ai_service(ai_service provider)
+void administration::set_ai_service(ai_service provider)
 {
     g_administration.ai_service = provider;
     if (data_changed_event_callback) data_changed_event_callback();
 }
 
-void administration_set_next_id(s32 nr)
+void administration::set_next_id(s32 nr)
 {
     g_administration.next_id = nr;
 }
 
-void administration_set_next_sequence_number(s32 nr)
+void administration::set_next_sequence_number(s32 nr)
 {
     g_administration.next_sequence_number = nr;
 }
 
-s32 administration_get_next_id()
+s32 administration::get_next_id()
 {
     return g_administration.next_id;
 }
 
-s32 administration_get_next_sequence_number()
+s32 administration::get_next_sequence_number()
 {
     return g_administration.next_sequence_number;
 }
 
-bool administration_can_create_invoices()
+bool administration::can_create_invoices()
 {
-    return administration_contact_is_valid(g_administration.company_info) == A_ERR_SUCCESS;
+    return administration::contact_is_valid(g_administration.company_info) == A_ERR_SUCCESS;
 }
 
-char* administration_get_default_currency()
+char* administration::get_default_currency()
 {
     return g_administration.default_currency;
 }
 
-char* administration_get_currency_symbol_for_currency(char* code)
+char* administration::get_currency_symbol_for_currency(char* code)
 {
     // Major European currencies
     if (strcmp(code, "EUR") == 0) return "€";   // Euro
@@ -458,7 +458,7 @@ static void administration_debug_print_income_statement(income_statement* statem
             project_report pr = report.reports[x];
 
             project proj;
-            administration_project_get_by_id(&proj, pr.project_id);
+            administration::project_get_by_id(&proj, pr.project_id);
             printf("PROJECT: %s\n", proj.description);
             printf("  revenue: %.2f\n", pr.revenue);
             printf("  taxes: %.2f\n", pr.taxes);
@@ -469,7 +469,7 @@ static void administration_debug_print_income_statement(income_statement* statem
                 project_expense expense = pr.expenses[y];
 
                 cost_center costcenter;
-                administration_cost_center_get_by_id(&costcenter, expense.cost_center_id);
+                administration::cost_center_get_by_id(&costcenter, expense.cost_center_id);
                 printf("    %s: %.2f\n", costcenter.code, expense.total);
             }         
         }
@@ -479,17 +479,17 @@ static void administration_debug_print_income_statement(income_statement* statem
 }
 #endif
 
-void administration_create_income_statement(income_statement* statement)
+void administration::create_income_statement(income_statement* statement)
 {
     STOPWATCH_START;
 
     assert(statement);
     statement->quarter_count = 0;
 
-    u32 invoice_count = administration_invoice_count();
+    u32 invoice_count = administration::invoice_count();
     if (invoice_count == 0) return;
     invoice* invoice_buffer = (invoice*)malloc(sizeof(invoice)*invoice_count);
-    invoice_count = administration_invoice_get_all(invoice_buffer);
+    invoice_count = administration::invoice_get_all(invoice_buffer);
 
     // Find oldest and youngest invoice.
     time_t oldest = INT64_MAX;
@@ -531,14 +531,14 @@ void administration_create_income_statement(income_statement* statement)
         quarter.profit = 0.0f;
         snprintf(quarter.quarter_str, MAX_LEN_SHORT_DESC, "%dQ%d", quarter.quarter+1, quarter.year);
         
-        project_count = administration_project_count();
+        project_count = administration::project_count();
         project* project_buffer = (project*)malloc(sizeof(project)*project_count);
-        project_count = administration_project_get_all(project_buffer);
+        project_count = administration::project_get_all(project_buffer);
         assert(project_count <= MAX_LEN_QUARTERLY_REPORT_PROJECTS);
 
-        costcenter_count = administration_cost_center_count();
+        costcenter_count = administration::cost_center_count();
         cost_center* costcenter_buffer = (cost_center*)malloc(sizeof(cost_center)*costcenter_count);
-        costcenter_count = administration_cost_center_get_all(costcenter_buffer);
+        costcenter_count = administration::cost_center_get_all(costcenter_buffer);
         assert(costcenter_count <= MAX_LEN_PROJECT_REPORT_COSTCENTERS);
 
         for (u32 x = 0; x < project_count; x++)
@@ -671,32 +671,32 @@ void administration_create_income_statement(income_statement* statement)
     logger::info("Created income statement in %.3fms.", STOPWATCH_TIME);
 }
 
-void administration_set_file_path(char* path)
+void administration::set_file_path(char* path)
 {
     strops::copy(g_administration.path, path, MAX_LEN_PATH);
 }
 
-char* administration_get_file_path()
+char* administration::get_file_path()
 {
     return strlen(g_administration.path) == 0 ? NULL : g_administration.path;
 }
 
-contact administration_company_info_get()
+contact administration::company_info_get()
 {
     return g_administration.company_info;
 }
 
-void administration_company_info_import(contact data)
+void administration::company_info_import(contact data)
 {
     g_administration.company_info = data;
-    strops::copy(g_administration.default_currency, administration_get_default_currency_for_country(g_administration.company_info.address.country_code), MAX_LEN_CURRENCY);
+    strops::copy(g_administration.default_currency, get_default_currency_for_country(g_administration.company_info.address.country_code), MAX_LEN_CURRENCY);
 }
 
-void administration_company_info_set(contact data)
+void administration::company_info_set(contact data)
 {
     strops::copy(data.id, MY_COMPANY_ID, sizeof(data.id));
     g_administration.company_info = data;
-    strops::copy(g_administration.default_currency, administration_get_default_currency_for_country(g_administration.company_info.address.country_code), MAX_LEN_CURRENCY);
+    strops::copy(g_administration.default_currency, get_default_currency_for_country(g_administration.company_info.address.country_code), MAX_LEN_CURRENCY);
 
     if (contact_changed_event_callback) contact_changed_event_callback(&data);
     if (data_changed_event_callback) data_changed_event_callback();
@@ -704,14 +704,14 @@ void administration_company_info_set(contact data)
 
 // Contact functions.
 // =======================
-a_err administration_contact_import(contact data)
+a_err administration::contact_import(contact data)
 {
-    a_err result = administration_contact_is_valid(data);
+    a_err result = administration::contact_is_valid(data);
     if (result != A_ERR_SUCCESS) return result;
 
     if (strcmp(data.id, MY_COMPANY_ID) == 0)
     {
-        administration_company_info_import(data);
+        administration::company_info_import(data);
         return A_ERR_SUCCESS;
     }
 
@@ -726,9 +726,9 @@ a_err administration_contact_import(contact data)
     return A_ERR_SUCCESS;
 }
 
-a_err administration_contact_add(contact data)
+a_err administration::contact_add(contact data)
 {
-    a_err result = administration_contact_is_valid(data);
+    a_err result = administration::contact_is_valid(data);
     if (result != A_ERR_SUCCESS) return result;
     
     contact* new_contact = (contact*)malloc(sizeof(contact));
@@ -747,9 +747,9 @@ a_err administration_contact_add(contact data)
     return A_ERR_SUCCESS;
 }
 
-a_err administration_contact_update(contact data)
+a_err administration::contact_update(contact data)
 {
-    a_err result = administration_contact_is_valid(data);
+    a_err result = administration::contact_is_valid(data);
     if (result != A_ERR_SUCCESS) return result;
 
     list_iterator_start(&g_administration.contacts);
@@ -771,7 +771,7 @@ a_err administration_contact_update(contact data)
     return A_ERR_NOT_FOUND;
 }
 
-a_err administration_contact_remove(contact data)
+a_err administration::contact_remove(contact data)
 {
     list_iterator_start(&g_administration.contacts);
     while (list_iterator_hasnext(&g_administration.contacts)) {
@@ -792,12 +792,12 @@ a_err administration_contact_remove(contact data)
     return A_ERR_NOT_FOUND;
 }
 
-u32 administration_contact_count()
+u32 administration::contact_count()
 {
     return list_size(&g_administration.contacts);
 }
 
-u32 administration_contact_get_all(contact* buffer)
+u32 administration::contact_get_all(contact* buffer)
 {
     u32 write_cursor = 0;
     
@@ -811,7 +811,7 @@ u32 administration_contact_get_all(contact* buffer)
     return write_cursor;
 }
 
-u32 administration_contact_get_partial_list(u32 page_index, u32 page_size, contact* buffer)
+u32 administration::contact_get_partial_list(u32 page_index, u32 page_size, contact* buffer)
 {
     assert(buffer);
 
@@ -833,7 +833,7 @@ u32 administration_contact_get_partial_list(u32 page_index, u32 page_size, conta
     return write_cursor;
 }
 
-a_err administration_contact_get_by_id(contact* buffer, char* id)
+a_err administration::contact_get_by_id(contact* buffer, char* id)
 {
     // Include company info in contact lookup because this might be
     // used in forms.
@@ -859,7 +859,7 @@ a_err administration_contact_get_by_id(contact* buffer, char* id)
     return result;
 }
 
-int administration_contact_get_autocompletions(contact* buffer, int buf_size, char* name)
+int administration::contact_get_autocompletions(contact* buffer, int buf_size, char* name)
 {
     int write_cursor = 0;
     if (name[0] == '\0') return 0;
@@ -878,7 +878,7 @@ int administration_contact_get_autocompletions(contact* buffer, int buf_size, ch
     return write_cursor;
 }
 
-a_err administration_addressee_is_valid(delivery_info data)
+a_err administration::addressee_is_valid(delivery_info data)
 {
     a_err result = A_ERR_SUCCESS;
     if (strlen(data.name) == 0) result |= A_ERR_MISSING_NAME;
@@ -890,7 +890,7 @@ a_err administration_addressee_is_valid(delivery_info data)
     return result;
 }
 
-a_err administration_contact_is_valid(contact data)
+a_err administration::contact_is_valid(contact data)
 {
     a_err result = A_ERR_SUCCESS;
     if (strlen(data.name) == 0) result |= A_ERR_MISSING_NAME;
@@ -909,27 +909,27 @@ a_err administration_contact_is_valid(contact data)
     return result;
 }
 
-contact administration_contact_create_empty()
+contact administration::contact_create_empty()
 {
     contact result;
     memset(&result, 0, sizeof(contact));
-    snprintf(result.id, sizeof(result.id), "C/%d", administration_create_id());
+    snprintf(result.id, sizeof(result.id), "C/%d", create_id());
     return result;
 }
 
-bool administration_contact_equals(contact c1, contact c2)
+bool administration::contact_equals(contact c1, contact c2)
 {
     return memcmp(&c1, &c2, sizeof(contact)) == 0;
 }
 
 // Project functions.
 // =======================
-u32 administration_project_count()
+u32 administration::project_count()
 {
     return list_size(&g_administration.projects);
 }
 
-a_err administration_project_get_by_id(project* buffer, char* id)
+a_err administration::project_get_by_id(project* buffer, char* id)
 {
     assert(buffer);
 
@@ -948,7 +948,7 @@ a_err administration_project_get_by_id(project* buffer, char* id)
     return A_ERR_NOT_FOUND;
 }
 
-u32 administration_project_get_all(project* buffer)
+u32 administration::project_get_all(project* buffer)
 {
     u32 write_cursor = 0;
     
@@ -962,7 +962,7 @@ u32 administration_project_get_all(project* buffer)
     return write_cursor;
 }
 
-u32 administration_project_get_partial_list(u32 page_index, u32 page_size, project* buffer)
+u32 administration::project_get_partial_list(u32 page_index, u32 page_size, project* buffer)
 {
     assert(buffer);
 
@@ -984,20 +984,20 @@ u32 administration_project_get_partial_list(u32 page_index, u32 page_size, proje
     return write_cursor;
 }
 
-void administration_project_cancel(project data)
+void administration::project_cancel(project data)
 {
     data.end_date = time(NULL);
     data.state = project_state::PROJECT_CANCELLED;
-    administration_project_update(data);
+    administration::project_update(data);
 }
 
-a_err administration_project_is_valid(project data)
+a_err administration::project_is_valid(project data)
 {
     if (strlen(data.description) == 0) return A_ERR_MISSING_DESCRIPTION;
     return A_ERR_SUCCESS;
 }
 
-char* administration_project_get_status_string(project data)
+char* administration::project_get_status_string(project data)
 {
     switch(data.state)
     {
@@ -1009,9 +1009,9 @@ char* administration_project_get_status_string(project data)
     return "";
 }
 
-a_err administration_project_import(project data)
+a_err administration::project_import(project data)
 {
-    a_err result = administration_project_is_valid(data);
+    a_err result = administration::project_is_valid(data);
     if (result != A_ERR_SUCCESS) return result;
 
     project* new_project = (project*)malloc(sizeof(project));
@@ -1025,9 +1025,9 @@ a_err administration_project_import(project data)
     return A_ERR_SUCCESS;
 }
 
-a_err administration_project_add(project data)
+a_err administration::project_add(project data)
 {
-    a_err result = administration_project_is_valid(data);
+    a_err result = administration::project_is_valid(data);
     if (result != A_ERR_SUCCESS) return result;
 
     project* new_project = (project*)malloc(sizeof(project));
@@ -1047,9 +1047,9 @@ a_err administration_project_add(project data)
     return A_ERR_SUCCESS;
 }
 
-a_err administration_project_update(project data)
+a_err administration::project_update(project data)
 {
-    a_err result = administration_project_is_valid(data);
+    a_err result = administration::project_is_valid(data);
     if (result != A_ERR_SUCCESS) return result;
 
     list_iterator_start(&g_administration.projects);
@@ -1071,7 +1071,7 @@ a_err administration_project_update(project data)
     return A_ERR_NOT_FOUND;
 }
 
-a_err administration_project_remove(project data)
+a_err administration::project_remove(project data)
 {
     list_iterator_start(&g_administration.projects);
     while (list_iterator_hasnext(&g_administration.projects)) {
@@ -1092,7 +1092,7 @@ a_err administration_project_remove(project data)
     return A_ERR_NOT_FOUND;
 }
 
-project administration_project_create_empty()
+project administration::project_create_empty()
 {
     project result;
     memset(&result, 0, sizeof(project));
@@ -1100,23 +1100,23 @@ project administration_project_create_empty()
     result.start_date = time(NULL);
     result.start_date -= (result.start_date % 86400);
     result.end_date = 0;
-    snprintf(result.id, sizeof(result.id), "P/%d", administration_create_id());
+    snprintf(result.id, sizeof(result.id), "P/%d", create_id());
     return result;
 }
 
 // Tax rate functions.
 // =======================
 
-tax_rate administration_tax_rate_create_empty()
+tax_rate administration::tax_rate_create_empty()
 {
     tax_rate result;
     memset(&result, 0, sizeof(tax_rate));
-    snprintf(result.id, sizeof(result.id), "T/%d", administration_create_id());
+    snprintf(result.id, sizeof(result.id), "T/%d", create_id());
     snprintf(result.category_code, sizeof(result.category_code), "S"); // S = standard rate.
     return result;
 }
 
-a_err administration_tax_rate_get_by_shorthandle(tax_rate* buffer, char* handle)
+a_err administration::tax_rate_get_by_shorthandle(tax_rate* buffer, char* handle)
 {
     assert(buffer);
 
@@ -1138,7 +1138,7 @@ a_err administration_tax_rate_get_by_shorthandle(tax_rate* buffer, char* handle)
     return A_ERR_NOT_FOUND;
 }
 
-a_err administration_tax_rate_get_by_id(tax_rate* buffer, char* id)
+a_err administration::tax_rate_get_by_id(tax_rate* buffer, char* id)
 {
     assert(buffer);
 
@@ -1157,12 +1157,12 @@ a_err administration_tax_rate_get_by_id(tax_rate* buffer, char* id)
     return A_ERR_NOT_FOUND;
 }
 
-u32 administration_tax_rate_count()
+u32 administration::tax_rate_count()
 {
     return list_size(&g_administration.tax_rates);
 }
 
-a_err administration_tax_rate_import(tax_rate data)
+a_err administration::tax_rate_import(tax_rate data)
 {
     tax_rate* tb = (tax_rate*)malloc(sizeof(tax_rate));
     if (!tb) return A_ERR_GENERIC;
@@ -1177,7 +1177,7 @@ a_err administration_tax_rate_import(tax_rate data)
     return A_ERR_SUCCESS;
 }
 
-a_err administration_tax_rate_add(tax_rate data)
+a_err administration::tax_rate_add(tax_rate data)
 {
     tax_rate* tb = (tax_rate*)malloc(sizeof(tax_rate));
     if (!tb) return A_ERR_GENERIC;
@@ -1198,7 +1198,7 @@ a_err administration_tax_rate_add(tax_rate data)
     return A_ERR_SUCCESS;
 }
 
-u32 administration_tax_rate_get_by_country(tax_rate* buffer, u32 code_count, char** tax_country_codes)
+u32 administration::tax_rate_get_by_country(tax_rate* buffer, u32 code_count, char** tax_country_codes)
 {
     assert(buffer);
 
@@ -1225,7 +1225,7 @@ u32 administration_tax_rate_get_by_country(tax_rate* buffer, u32 code_count, cha
     return write_cursor;
 }
 
-u32 administration_tax_rate_get_all(tax_rate* buffer)
+u32 administration::tax_rate_get_all(tax_rate* buffer)
 {
     assert(buffer);
 
@@ -1241,7 +1241,7 @@ u32 administration_tax_rate_get_all(tax_rate* buffer)
     return write_cursor;
 }
 
-a_err administration_tax_rate_update(tax_rate data)
+a_err administration::tax_rate_update(tax_rate data)
 {
     list_iterator_start(&g_administration.tax_rates);
     while (list_iterator_hasnext(&g_administration.tax_rates)) {
@@ -1264,20 +1264,20 @@ a_err administration_tax_rate_update(tax_rate data)
 
 // Cost center functions.
 // =======================
-u32 administration_cost_center_count()
+u32 administration::cost_center_count()
 {
     return list_size(&g_administration.cost_centers);
 }
 
-cost_center administration_cost_center_create_empty()
+cost_center administration::cost_center_create_empty()
 {
     cost_center cc;
     memset(&cc, 0, sizeof(cost_center));
-    snprintf(cc.id, sizeof(cc.id), "E/%d", administration_create_id());
+    snprintf(cc.id, sizeof(cc.id), "E/%d", create_id());
     return cc;
 }
 
-a_err administration_cost_center_get_by_id(cost_center* buffer, char* id)
+a_err administration::cost_center_get_by_id(cost_center* buffer, char* id)
 {
     assert(buffer);
 
@@ -1296,7 +1296,7 @@ a_err administration_cost_center_get_by_id(cost_center* buffer, char* id)
     return A_ERR_NOT_FOUND;
 }
 
-u32 administration_cost_center_get_all(cost_center* buffer)
+u32 administration::cost_center_get_all(cost_center* buffer)
 {
     assert(buffer);
 
@@ -1312,7 +1312,7 @@ u32 administration_cost_center_get_all(cost_center* buffer)
     return write_cursor;
 }
 
-static bool administration_get_cost_center_by_code(char* code, cost_center* buffer)
+static bool get_cost_center_by_code(char* code, cost_center* buffer)
 {
     bool result = false;
     list_iterator_start(&g_administration.cost_centers);
@@ -1329,21 +1329,21 @@ static bool administration_get_cost_center_by_code(char* code, cost_center* buff
     return result;
 }
 
-a_err administration_cost_center_is_valid(cost_center data)
+a_err administration::cost_center_is_valid(cost_center data)
 {
     cost_center lookup;
 
     a_err result = A_ERR_SUCCESS;
     if (strlen(data.code) == 0) result |= A_ERR_MISSING_CODE;
     if (strlen(data.description) == 0) result |= A_ERR_MISSING_DESCRIPTION;
-    if (administration_get_cost_center_by_code(data.code, &lookup)) result |= A_ERR_CODE_EXISTS;
+    if (get_cost_center_by_code(data.code, &lookup)) result |= A_ERR_CODE_EXISTS;
 
     return result;
 }
 
-a_err administration_cost_center_import(cost_center data)
+a_err administration::cost_center_import(cost_center data)
 {
-    a_err result = administration_cost_center_is_valid(data);
+    a_err result = administration::cost_center_is_valid(data);
     if (result != A_ERR_SUCCESS) return result;
 
     cost_center* tb = (cost_center*)malloc(sizeof(cost_center));
@@ -1356,9 +1356,9 @@ a_err administration_cost_center_import(cost_center data)
     return A_ERR_SUCCESS;
 }
 
-a_err administration_cost_center_add(cost_center data)
+a_err administration::cost_center_add(cost_center data)
 {  
-    a_err result = administration_cost_center_is_valid(data);
+    a_err result = administration::cost_center_is_valid(data);
     if (result != A_ERR_SUCCESS) return result;
 
     cost_center* tb = (cost_center*)malloc(sizeof(cost_center));
@@ -1377,9 +1377,9 @@ a_err administration_cost_center_add(cost_center data)
     return A_ERR_SUCCESS;
 }
 
-a_err administration_cost_center_update(cost_center data)
+a_err administration::cost_center_update(cost_center data)
 {
-    a_err result = administration_cost_center_is_valid(data);
+    a_err result = administration::cost_center_is_valid(data);
     if (result != A_ERR_CODE_EXISTS) return result;
 
     list_iterator_start(&g_administration.cost_centers);
@@ -1403,7 +1403,7 @@ a_err administration_cost_center_update(cost_center data)
 
 // Invoice functions.
 // =======================
-static char* administration_get_default_currency_for_country(char* country_code)
+static char* get_default_currency_for_country(char* country_code)
 {
     if (country_code == NULL || strlen(country_code) != 2)
         return "EUR"; // default
@@ -1443,19 +1443,19 @@ static char* administration_get_default_currency_for_country(char* country_code)
     return "EUR";
 }
 
-invoice administration_invoice_create_empty()
+invoice administration::invoice_create_empty()
 {
     invoice result;
     memset(&result, 0, sizeof(invoice));
-    snprintf(result.id, sizeof(result.id), "I/%d", administration_create_id());
-    snprintf(result.sequential_number, sizeof(result.id), "INV%010d", administration_create_sequence_number());
+    snprintf(result.id, sizeof(result.id), "I/%d", create_id());
+    snprintf(result.sequential_number, sizeof(result.id), "INV%010d", create_sequence_number());
     result.issued_at = time(NULL);
     result.issued_at -= (result.issued_at % 86400);
 
     result.delivered_at = result.issued_at;
-    result.expires_at = result.issued_at + administration_get_default_invoice_expire_duration();
+    result.expires_at = result.issued_at + administration::get_default_invoice_expire_duration();
     list_init(&result.billing_items); // @leak
-    strops::copy(result.currency, administration_get_default_currency_for_country(g_administration.company_info.address.country_code), MAX_LEN_CURRENCY);
+    strops::copy(result.currency, get_default_currency_for_country(g_administration.company_info.address.country_code), MAX_LEN_CURRENCY);
     return result;
 }
 
@@ -1477,7 +1477,7 @@ static void administration_recalculate_invoice_totals(invoice* invoice)
     }
     list_iterator_stop(&invoice->billing_items);
 
-    if (strcmp(invoice->currency, administration_get_default_currency()) == 0) {
+    if (strcmp(invoice->currency, administration::get_default_currency()) == 0) {
         invoice->tax = invoice->orig_tax;
         invoice->total = invoice->orig_total;
         invoice->net = invoice->orig_net;
@@ -1485,7 +1485,7 @@ static void administration_recalculate_invoice_totals(invoice* invoice)
     }
 }
 
-void administration_invoice_set_currency(invoice* invoice, char* currency)
+void administration::invoice_set_currency(invoice* invoice, char* currency)
 {
     strops::copy(invoice->currency, currency, MAX_LEN_CURRENCY);
 
@@ -1498,25 +1498,25 @@ void administration_invoice_set_currency(invoice* invoice, char* currency)
     list_iterator_stop(&invoice->billing_items);
 }
 
-a_err administration_invoice_is_valid(invoice* invoice)
+a_err administration::invoice_is_valid(invoice* invoice)
 {
     a_err result = A_ERR_SUCCESS;
     if (list_size(&invoice->billing_items) == 0) result |= A_ERR_MISSING_BILLING_ITEMS;
-    if (invoice->is_triangulation && administration_addressee_is_valid(invoice->addressee) != A_ERR_SUCCESS) result |= A_ERR_INVALID_ADDRESSEE;
-    if (administration_contact_is_valid(invoice->customer) != A_ERR_SUCCESS) result |= A_ERR_INVALID_CUSTOMER;
-    if (administration_contact_is_valid(invoice->supplier) != A_ERR_SUCCESS) result |= A_ERR_INVALID_SUPPLIER;
+    if (invoice->is_triangulation && administration::addressee_is_valid(invoice->addressee) != A_ERR_SUCCESS) result |= A_ERR_INVALID_ADDRESSEE;
+    if (administration::contact_is_valid(invoice->customer) != A_ERR_SUCCESS) result |= A_ERR_INVALID_CUSTOMER;
+    if (administration::contact_is_valid(invoice->supplier) != A_ERR_SUCCESS) result |= A_ERR_INVALID_SUPPLIER;
 
     list_iterator_start(&invoice->billing_items);
     while (list_iterator_hasnext(&invoice->billing_items)) {
         billing_item* c = (billing_item *)list_iterator_next(&invoice->billing_items);
-        if (administration_billing_item_is_valid(*c) != A_ERR_SUCCESS) result |= A_ERR_INVALID_BILLING_ITEM;
+        if (administration::billing_item_is_valid(*c) != A_ERR_SUCCESS) result |= A_ERR_INVALID_BILLING_ITEM;
     }
     list_iterator_stop(&invoice->billing_items);
 
     return result;
 }
 
-a_err administration_invoice_remove(invoice* inv)
+a_err administration::invoice_remove(invoice* inv)
 {
     list_iterator_start(&g_administration.invoices);
     while (list_iterator_hasnext(&g_administration.invoices)) {
@@ -1541,7 +1541,7 @@ a_err administration_invoice_remove(invoice* inv)
     return A_ERR_NOT_FOUND;
 }
 
-static void _administration_invoice_set_addressee(invoice* inv, contact contact)
+static void invoice_set_addressee(invoice* inv, contact contact)
 {
     memcpy(&inv->addressee.name, &contact.name, sizeof(inv->addressee.name));
     memcpy(&inv->addressee.address.address1, &contact.address.address1, sizeof(inv->addressee.address.address1));
@@ -1552,13 +1552,13 @@ static void _administration_invoice_set_addressee(invoice* inv, contact contact)
     memcpy(&inv->addressee.address.country_code, &contact.address.country_code, sizeof(inv->addressee.address.country_code));
 }
 
-a_err administration_invoice_update(invoice* inv)
+a_err administration::invoice_update(invoice* inv)
 {
-    a_err result = administration_invoice_is_valid(inv);
+    a_err result = administration::invoice_is_valid(inv);
     if (result != A_ERR_SUCCESS) return result;
 
     // Addressee is same as customer.
-    if (!inv->is_triangulation) _administration_invoice_set_addressee(inv, inv->customer);
+    if (!inv->is_triangulation) invoice_set_addressee(inv, inv->customer);
 
     list_iterator_start(&g_administration.invoices);
     while (list_iterator_hasnext(&g_administration.invoices)) {
@@ -1579,9 +1579,9 @@ a_err administration_invoice_update(invoice* inv)
     return A_ERR_NOT_FOUND;
 }
 
-a_err administration_invoice_import(invoice* inv)
+a_err administration::invoice_import(invoice* inv)
 {
-    //a_err result = administration_invoice_is_valid(inv);
+    //a_err result = administration::invoice_is_valid(inv);
     //if (result != A_ERR_SUCCESS) return result;
 
     inv->is_triangulation = !(memcmp(&inv->addressee.address, &inv->customer.address, sizeof(address)) == 0);
@@ -1591,7 +1591,7 @@ a_err administration_invoice_import(invoice* inv)
     inv->expires_at -= (inv->expires_at % 86400);
     inv->is_outgoing = strcmp(inv->supplier.id, MY_COMPANY_ID) == 0;
     
-    invoice copy = administration_invoice_create_copy(inv); // Create copy to make copy of billing item list.
+    invoice copy = administration::invoice_create_copy(inv); // Create copy to make copy of billing item list.
     invoice* new_inv = (invoice*)malloc(sizeof(invoice));
     if (!new_inv) return A_ERR_GENERIC;
     
@@ -1604,12 +1604,12 @@ a_err administration_invoice_import(invoice* inv)
     return A_ERR_SUCCESS;
 }
 
-a_err administration_invoice_add(invoice* inv)
+a_err administration::invoice_add(invoice* inv)
 {
-    a_err result = administration_invoice_is_valid(inv);
+    a_err result = administration::invoice_is_valid(inv);
     if (result != A_ERR_SUCCESS) return result;
 
-    if (!inv->is_triangulation) _administration_invoice_set_addressee(inv, inv->customer);
+    if (!inv->is_triangulation) invoice_set_addressee(inv, inv->customer);
 
     inv->issued_at -= (inv->issued_at % 86400);
     inv->delivered_at -= (inv->delivered_at % 86400);
@@ -1622,7 +1622,7 @@ a_err administration_invoice_add(invoice* inv)
     strops::copy(inv->payment_means.service_provider_id, "",                         sizeof(inv->payment_means.service_provider_id));
     strops::copy(inv->payment_means.payer_bank_account, inv->customer.bank_account,  sizeof(inv->payment_means.payer_bank_account));
  
-    invoice copy = administration_invoice_create_copy(inv); // Create copy to make copy of billing item list.
+    invoice copy = administration::invoice_create_copy(inv); // Create copy to make copy of billing item list.
     invoice* new_inv = (invoice*)malloc(sizeof(invoice));
     if (!new_inv) return A_ERR_GENERIC;
     
@@ -1644,9 +1644,9 @@ a_err administration_invoice_add(invoice* inv)
     return A_ERR_SUCCESS;
 }
 
-invoice administration_invoice_create_copy(invoice* inv)
+invoice administration::invoice_create_copy(invoice* inv)
 {
-    invoice new_inv = administration_invoice_create_empty();
+    invoice new_inv = administration::invoice_create_empty();
     list_t billing_items = new_inv.billing_items;
 
     memcpy((void*)&new_inv, (void*)inv, sizeof(invoice));
@@ -1665,22 +1665,22 @@ invoice administration_invoice_create_copy(invoice* inv)
     return new_inv;
 }
 
-u32 administration_invoice_count()
+u32 administration::invoice_count()
 {
     return list_size(&g_administration.invoices);
 }
 
-u32 administration_invoice_get_incomming_count()
+u32 administration::invoice_get_incomming_count()
 {
     return g_administration.expense_count;
 }
 
-u32 administration_invoice_get_outgoing_count()
+u32 administration::invoice_get_outgoing_count()
 {
     return g_administration.invoice_count;
 }
 
-a_err administration_invoice_get_by_id(invoice* buffer, char* id)
+a_err administration::invoice_get_by_id(invoice* buffer, char* id)
 {
     a_err result = A_ERR_NOT_FOUND;
     list_iterator_start(&g_administration.invoices);
@@ -1698,7 +1698,7 @@ a_err administration_invoice_get_by_id(invoice* buffer, char* id)
     return result;
 }
 
-u32 administration_invoice_get_all(invoice* buffer)
+u32 administration::invoice_get_all(invoice* buffer)
 {
     assert(buffer);
 
@@ -1714,7 +1714,7 @@ u32 administration_invoice_get_all(invoice* buffer)
     return write_cursor;
 }
 
-bool administration_invoice_get_subtotal_for_tax_rate(invoice* invoice, tax_rate rate, tax_subtotal* buffer)
+bool administration::invoice_get_subtotal_for_tax_rate(invoice* invoice, tax_rate rate, tax_subtotal* buffer)
 {
     bool result = false;
 
@@ -1741,7 +1741,7 @@ bool administration_invoice_get_subtotal_for_tax_rate(invoice* invoice, tax_rate
     return result;
 }
 
-u32 administration_invoice_get_tax_rates(invoice* invoice, tax_rate* buffer)
+u32 administration::invoice_get_tax_rates(invoice* invoice, tax_rate* buffer)
 {
     u32 write_cursor = 0;
     
@@ -1750,7 +1750,7 @@ u32 administration_invoice_get_tax_rates(invoice* invoice, tax_rate* buffer)
         billing_item c = *(billing_item *)list_iterator_next(&invoice->billing_items);
 
         tax_rate rate;
-        a_err found = administration_tax_rate_get_by_id(&rate, c.tax_rate_id);
+        a_err found = administration::tax_rate_get_by_id(&rate, c.tax_rate_id);
         if (found == A_ERR_SUCCESS) {
 
             bool exists = false;
@@ -1771,7 +1771,7 @@ u32 administration_invoice_get_tax_rates(invoice* invoice, tax_rate* buffer)
     return write_cursor;
 }
 
-static u32 administration_invoice_get_partial_list(u32 page_index, u32 page_size, invoice* buffer, bool want_outgoing)
+static u32 invoice_get_partial_list(u32 page_index, u32 page_size, invoice* buffer, bool want_outgoing)
 {
     assert(buffer);
     u32 write_cursor = 0;
@@ -1794,17 +1794,17 @@ static u32 administration_invoice_get_partial_list(u32 page_index, u32 page_size
     return write_cursor;
 }
 
-u32 administration_invoice_get_partial_list_outgoing(u32 page_index, u32 page_size, invoice* buffer)
+u32 administration::invoice_get_partial_list_outgoing(u32 page_index, u32 page_size, invoice* buffer)
 {
-    return administration_invoice_get_partial_list(page_index, page_size, buffer, 1);
+    return invoice_get_partial_list(page_index, page_size, buffer, 1);
 }
 
-u32 administration_invoice_get_partial_list_incomming(u32 page_index, u32 page_size, invoice* buffer)
+u32 administration::invoice_get_partial_list_incomming(u32 page_index, u32 page_size, invoice* buffer)
 {
-    return administration_invoice_get_partial_list(page_index, page_size, buffer, 0);
+    return invoice_get_partial_list(page_index, page_size, buffer, 0);
 }
 
-char* administration_invoice_get_status_string(invoice* invoice)
+char* administration::invoice_get_status_string(invoice* invoice)
 {
     switch(invoice->status)
     {
@@ -1851,7 +1851,7 @@ static void administration_recalculate_billing_item_totals(billing_item* item)
     }
 
     tax_rate rate;
-    if (administration_tax_rate_get_by_id(&rate, item->tax_rate_id) == A_ERR_SUCCESS)
+    if (administration::tax_rate_get_by_id(&rate, item->tax_rate_id) == A_ERR_SUCCESS)
     {
         item->tax = item->net * (rate.rate/100.0f);
     }
@@ -1859,12 +1859,12 @@ static void administration_recalculate_billing_item_totals(billing_item* item)
     item->total = item->net + item->tax;
 }
 
-u32 administration_billing_item_count(invoice* invoice)
+u32 administration::billing_item_count(invoice* invoice)
 {
     return list_size(&invoice->billing_items);
 }
 
-u32 administration_billing_item_get_all_for_invoice(invoice* invoice, billing_item* buffer)
+u32 administration::billing_item_get_all_for_invoice(invoice* invoice, billing_item* buffer)
 {
     u32 write_cursor = 0;
     
@@ -1878,7 +1878,7 @@ u32 administration_billing_item_get_all_for_invoice(invoice* invoice, billing_it
     return write_cursor;
 }
 
-a_err administration_billing_item_remove_from_invoice(invoice* invoice, billing_item item)
+a_err administration::billing_item_remove_from_invoice(invoice* invoice, billing_item item)
 {
     list_iterator_start(&invoice->billing_items);
     while (list_iterator_hasnext(&invoice->billing_items)) {
@@ -1896,7 +1896,7 @@ a_err administration_billing_item_remove_from_invoice(invoice* invoice, billing_
     return A_ERR_NOT_FOUND;
 }
 
-a_err administration_billing_item_update_in_invoice(invoice* invoice, billing_item item)
+a_err administration::billing_item_update_in_invoice(invoice* invoice, billing_item item)
 {
     list_iterator_start(&invoice->billing_items);
     while (list_iterator_hasnext(&invoice->billing_items)) {
@@ -1916,7 +1916,7 @@ a_err administration_billing_item_update_in_invoice(invoice* invoice, billing_it
     return A_ERR_NOT_FOUND;
 }
 
-a_err administration_billing_item_is_valid(billing_item item)
+a_err administration::billing_item_is_valid(billing_item item)
 {
     a_err result = A_ERR_SUCCESS;
     if (strlen(item.description) == 0) result |= A_ERR_MISSING_DESCRIPTION;
@@ -1925,9 +1925,9 @@ a_err administration_billing_item_is_valid(billing_item item)
     return result;
 }
 
-a_err administration_billing_item_import_to_invoice(invoice* invoice, billing_item item)
+a_err administration::billing_item_import_to_invoice(invoice* invoice, billing_item item)
 {
-    if (administration_billing_item_count(invoice) >= MAX_BILLING_ITEMS) return A_ERR_MAX_ITEMS_REACHED;
+    if (administration::billing_item_count(invoice) >= MAX_BILLING_ITEMS) return A_ERR_MAX_ITEMS_REACHED;
 
     billing_item* tb = (billing_item*)malloc(sizeof(billing_item));
     if (!tb) return A_ERR_GENERIC;
@@ -1943,15 +1943,15 @@ a_err administration_billing_item_import_to_invoice(invoice* invoice, billing_it
     return A_ERR_SUCCESS;
 }
 
-a_err administration_billing_item_add_to_invoice(invoice* invoice, billing_item item)
+a_err administration::billing_item_add_to_invoice(invoice* invoice, billing_item item)
 {
-    if (administration_billing_item_count(invoice) >= MAX_BILLING_ITEMS) return A_ERR_MAX_ITEMS_REACHED;
+    if (administration::billing_item_count(invoice) >= MAX_BILLING_ITEMS) return A_ERR_MAX_ITEMS_REACHED;
 
     billing_item* tb = (billing_item*)malloc(sizeof(billing_item));
     if (!tb) return A_ERR_GENERIC;
     
     memcpy(tb, &item, sizeof(billing_item));
-    snprintf(tb->id, sizeof(tb->id), "B/%d", administration_create_id());
+    snprintf(tb->id, sizeof(tb->id), "B/%d", create_id());
     strops::copy(tb->currency, invoice->currency, MAX_LEN_CURRENCY); // Set billing item currency to invoice currency.
     
     administration_recalculate_billing_item_totals(tb);
@@ -1965,7 +1965,7 @@ a_err administration_billing_item_add_to_invoice(invoice* invoice, billing_item
     return A_ERR_SUCCESS;
 }
 
-billing_item administration_billing_item_create_empty()
+billing_item administration::billing_item_create_empty()
 {
     billing_item item;
     memset(&item, 0, sizeof(billing_item));