namespace administration

4 files changed, 209 insertions, 209 deletions

diff --git a/tests/administration_rw_tests.cpp b/tests/administration_rw_tests.cpp
index 321968e..6d12b45 100644
--- a/tests/administration_rw_tests.cpp
+++ b/tests/administration_rw_tests.cpp
@@ -23,23 +23,23 @@ TEST _administration_rw_taxrate(void)
 
     administration_writer::create();
 
-    administration_create_empty(test_file_path);
+    administration::create_empty(test_file_path);
     {
-        pw = administration_tax_rate_create_empty();
+        pw = administration::tax_rate_create_empty();
         strops::copy(pw.country_code, "NL", sizeof(pw.country_code));
         pw.rate = 10.0f;
         strops::copy(pw.category_code, "S", sizeof(pw.category_code));
         
-        count = administration_tax_rate_count();
-        administration_tax_rate_add(pw);
+        count = administration::tax_rate_count();
+        administration::tax_rate_add(pw);
 
-        ASSERT_EQ(count+1, administration_tax_rate_count());
+        ASSERT_EQ(count+1, administration::tax_rate_count());
     }
 
     administration_reader::open_existing(test_file_path);
     {
-        ASSERT_EQ(count+1, administration_tax_rate_count());
-        ASSERT_EQ(A_ERR_SUCCESS, administration_tax_rate_get_by_id(&pr, pw.id));
+        ASSERT_EQ(count+1, administration::tax_rate_count());
+        ASSERT_EQ(A_ERR_SUCCESS, administration::tax_rate_get_by_id(&pr, pw.id));
         ASSERT_MEM_EQ(&pw, &pr, sizeof(tax_rate));
     }
 
@@ -54,22 +54,22 @@ TEST _administration_rw_costcenter(void)
 
     administration_writer::create();
 
-    administration_create_empty(test_file_path);
+    administration::create_empty(test_file_path);
     {
-        pw = administration_cost_center_create_empty();
+        pw = administration::cost_center_create_empty();
         strops::copy(pw.code, "CODE", sizeof(pw.code));
         strops::copy(pw.description, "Description", sizeof(pw.description));
         
-        count = administration_cost_center_count();
-        administration_cost_center_add(pw);
+        count = administration::cost_center_count();
+        administration::cost_center_add(pw);
 
-        ASSERT_EQ(count+1, administration_cost_center_count());
+        ASSERT_EQ(count+1, administration::cost_center_count());
     }
 
     administration_reader::open_existing(test_file_path);
     {
-        ASSERT_EQ(count+1, administration_cost_center_count());
-        ASSERT_EQ(A_ERR_SUCCESS, administration_cost_center_get_by_id(&pr, pw.id));
+        ASSERT_EQ(count+1, administration::cost_center_count());
+        ASSERT_EQ(A_ERR_SUCCESS, administration::cost_center_get_by_id(&pr, pw.id));
         ASSERT_MEM_EQ(&pw, &pr, sizeof(cost_center));
     }
 
@@ -84,20 +84,20 @@ TEST _administration_rw_project(void)
 
     administration_writer::create();
 
-    administration_create_empty(test_file_path);
+    administration::create_empty(test_file_path);
     {
-        pw = administration_project_create_empty();
+        pw = administration::project_create_empty();
         strops::copy(pw.description, "Test Project", sizeof(pw.description));
-        count = administration_project_count();
-        administration_project_add(pw);
+        count = administration::project_count();
+        administration::project_add(pw);
 
-        ASSERT_EQ(count+1, administration_project_count());
+        ASSERT_EQ(count+1, administration::project_count());
     }
 
     administration_reader::open_existing(test_file_path);
     {
-        ASSERT_EQ(count+1, administration_project_count());
-        ASSERT_EQ(A_ERR_SUCCESS, administration_project_get_by_id(&pr, pw.id));
+        ASSERT_EQ(count+1, administration::project_count());
+        ASSERT_EQ(A_ERR_SUCCESS, administration::project_get_by_id(&pr, pw.id));
         ASSERT_MEM_EQ(&pw, &pr, sizeof(project));
     }
 
@@ -112,9 +112,9 @@ TEST _administration_rw_contact(void)
 
     administration_writer::create();
 
-    administration_create_empty(test_file_path);
+    administration::create_empty(test_file_path);
     {
-        pw = administration_contact_create_empty();
+        pw = administration::contact_create_empty();
         strops::copy(pw.name, "John Johnsson", sizeof(pw.name));
         strops::copy(pw.address.address1, "Address 1", sizeof(pw.address.address1));
         strops::copy(pw.address.country_code, "FR", sizeof(pw.address.country_code));
@@ -123,16 +123,16 @@ TEST _administration_rw_contact(void)
         strops::copy(pw.email, "test@test.com", sizeof(pw.email));
         pw.type = contact_type::CONTACT_CONSUMER;
 
-        count = administration_contact_count();
-        administration_contact_add(pw);
+        count = administration::contact_count();
+        administration::contact_add(pw);
 
-        ASSERT_EQ(count+1, administration_contact_count());
+        ASSERT_EQ(count+1, administration::contact_count());
     }
 
     administration_reader::open_existing(test_file_path);
     {
-        ASSERT_EQ(count+1, administration_contact_count());
-        ASSERT_EQ(A_ERR_SUCCESS, administration_contact_get_by_id(&pr, pw.id));
+        ASSERT_EQ(count+1, administration::contact_count());
+        ASSERT_EQ(A_ERR_SUCCESS, administration::contact_get_by_id(&pr, pw.id));
         ASSERT_MEM_EQ(&pw, &pr, sizeof(contact));
     }
 
@@ -145,25 +145,25 @@ TEST _administration_rw_info(void)
 
     s32 next_id, next_sequence_number;
     ai_service ais;
-    administration_create_empty(test_file_path);
+    administration::create_empty(test_file_path);
     {
-        next_id = administration_get_next_id();
-        next_sequence_number = administration_get_next_sequence_number();
+        next_id = administration::get_next_id();
+        next_sequence_number = administration::get_next_sequence_number();
 
         ai_service ss = {0};
         ss.provider = AI_PROVIDER_OPENAI;
         strops::copy(ss.api_key_public, "123", sizeof(ss.api_key_public));
-        administration_set_ai_service(ss);
+        administration::set_ai_service(ss);
 
-        ais = administration_get_ai_service();
+        ais = administration::get_ai_service();
     }
 
     administration_reader::open_existing(test_file_path);
     {
-        ASSERT_EQ(next_id, administration_get_next_id());
-        ASSERT_EQ(next_sequence_number, administration_get_next_sequence_number());
+        ASSERT_EQ(next_id, administration::get_next_id());
+        ASSERT_EQ(next_sequence_number, administration::get_next_sequence_number());
 
-        ai_service rs = administration_get_ai_service();
+        ai_service rs = administration::get_ai_service();
         ASSERT_MEM_EQ(&ais, &rs, sizeof(ai_service));
     }
 
@@ -183,9 +183,9 @@ TEST _assert_invoices_are_equal(invoice inv, invoice invr)
     ASSERT_STR_EQ(invr.project_id, inv.project_id);
     ASSERT_STR_EQ(invr.cost_center_id, inv.cost_center_id);
 
-    ASSERT_EQ(administration_billing_item_count(&inv), administration_billing_item_count(&invr));
+    ASSERT_EQ(administration::billing_item_count(&inv), administration::billing_item_count(&invr));
 
-    int num_items = administration_billing_item_count(&inv);
+    int num_items = administration::billing_item_count(&inv);
     for (int i = 0; i < num_items; i++)
     {
         billing_item* b1 = (billing_item*)list_get_at(&inv.billing_items, i);
@@ -236,12 +236,12 @@ TEST _administration_rw_b2b_invoice(void)
 
     administration_writer::create();
 
-    administration_create_default(test_file_path);
+    administration::create_default(test_file_path);
     {
         contact pw1 = _create_nl_business();
         contact pw2 = _create_nl_business();
 
-        inv = administration_invoice_create_empty();
+        inv = administration::invoice_create_empty();
         inv.supplier = pw1;
         inv.customer = pw2;
         inv.is_outgoing = 1;
@@ -250,20 +250,20 @@ TEST _administration_rw_b2b_invoice(void)
         inv.delivered_at = inv.issued_at;
         inv.expires_at = inv.issued_at + 1000;
 
-        administration_billing_item_add_to_invoice(&inv, _create_bi3(&inv));
-        administration_billing_item_add_to_invoice(&inv, _create_bi4(&inv));
-        administration_billing_item_add_to_invoice(&inv, _create_bi5(&inv));
-        administration_billing_item_add_to_invoice(&inv, _create_bi6(&inv));
+        administration::billing_item_add_to_invoice(&inv, _create_bi3(&inv));
+        administration::billing_item_add_to_invoice(&inv, _create_bi4(&inv));
+        administration::billing_item_add_to_invoice(&inv, _create_bi5(&inv));
+        administration::billing_item_add_to_invoice(&inv, _create_bi6(&inv));
 
-        count = administration_invoice_count();
-        ASSERT_EQ(administration_invoice_add(&inv), A_ERR_SUCCESS);
-        ASSERT_EQ(count+1, administration_invoice_count());
+        count = administration::invoice_count();
+        ASSERT_EQ(administration::invoice_add(&inv), A_ERR_SUCCESS);
+        ASSERT_EQ(count+1, administration::invoice_count());
     }
 
     administration_reader::open_existing(test_file_path);
     {
-        ASSERT_EQ(count+1, administration_invoice_count());
-        ASSERT_EQ(A_ERR_SUCCESS, administration_invoice_get_by_id(&invr, inv.id));
+        ASSERT_EQ(count+1, administration::invoice_count());
+        ASSERT_EQ(A_ERR_SUCCESS, administration::invoice_get_by_id(&invr, inv.id));
 
         CHECK_CALL(_assert_invoices_are_equal(inv, invr));
     }
@@ -279,12 +279,12 @@ TEST _administration_rw_b2c_invoice(void)
 
     administration_writer::create();
 
-    administration_create_default(test_file_path);
+    administration::create_default(test_file_path);
     {
         contact pw1 = _create_nl_business();
         contact pw2 = _create_nl_consumer();
 
-        inv = administration_invoice_create_empty();
+        inv = administration::invoice_create_empty();
         inv.supplier = pw1;
         inv.customer = pw2;
         inv.is_outgoing = 1;
@@ -293,20 +293,20 @@ TEST _administration_rw_b2c_invoice(void)
         inv.delivered_at = inv.issued_at;
         inv.expires_at = inv.issued_at + 1000;
 
-        administration_billing_item_add_to_invoice(&inv, _create_bi3(&inv));
-        administration_billing_item_add_to_invoice(&inv, _create_bi4(&inv));
-        administration_billing_item_add_to_invoice(&inv, _create_bi5(&inv));
-        administration_billing_item_add_to_invoice(&inv, _create_bi6(&inv));
+        administration::billing_item_add_to_invoice(&inv, _create_bi3(&inv));
+        administration::billing_item_add_to_invoice(&inv, _create_bi4(&inv));
+        administration::billing_item_add_to_invoice(&inv, _create_bi5(&inv));
+        administration::billing_item_add_to_invoice(&inv, _create_bi6(&inv));
 
-        count = administration_invoice_count();
-        ASSERT_EQ(administration_invoice_add(&inv), A_ERR_SUCCESS);
-        ASSERT_EQ(count+1, administration_invoice_count());
+        count = administration::invoice_count();
+        ASSERT_EQ(administration::invoice_add(&inv), A_ERR_SUCCESS);
+        ASSERT_EQ(count+1, administration::invoice_count());
     }
 
     administration_reader::open_existing(test_file_path);
     {
-        ASSERT_EQ(count+1, administration_invoice_count());
-        ASSERT_EQ(A_ERR_SUCCESS, administration_invoice_get_by_id(&invr, inv.id));
+        ASSERT_EQ(count+1, administration::invoice_count());
+        ASSERT_EQ(A_ERR_SUCCESS, administration::invoice_get_by_id(&invr, inv.id));
 
         CHECK_CALL(_assert_invoices_are_equal(inv, invr));
     }
@@ -322,9 +322,9 @@ TEST _administration_rw_b2b2c_invoice(void)
 
     administration_writer::create();
 
-    administration_create_default(test_file_path);
+    administration::create_default(test_file_path);
     {
-        inv = administration_invoice_create_empty();
+        inv = administration::invoice_create_empty();
         inv.supplier = _create_nl_business();
         inv.customer = _create_nl_business();
         strops::copy(inv.addressee.name, "Piet Pinda", sizeof(inv.addressee.name));
@@ -336,20 +336,20 @@ TEST _administration_rw_b2b2c_invoice(void)
         inv.delivered_at = inv.issued_at;
         inv.expires_at = inv.issued_at + 1000;
 
-        administration_billing_item_add_to_invoice(&inv, _create_bi3(&inv));
-        administration_billing_item_add_to_invoice(&inv, _create_bi4(&inv));
-        administration_billing_item_add_to_invoice(&inv, _create_bi5(&inv));
-        administration_billing_item_add_to_invoice(&inv, _create_bi6(&inv));
+        administration::billing_item_add_to_invoice(&inv, _create_bi3(&inv));
+        administration::billing_item_add_to_invoice(&inv, _create_bi4(&inv));
+        administration::billing_item_add_to_invoice(&inv, _create_bi5(&inv));
+        administration::billing_item_add_to_invoice(&inv, _create_bi6(&inv));
 
-        count = administration_invoice_count();
-        ASSERT_EQ(administration_invoice_add(&inv), A_ERR_SUCCESS);
-        ASSERT_EQ(count+1, administration_invoice_count());
+        count = administration::invoice_count();
+        ASSERT_EQ(administration::invoice_add(&inv), A_ERR_SUCCESS);
+        ASSERT_EQ(count+1, administration::invoice_count());
     }
 
     administration_reader::open_existing(test_file_path);
     {
-        ASSERT_EQ(count+1, administration_invoice_count());
-        ASSERT_EQ(A_ERR_SUCCESS, administration_invoice_get_by_id(&invr, inv.id));
+        ASSERT_EQ(count+1, administration::invoice_count());
+        ASSERT_EQ(A_ERR_SUCCESS, administration::invoice_get_by_id(&invr, inv.id));
 
         CHECK_CALL(_assert_invoices_are_equal(inv, invr));
     }
@@ -365,12 +365,12 @@ TEST _administration_rw_b2c_2currency_invoice(void)
 
     administration_writer::create();
 
-    administration_create_default(test_file_path);
+    administration::create_default(test_file_path);
     {
         contact pw1 = _create_nl_business();
         contact pw2 = _create_nl_consumer();
 
-        inv = administration_invoice_create_empty();
+        inv = administration::invoice_create_empty();
         inv.supplier = pw1;
         inv.customer = pw2;
         inv.is_outgoing = 1;
@@ -379,12 +379,12 @@ TEST _administration_rw_b2c_2currency_invoice(void)
         inv.delivered_at = inv.issued_at;
         inv.expires_at = inv.issued_at + 1000;
 
-        administration_invoice_set_currency(&inv, "USD");
+        administration::invoice_set_currency(&inv, "USD");
 
-        administration_billing_item_add_to_invoice(&inv, _create_bi3(&inv));
-        administration_billing_item_add_to_invoice(&inv, _create_bi4(&inv));
-        administration_billing_item_add_to_invoice(&inv, _create_bi5(&inv));
-        administration_billing_item_add_to_invoice(&inv, _create_bi6(&inv));
+        administration::billing_item_add_to_invoice(&inv, _create_bi3(&inv));
+        administration::billing_item_add_to_invoice(&inv, _create_bi4(&inv));
+        administration::billing_item_add_to_invoice(&inv, _create_bi5(&inv));
+        administration::billing_item_add_to_invoice(&inv, _create_bi6(&inv));
 
         // Finals are set manually for multi currency invoices.
         inv.total = 20.0f;
@@ -392,15 +392,15 @@ TEST _administration_rw_b2c_2currency_invoice(void)
         inv.net = 10.0f;
         inv.allowance = 5.0f;
 
-        count = administration_invoice_count();
-        ASSERT_EQ(administration_invoice_add(&inv), A_ERR_SUCCESS);
-        ASSERT_EQ(count+1, administration_invoice_count());
+        count = administration::invoice_count();
+        ASSERT_EQ(administration::invoice_add(&inv), A_ERR_SUCCESS);
+        ASSERT_EQ(count+1, administration::invoice_count());
     }
 
     administration_reader::open_existing(test_file_path);
     {
-        ASSERT_EQ(count+1, administration_invoice_count());
-        ASSERT_EQ(A_ERR_SUCCESS, administration_invoice_get_by_id(&invr, inv.id));
+        ASSERT_EQ(count+1, administration::invoice_count());
+        ASSERT_EQ(A_ERR_SUCCESS, administration::invoice_get_by_id(&invr, inv.id));
 
         CHECK_CALL(_assert_invoices_are_equal(inv, invr));
     }
diff --git a/tests/administration_validation_tests.cpp b/tests/administration_validation_tests.cpp
index 3803469..7ebe48e 100644
--- a/tests/administration_validation_tests.cpp
+++ b/tests/administration_validation_tests.cpp
@@ -3,26 +3,26 @@
 //////////////////
 TEST _administration_validate_project_add(void)
 {
-    administration_create_empty("");
-    project p1 = administration_project_create_empty(); 
+    administration::create_empty("");
+    project p1 = administration::project_create_empty(); 
     
-    ASSERT_EQ(administration_project_add(p1), A_ERR_MISSING_DESCRIPTION);
+    ASSERT_EQ(administration::project_add(p1), A_ERR_MISSING_DESCRIPTION);
 
     strops::copy(p1.description, "test project", sizeof(p1.description));
-    ASSERT_EQ(administration_project_add(p1), A_ERR_SUCCESS);
+    ASSERT_EQ(administration::project_add(p1), A_ERR_SUCCESS);
     
     PASS();
 }
 
 TEST _administration_validate_project_import(void)
 {
-    administration_create_empty("");
-    project p1 = administration_project_create_empty(); 
+    administration::create_empty("");
+    project p1 = administration::project_create_empty(); 
     
-    ASSERT_EQ(administration_project_import(p1), A_ERR_MISSING_DESCRIPTION);
+    ASSERT_EQ(administration::project_import(p1), A_ERR_MISSING_DESCRIPTION);
 
     strops::copy(p1.description, "test project", sizeof(p1.description));
-    ASSERT_EQ(administration_project_import(p1), A_ERR_SUCCESS);
+    ASSERT_EQ(administration::project_import(p1), A_ERR_SUCCESS);
     
     PASS();
 }
@@ -30,49 +30,49 @@ TEST _administration_validate_project_import(void)
 
 TEST _administration_validate_project_update(void)
 {
-    administration_create_empty("");
-    project p1 = administration_project_create_empty(); 
+    administration::create_empty("");
+    project p1 = administration::project_create_empty(); 
 
     strops::copy(p1.description, "test project", sizeof(p1.description));
-    ASSERT_EQ(administration_project_add(p1), A_ERR_SUCCESS);
-    ASSERT_EQ(administration_project_update(p1), A_ERR_SUCCESS);
+    ASSERT_EQ(administration::project_add(p1), A_ERR_SUCCESS);
+    ASSERT_EQ(administration::project_update(p1), A_ERR_SUCCESS);
 
     strops::copy(p1.description, "", sizeof(p1.description));
-    ASSERT_EQ(administration_project_update(p1), A_ERR_MISSING_DESCRIPTION);
+    ASSERT_EQ(administration::project_update(p1), A_ERR_MISSING_DESCRIPTION);
 
     strops::copy(p1.id, "-1", sizeof(p1.id));
     strops::copy(p1.description, "test project 2", sizeof(p1.description));
-    ASSERT_EQ(administration_project_update(p1), A_ERR_NOT_FOUND);
+    ASSERT_EQ(administration::project_update(p1), A_ERR_NOT_FOUND);
     
     PASS();
 }
 
 TEST _administration_validate_project_remove(void)
 {
-    administration_create_empty("");
-    project p1 = administration_project_create_empty(); 
+    administration::create_empty("");
+    project p1 = administration::project_create_empty(); 
 
     strops::copy(p1.description, "test project", sizeof(p1.description));
-    ASSERT_EQ(administration_project_add(p1), A_ERR_SUCCESS);
+    ASSERT_EQ(administration::project_add(p1), A_ERR_SUCCESS);
 
-    ASSERT_EQ(administration_project_remove(p1), A_ERR_SUCCESS);
+    ASSERT_EQ(administration::project_remove(p1), A_ERR_SUCCESS);
 
-    ASSERT_EQ(administration_project_add(p1), A_ERR_SUCCESS);
+    ASSERT_EQ(administration::project_add(p1), A_ERR_SUCCESS);
     strops::copy(p1.id, "-1", sizeof(p1.id));
-    ASSERT_EQ(administration_project_remove(p1), A_ERR_NOT_FOUND);
+    ASSERT_EQ(administration::project_remove(p1), A_ERR_NOT_FOUND);
     
     PASS();
 }
 
 TEST _administration_validate_project_isvalid(void)
 {
-    administration_create_empty("");
-    project p1 = administration_project_create_empty(); 
+    administration::create_empty("");
+    project p1 = administration::project_create_empty(); 
     
-    ASSERT_EQ(administration_project_is_valid(p1), A_ERR_MISSING_DESCRIPTION);
+    ASSERT_EQ(administration::project_is_valid(p1), A_ERR_MISSING_DESCRIPTION);
 
     strops::copy(p1.description, "test project", sizeof(p1.description));
-    ASSERT_EQ(administration_project_is_valid(p1), A_ERR_SUCCESS);
+    ASSERT_EQ(administration::project_is_valid(p1), A_ERR_SUCCESS);
     
     PASS();
 }
@@ -81,20 +81,20 @@ TEST _administration_validate_project_isvalid(void)
 //////////////////
 TEST _administration_validate_taxrate_add(void)
 {
-    administration_create_empty("");
-    tax_rate p1 = administration_tax_rate_create_empty(); 
+    administration::create_empty("");
+    tax_rate p1 = administration::tax_rate_create_empty(); 
     
-    ASSERT_EQ(administration_tax_rate_add(p1), A_ERR_SUCCESS);   
+    ASSERT_EQ(administration::tax_rate_add(p1), A_ERR_SUCCESS);   
 
     PASS();
 }
 
 TEST _administration_validate_taxrate_import(void)
 {
-    administration_create_empty("");
-    tax_rate p1 = administration_tax_rate_create_empty(); 
+    administration::create_empty("");
+    tax_rate p1 = administration::tax_rate_create_empty(); 
     
-    ASSERT_EQ(administration_tax_rate_import(p1), A_ERR_SUCCESS);   
+    ASSERT_EQ(administration::tax_rate_import(p1), A_ERR_SUCCESS);   
 
     PASS();
 }
@@ -102,14 +102,14 @@ TEST _administration_validate_taxrate_import(void)
 
 TEST _administration_validate_taxrate_update(void)
 {
-    administration_create_empty("");
-    tax_rate p1 = administration_tax_rate_create_empty(); 
+    administration::create_empty("");
+    tax_rate p1 = administration::tax_rate_create_empty(); 
     
-    ASSERT_EQ(administration_tax_rate_add(p1), A_ERR_SUCCESS);
-    ASSERT_EQ(administration_tax_rate_update(p1), A_ERR_SUCCESS);
+    ASSERT_EQ(administration::tax_rate_add(p1), A_ERR_SUCCESS);
+    ASSERT_EQ(administration::tax_rate_update(p1), A_ERR_SUCCESS);
 
     strops::copy(p1.id, "-1", sizeof(p1.id));
-    ASSERT_EQ(administration_tax_rate_update(p1), A_ERR_NOT_FOUND);
+    ASSERT_EQ(administration::tax_rate_update(p1), A_ERR_NOT_FOUND);
 
     PASS();
 }
@@ -118,34 +118,34 @@ TEST _administration_validate_taxrate_update(void)
 //////////////////
 TEST _administration_validate_costcenter_add(void)
 {
-    administration_create_empty("");
-    cost_center p1 = administration_cost_center_create_empty(); 
+    administration::create_empty("");
+    cost_center p1 = administration::cost_center_create_empty(); 
     strops::copy(p1.code, "TEST", sizeof(p1.code));
     strops::copy(p1.description, "description", sizeof(p1.description));
-    ASSERT_EQ(administration_cost_center_add(p1), A_ERR_SUCCESS);
+    ASSERT_EQ(administration::cost_center_add(p1), A_ERR_SUCCESS);
 
-    ASSERT_EQ(administration_cost_center_add(p1), A_ERR_CODE_EXISTS);
+    ASSERT_EQ(administration::cost_center_add(p1), A_ERR_CODE_EXISTS);
     strops::copy(p1.code, "", sizeof(p1.code));
-    ASSERT_EQ(administration_cost_center_add(p1), A_ERR_MISSING_CODE);
+    ASSERT_EQ(administration::cost_center_add(p1), A_ERR_MISSING_CODE);
     strops::copy(p1.description, "", sizeof(p1.description));
-    ASSERT_EQ(administration_cost_center_add(p1), A_ERR_MISSING_CODE|A_ERR_MISSING_DESCRIPTION);
+    ASSERT_EQ(administration::cost_center_add(p1), A_ERR_MISSING_CODE|A_ERR_MISSING_DESCRIPTION);
 
     PASS();
 }
 
 TEST _administration_validate_costcenter_import(void)
 {
-    administration_create_empty("");
-    cost_center p1 = administration_cost_center_create_empty(); 
+    administration::create_empty("");
+    cost_center p1 = administration::cost_center_create_empty(); 
     strops::copy(p1.code, "TEST", sizeof(p1.code));
     strops::copy(p1.description, "description", sizeof(p1.description));
-    ASSERT_EQ(administration_cost_center_import(p1), A_ERR_SUCCESS);
+    ASSERT_EQ(administration::cost_center_import(p1), A_ERR_SUCCESS);
 
-    ASSERT_EQ(administration_cost_center_import(p1), A_ERR_CODE_EXISTS);
+    ASSERT_EQ(administration::cost_center_import(p1), A_ERR_CODE_EXISTS);
     strops::copy(p1.code, "", sizeof(p1.code));
-    ASSERT_EQ(administration_cost_center_import(p1), A_ERR_MISSING_CODE);
+    ASSERT_EQ(administration::cost_center_import(p1), A_ERR_MISSING_CODE);
     strops::copy(p1.description, "", sizeof(p1.description));
-    ASSERT_EQ(administration_cost_center_import(p1), A_ERR_MISSING_CODE|A_ERR_MISSING_DESCRIPTION);
+    ASSERT_EQ(administration::cost_center_import(p1), A_ERR_MISSING_CODE|A_ERR_MISSING_DESCRIPTION);
 
     PASS();
 }
@@ -153,46 +153,46 @@ TEST _administration_validate_costcenter_import(void)
 
 TEST _administration_validate_costcenter_update(void)
 {
-    administration_create_empty("");
-    cost_center p1 = administration_cost_center_create_empty(); 
+    administration::create_empty("");
+    cost_center p1 = administration::cost_center_create_empty(); 
     strops::copy(p1.code, "TEST", sizeof(p1.code));
     strops::copy(p1.description, "description", sizeof(p1.description));
-    ASSERT_EQ(administration_cost_center_add(p1), A_ERR_SUCCESS);
-    ASSERT_EQ(administration_cost_center_update(p1), A_ERR_SUCCESS);
+    ASSERT_EQ(administration::cost_center_add(p1), A_ERR_SUCCESS);
+    ASSERT_EQ(administration::cost_center_update(p1), A_ERR_SUCCESS);
 
     strops::copy(p1.code, "", sizeof(p1.code));
-    ASSERT_EQ(administration_cost_center_update(p1), A_ERR_MISSING_CODE);
+    ASSERT_EQ(administration::cost_center_update(p1), A_ERR_MISSING_CODE);
     strops::copy(p1.description, "", sizeof(p1.description));
-    ASSERT_EQ(administration_cost_center_update(p1), A_ERR_MISSING_CODE|A_ERR_MISSING_DESCRIPTION);
+    ASSERT_EQ(administration::cost_center_update(p1), A_ERR_MISSING_CODE|A_ERR_MISSING_DESCRIPTION);
 
     strops::copy(p1.id, "-1", sizeof(p1.id));
     strops::copy(p1.code, "TEST", sizeof(p1.code));
     strops::copy(p1.description, "description", sizeof(p1.description));
-    ASSERT_EQ(administration_cost_center_update(p1), A_ERR_NOT_FOUND);
+    ASSERT_EQ(administration::cost_center_update(p1), A_ERR_NOT_FOUND);
 
     PASS();
 }
 
 TEST _administration_validate_costcenter_isvalid(void)
 {
-    administration_create_empty("");
-    cost_center p1 = administration_cost_center_create_empty(); 
+    administration::create_empty("");
+    cost_center p1 = administration::cost_center_create_empty(); 
     strops::copy(p1.code, "TEST", sizeof(p1.code));
     strops::copy(p1.description, "description", sizeof(p1.description));
   
-    ASSERT_EQ(administration_cost_center_is_valid(p1), A_ERR_SUCCESS);
+    ASSERT_EQ(administration::cost_center_is_valid(p1), A_ERR_SUCCESS);
 
     strops::copy(p1.code, "", sizeof(p1.code));
-    ASSERT_EQ(administration_cost_center_is_valid(p1), A_ERR_MISSING_CODE);
+    ASSERT_EQ(administration::cost_center_is_valid(p1), A_ERR_MISSING_CODE);
     
     strops::copy(p1.code, "", sizeof(p1.code));
     strops::copy(p1.description, "", sizeof(p1.description));
-    ASSERT_EQ(administration_cost_center_is_valid(p1), A_ERR_MISSING_CODE|A_ERR_MISSING_DESCRIPTION);
+    ASSERT_EQ(administration::cost_center_is_valid(p1), A_ERR_MISSING_CODE|A_ERR_MISSING_DESCRIPTION);
 
     strops::copy(p1.code, "TEST", sizeof(p1.code));
     strops::copy(p1.description, "description", sizeof(p1.description));
-    ASSERT_EQ(administration_cost_center_add(p1), A_ERR_SUCCESS);
-    ASSERT_EQ(administration_cost_center_is_valid(p1), A_ERR_CODE_EXISTS);
+    ASSERT_EQ(administration::cost_center_add(p1), A_ERR_SUCCESS);
+    ASSERT_EQ(administration::cost_center_is_valid(p1), A_ERR_CODE_EXISTS);
 
     PASS();
 }
@@ -202,7 +202,7 @@ TEST _administration_validate_costcenter_isvalid(void)
 //////////////////
 contact _create_test_contact()
 {
-    contact p1 = administration_contact_create_empty();
+    contact p1 = administration::contact_create_empty();
     strops::copy(p1.name, "John Johnsson", sizeof(p1.name));
     strops::copy(p1.address.address1, "Address 1", sizeof(p1.address.address1));
     strops::copy(p1.address.country_code, "FR", sizeof(p1.address.country_code));
@@ -215,24 +215,24 @@ contact _create_test_contact()
 
 TEST _administration_validate_contact_add(void)
 {
-    administration_create_empty("");
+    administration::create_empty("");
     contact p1 = _create_test_contact();
     
-    ASSERT_EQ(administration_contact_add(p1), A_ERR_SUCCESS);
+    ASSERT_EQ(administration::contact_add(p1), A_ERR_SUCCESS);
 
     strops::copy(p1.name, "", sizeof(p1.name));
-    ASSERT_EQ(administration_contact_add(p1), A_ERR_MISSING_NAME);
+    ASSERT_EQ(administration::contact_add(p1), A_ERR_MISSING_NAME);
     strops::copy(p1.address.address1, "", sizeof(p1.address.address1));
-    ASSERT_EQ(administration_contact_add(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1);
+    ASSERT_EQ(administration::contact_add(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1);
     strops::copy(p1.address.city, "", sizeof(p1.address.city));
-    ASSERT_EQ(administration_contact_add(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY);
+    ASSERT_EQ(administration::contact_add(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY);
     strops::copy(p1.address.postal, "", sizeof(p1.address.postal));
-    ASSERT_EQ(administration_contact_add(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY|A_ERR_MISSING_POSTAL);
+    ASSERT_EQ(administration::contact_add(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY|A_ERR_MISSING_POSTAL);
     strops::copy(p1.address.country_code, "", sizeof(p1.address.country_code));
-    ASSERT_EQ(administration_contact_add(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY|A_ERR_MISSING_POSTAL|A_ERR_MISSING_COUNTRYCODE);
+    ASSERT_EQ(administration::contact_add(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY|A_ERR_MISSING_POSTAL|A_ERR_MISSING_COUNTRYCODE);
 
     p1.type = contact_type::CONTACT_BUSINESS;
-    ASSERT_EQ(administration_contact_add(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY|
+    ASSERT_EQ(administration::contact_add(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY|
                                             A_ERR_MISSING_POSTAL|A_ERR_MISSING_COUNTRYCODE|A_ERR_MISSING_TAXID|A_ERR_MISSING_BUSINESSID);
     
     PASS();
@@ -241,24 +241,24 @@ TEST _administration_validate_contact_add(void)
 TEST _administration_validate_contact_import(void)
 {
 
-    administration_create_empty("");
+    administration::create_empty("");
     contact p1 = _create_test_contact();
     
-    ASSERT_EQ(administration_contact_import(p1), A_ERR_SUCCESS);
+    ASSERT_EQ(administration::contact_import(p1), A_ERR_SUCCESS);
 
     strops::copy(p1.name, "", sizeof(p1.name));
-    ASSERT_EQ(administration_contact_import(p1), A_ERR_MISSING_NAME);
+    ASSERT_EQ(administration::contact_import(p1), A_ERR_MISSING_NAME);
     strops::copy(p1.address.address1, "", sizeof(p1.address.address1));
-    ASSERT_EQ(administration_contact_import(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1);
+    ASSERT_EQ(administration::contact_import(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1);
     strops::copy(p1.address.city, "", sizeof(p1.address.city));
-    ASSERT_EQ(administration_contact_import(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY);
+    ASSERT_EQ(administration::contact_import(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY);
     strops::copy(p1.address.postal, "", sizeof(p1.address.postal));
-    ASSERT_EQ(administration_contact_import(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY|A_ERR_MISSING_POSTAL);
+    ASSERT_EQ(administration::contact_import(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY|A_ERR_MISSING_POSTAL);
     strops::copy(p1.address.country_code, "", sizeof(p1.address.country_code));
-    ASSERT_EQ(administration_contact_import(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY|A_ERR_MISSING_POSTAL|A_ERR_MISSING_COUNTRYCODE);
+    ASSERT_EQ(administration::contact_import(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY|A_ERR_MISSING_POSTAL|A_ERR_MISSING_COUNTRYCODE);
 
     p1.type = contact_type::CONTACT_BUSINESS;
-    ASSERT_EQ(administration_contact_import(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY|
+    ASSERT_EQ(administration::contact_import(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY|
                                             A_ERR_MISSING_POSTAL|A_ERR_MISSING_COUNTRYCODE|A_ERR_MISSING_TAXID|A_ERR_MISSING_BUSINESSID);
     
     PASS();
@@ -267,25 +267,25 @@ TEST _administration_validate_contact_import(void)
 
 TEST _administration_validate_contact_update(void)
 {
-    administration_create_empty("");
+    administration::create_empty("");
     contact p1 = _create_test_contact();
     
-    ASSERT_EQ(administration_contact_add(p1), A_ERR_SUCCESS);
-    ASSERT_EQ(administration_contact_update(p1), A_ERR_SUCCESS);
+    ASSERT_EQ(administration::contact_add(p1), A_ERR_SUCCESS);
+    ASSERT_EQ(administration::contact_update(p1), A_ERR_SUCCESS);
 
     strops::copy(p1.name, "", sizeof(p1.name));
-    ASSERT_EQ(administration_contact_update(p1), A_ERR_MISSING_NAME);
+    ASSERT_EQ(administration::contact_update(p1), A_ERR_MISSING_NAME);
     strops::copy(p1.address.address1, "", sizeof(p1.address.address1));
-    ASSERT_EQ(administration_contact_update(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1);
+    ASSERT_EQ(administration::contact_update(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1);
     strops::copy(p1.address.city, "", sizeof(p1.address.city));
-    ASSERT_EQ(administration_contact_update(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY);
+    ASSERT_EQ(administration::contact_update(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY);
     strops::copy(p1.address.postal, "", sizeof(p1.address.postal));
-    ASSERT_EQ(administration_contact_update(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY|A_ERR_MISSING_POSTAL);
+    ASSERT_EQ(administration::contact_update(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY|A_ERR_MISSING_POSTAL);
     strops::copy(p1.address.country_code, "", sizeof(p1.address.country_code));
-    ASSERT_EQ(administration_contact_update(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY|A_ERR_MISSING_POSTAL|A_ERR_MISSING_COUNTRYCODE);
+    ASSERT_EQ(administration::contact_update(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY|A_ERR_MISSING_POSTAL|A_ERR_MISSING_COUNTRYCODE);
 
     p1.type = contact_type::CONTACT_BUSINESS;
-    ASSERT_EQ(administration_contact_update(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY|
+    ASSERT_EQ(administration::contact_update(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY|
                                             A_ERR_MISSING_POSTAL|A_ERR_MISSING_COUNTRYCODE|A_ERR_MISSING_TAXID|A_ERR_MISSING_BUSINESSID);
     
     strops::copy(p1.id, "-1", sizeof(p1.id));
@@ -295,48 +295,48 @@ TEST _administration_validate_contact_update(void)
     strops::copy(p1.address.city, "Paris", sizeof(p1.address.city));
     strops::copy(p1.address.postal, "12345", sizeof(p1.address.postal));
     p1.type = contact_type::CONTACT_CONSUMER;
-    ASSERT_EQ(administration_contact_update(p1), A_ERR_NOT_FOUND);
+    ASSERT_EQ(administration::contact_update(p1), A_ERR_NOT_FOUND);
 
     PASS();
 }
 
 TEST _administration_validate_contact_remove(void)
 {
-    administration_create_empty("");
+    administration::create_empty("");
     contact p1 = _create_test_contact();
     
-    ASSERT_EQ(administration_contact_add(p1), A_ERR_SUCCESS);
+    ASSERT_EQ(administration::contact_add(p1), A_ERR_SUCCESS);
 
-    ASSERT_EQ(administration_contact_remove(p1), A_ERR_SUCCESS);
+    ASSERT_EQ(administration::contact_remove(p1), A_ERR_SUCCESS);
 
-    ASSERT_EQ(administration_contact_add(p1), A_ERR_SUCCESS);
+    ASSERT_EQ(administration::contact_add(p1), A_ERR_SUCCESS);
     strops::copy(p1.id, "-1", sizeof(p1.id));
-    ASSERT_EQ(administration_contact_remove(p1), A_ERR_NOT_FOUND);
+    ASSERT_EQ(administration::contact_remove(p1), A_ERR_NOT_FOUND);
 
     PASS();
 }
 
 TEST _administration_validate_contact_isvalid(void)
 {
-    administration_create_empty("");
+    administration::create_empty("");
     contact p1 = _create_test_contact();
     
-    ASSERT_EQ(administration_contact_is_valid(p1), A_ERR_SUCCESS);
-    ASSERT_EQ(administration_contact_is_valid(p1), A_ERR_SUCCESS);
+    ASSERT_EQ(administration::contact_is_valid(p1), A_ERR_SUCCESS);
+    ASSERT_EQ(administration::contact_is_valid(p1), A_ERR_SUCCESS);
 
     strops::copy(p1.name, "", sizeof(p1.name));
-    ASSERT_EQ(administration_contact_is_valid(p1), A_ERR_MISSING_NAME);
+    ASSERT_EQ(administration::contact_is_valid(p1), A_ERR_MISSING_NAME);
     strops::copy(p1.address.address1, "", sizeof(p1.address.address1));
-    ASSERT_EQ(administration_contact_is_valid(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1);
+    ASSERT_EQ(administration::contact_is_valid(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1);
     strops::copy(p1.address.city, "", sizeof(p1.address.city));
-    ASSERT_EQ(administration_contact_is_valid(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY);
+    ASSERT_EQ(administration::contact_is_valid(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY);
     strops::copy(p1.address.postal, "", sizeof(p1.address.postal));
-    ASSERT_EQ(administration_contact_is_valid(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY|A_ERR_MISSING_POSTAL);
+    ASSERT_EQ(administration::contact_is_valid(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY|A_ERR_MISSING_POSTAL);
     strops::copy(p1.address.country_code, "", sizeof(p1.address.country_code));
-    ASSERT_EQ(administration_contact_is_valid(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY|A_ERR_MISSING_POSTAL|A_ERR_MISSING_COUNTRYCODE);
+    ASSERT_EQ(administration::contact_is_valid(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY|A_ERR_MISSING_POSTAL|A_ERR_MISSING_COUNTRYCODE);
 
     p1.type = contact_type::CONTACT_BUSINESS;
-    ASSERT_EQ(administration_contact_is_valid(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY|
+    ASSERT_EQ(administration::contact_is_valid(p1), A_ERR_MISSING_NAME|A_ERR_MISSING_ADDRESS1|A_ERR_MISSING_CITY|
                                             A_ERR_MISSING_POSTAL|A_ERR_MISSING_COUNTRYCODE|A_ERR_MISSING_TAXID|A_ERR_MISSING_BUSINESSID);
 
     PASS();
diff --git a/tests/peppol_write_tests.cpp b/tests/peppol_write_tests.cpp
index fd137b5..7caa102 100644
--- a/tests/peppol_write_tests.cpp
+++ b/tests/peppol_write_tests.cpp
@@ -5,9 +5,9 @@
 TEST _peppol_write_nl2nl_b2b(void)
 {
     administration_writer::create();
-    administration_create_default(test_file_path);
+    administration::create_default(test_file_path);
     
-    invoice inv = administration_invoice_create_empty();
+    invoice inv = administration::invoice_create_empty();
     inv.supplier = _create_nl_business();
     inv.customer = _create_nl_business();
     inv.is_outgoing = 1;
@@ -16,9 +16,9 @@ TEST _peppol_write_nl2nl_b2b(void)
     inv.delivered_at = inv.issued_at;
     inv.expires_at = inv.issued_at + 1000;
 
-    administration_billing_item_add_to_invoice(&inv, _create_bi1(&inv));
-    administration_billing_item_add_to_invoice(&inv, _create_bi2(&inv));
-    ASSERT_EQ(administration_invoice_add(&inv), A_ERR_SUCCESS);
+    administration::billing_item_add_to_invoice(&inv, _create_bi1(&inv));
+    administration::billing_item_add_to_invoice(&inv, _create_bi2(&inv));
+    ASSERT_EQ(administration::invoice_add(&inv), A_ERR_SUCCESS);
 
     if (_test_peppol_file(inv.id)) { PASS(); } else { FAIL(); }
 }
@@ -26,9 +26,9 @@ TEST _peppol_write_nl2nl_b2b(void)
 TEST _peppol_write_nl2nl_b2c(void)
 {
     administration_writer::create();
-    administration_create_default(test_file_path);
+    administration::create_default(test_file_path);
     
-    invoice inv = administration_invoice_create_empty();
+    invoice inv = administration::invoice_create_empty();
     inv.supplier = _create_nl_business();
     inv.customer = _create_nl_consumer();
     inv.is_outgoing = 1;
@@ -37,9 +37,9 @@ TEST _peppol_write_nl2nl_b2c(void)
     inv.delivered_at = inv.issued_at;
     inv.expires_at = inv.issued_at + 1000;
 
-    administration_billing_item_add_to_invoice(&inv, _create_bi1(&inv));
-    administration_billing_item_add_to_invoice(&inv, _create_bi2(&inv));
-    ASSERT_EQ(administration_invoice_add(&inv), A_ERR_SUCCESS);
+    administration::billing_item_add_to_invoice(&inv, _create_bi1(&inv));
+    administration::billing_item_add_to_invoice(&inv, _create_bi2(&inv));
+    ASSERT_EQ(administration::invoice_add(&inv), A_ERR_SUCCESS);
 
     if (_test_peppol_file(inv.id)) { PASS(); } else { FAIL(); }
 }
diff --git a/tests/test_helper.cpp b/tests/test_helper.cpp
index 38aa655..f0b0d66 100644
--- a/tests/test_helper.cpp
+++ b/tests/test_helper.cpp
@@ -21,7 +21,7 @@ char* extract_dir = "build\\extracted";
 
 static contact _create_nl_business()
 {
-    contact pw = administration_contact_create_empty();
+    contact pw = administration::contact_create_empty();
     strops::copy(pw.name, "Dutch Company BV", sizeof(pw.name));
     strops::copy(pw.address.address1, "Address 1", sizeof(pw.address.address1));
     strops::copy(pw.address.country_code, "NL", sizeof(pw.address.country_code));
@@ -39,7 +39,7 @@ static contact _create_nl_business()
 
 static contact _create_nl_consumer()
 {
-    contact pw = administration_contact_create_empty();
+    contact pw = administration::contact_create_empty();
     strops::copy(pw.name, "Piet Pinda", sizeof(pw.name));
     strops::copy(pw.address.address1, "Address 2", sizeof(pw.address.address1));
     strops::copy(pw.address.country_code, "NL", sizeof(pw.address.country_code));
@@ -55,7 +55,7 @@ static contact _create_nl_consumer()
 
 static billing_item _create_bi1(invoice *inv)
 {
-    billing_item item = administration_billing_item_create_empty();
+    billing_item item = administration::billing_item_create_empty();
     item.amount = 1;
     item.amount_is_percentage = 0;
     strops::copy(item.description, "Shampoo", MAX_LEN_LONG_DESC);
@@ -65,7 +65,7 @@ static billing_item _create_bi1(invoice *inv)
 
     tax_rate buffer[20];
     char* _country_codes[2] = {inv->supplier.address.country_code, inv->customer.address.country_code};
-    u32 tax_rate_count = administration_tax_rate_get_by_country(buffer, 2, _country_codes);
+    u32 tax_rate_count = administration::tax_rate_get_by_country(buffer, 2, _country_codes);
     tax_rate rand_rate = buffer[tax_rate_count-1];
     strops::copy(item.tax_rate_id, rand_rate.id, MAX_LEN_ID);
 
@@ -74,7 +74,7 @@ static billing_item _create_bi1(invoice *inv)
 
 static billing_item _create_bi2(invoice *inv)
 {
-    billing_item item = administration_billing_item_create_empty();
+    billing_item item = administration::billing_item_create_empty();
     item.amount = 2;
     item.amount_is_percentage = 0;
     strops::copy(item.description, "Soap", MAX_LEN_LONG_DESC);
@@ -84,7 +84,7 @@ static billing_item _create_bi2(invoice *inv)
 
     tax_rate buffer[20];
     char* _country_codes[2] = {inv->supplier.address.country_code, inv->customer.address.country_code};
-    u32 tax_rate_count = administration_tax_rate_get_by_country(buffer, 2, _country_codes);
+    u32 tax_rate_count = administration::tax_rate_get_by_country(buffer, 2, _country_codes);
     tax_rate rand_rate = buffer[tax_rate_count-1];
     strops::copy(item.tax_rate_id, rand_rate.id, MAX_LEN_ID);
 
@@ -93,7 +93,7 @@ static billing_item _create_bi2(invoice *inv)
 
 static billing_item _create_bi3(invoice *inv)
 {
-    billing_item item = administration_billing_item_create_empty();
+    billing_item item = administration::billing_item_create_empty();
     item.amount = 1;
     item.amount_is_percentage = 0;
     strops::copy(item.description, "Guacamole", MAX_LEN_LONG_DESC);
@@ -103,7 +103,7 @@ static billing_item _create_bi3(invoice *inv)
 
     tax_rate buffer[20];
     char* _country_codes[2] = {inv->supplier.address.country_code, inv->customer.address.country_code};
-    u32 tax_rate_count = administration_tax_rate_get_by_country(buffer, 2, _country_codes);
+    u32 tax_rate_count = administration::tax_rate_get_by_country(buffer, 2, _country_codes);
     tax_rate rand_rate = buffer[tax_rate_count-1];
     strops::copy(item.tax_rate_id, rand_rate.id, MAX_LEN_ID);
 
@@ -112,7 +112,7 @@ static billing_item _create_bi3(invoice *inv)
 
 static billing_item _create_bi4(invoice *inv)
 {
-    billing_item item = administration_billing_item_create_empty();
+    billing_item item = administration::billing_item_create_empty();
     item.amount = 3;
     item.amount_is_percentage = 0;
     strops::copy(item.description, "Bananas", MAX_LEN_LONG_DESC);
@@ -122,7 +122,7 @@ static billing_item _create_bi4(invoice *inv)
 
     tax_rate buffer[20];
     char* _country_codes[2] = {inv->supplier.address.country_code, inv->customer.address.country_code};
-    u32 tax_rate_count = administration_tax_rate_get_by_country(buffer, 2, _country_codes);
+    u32 tax_rate_count = administration::tax_rate_get_by_country(buffer, 2, _country_codes);
     tax_rate rand_rate = buffer[tax_rate_count-1];
     strops::copy(item.tax_rate_id, rand_rate.id, MAX_LEN_ID);
 
@@ -131,7 +131,7 @@ static billing_item _create_bi4(invoice *inv)
 
 static billing_item _create_bi5(invoice *inv)
 {
-    billing_item item = administration_billing_item_create_empty();
+    billing_item item = administration::billing_item_create_empty();
     item.amount = 5;
     item.amount_is_percentage = 0;
     strops::copy(item.description, "Apple", MAX_LEN_LONG_DESC);
@@ -141,7 +141,7 @@ static billing_item _create_bi5(invoice *inv)
 
     tax_rate buffer[20];
     char* _country_codes[2] = {inv->supplier.address.country_code, inv->customer.address.country_code};
-    u32 tax_rate_count = administration_tax_rate_get_by_country(buffer, 2, _country_codes);
+    u32 tax_rate_count = administration::tax_rate_get_by_country(buffer, 2, _country_codes);
     tax_rate rand_rate = buffer[tax_rate_count-1];
     strops::copy(item.tax_rate_id, rand_rate.id, MAX_LEN_ID);
 
@@ -150,7 +150,7 @@ static billing_item _create_bi5(invoice *inv)
 
 static billing_item _create_bi6(invoice *inv)
 {
-    billing_item item = administration_billing_item_create_empty();
+    billing_item item = administration::billing_item_create_empty();
     item.amount = 10;
     item.amount_is_percentage = 1;
     strops::copy(item.description, "Tip", MAX_LEN_LONG_DESC);
@@ -160,7 +160,7 @@ static billing_item _create_bi6(invoice *inv)
 
     tax_rate buffer[20];
     char* _country_codes[2] = {inv->supplier.address.country_code, inv->customer.address.country_code};
-    u32 tax_rate_count = administration_tax_rate_get_by_country(buffer, 2, _country_codes);
+    u32 tax_rate_count = administration::tax_rate_get_by_country(buffer, 2, _country_codes);
     tax_rate rand_rate = buffer[tax_rate_count-1];
     strops::copy(item.tax_rate_id, rand_rate.id, MAX_LEN_ID);