.clang-format

@@ -5,7 +5,7 @@ IndentWidth: 4
 
 Language: Cpp
 PointerAlignment: Left
-ColumnLimit: 80
+ColumnLimit: 100
 AlignAfterOpenBracket: Align 
 AlignTrailingComments: true
 AllowAllParametersOfDeclarationOnNextLine: true

Customer.cpp

@@ -1,19 +1,24 @@
 #include "headers/Customer.h"
 
+
 // constructors
-Customer::Customer(string name_, string password_, Vehicle_type vehicle_)
+Customer::Customer(string name_, string password_, Vehicle_type vehicle_, string telephone_)
-    : name{name_}, vehicle{vehicle_}, password{hash_password(password_)} {
+    : id{auto_increment_db() + 1},
-    id = auto_increment_db() + 1;
+      name{name_},
+      password{hash_password(password_)},
+      vehicle{vehicle_},
+      telephone{telephone_} {
     save_db();
 }
 
-Customer::Customer(int id_, string name_, string password_,
+Customer::Customer(int id_, string name_, string password_, Vehicle_type vehicle_,
-                   Vehicle_type vehicle_, vector<Park_time> instances)
+                   vector<Park_time> instances, string telephone_)
     : id{id_},
       name{name_},
       password{password_},
       vehicle{vehicle_},
-      park_instances{instances} {}
+      park_instances{instances},
+      telephone{telephone_} {}
 
 // clock in/out methods
 // ====================================================================================
@@ -31,45 +36,32 @@ void Customer::clock_out(int s_id) {
 }
 
 bool Customer::parked() {
-    if (!park_instances.size()){
+    if (!park_instances.size()) {
         return false;
     }
     if ((park_instances[park_instances.size() - 1].duration)) {
         // if duration of the last parktime == 0, meaning
         // that the customer has not clocked out
         return false;
-    }
+    } else {
-    else {
         return true;
     }
 }
 
-int Customer::parked_at(){
+int Customer::parked_at() { return park_instances[park_instances.size() - 1].spot_id; }
-    return park_instances[park_instances.size() - 1].spot_id;
-}
-
-// report gen
-void Customer::gen_monthly() {
-    cout << "NAME: " << name << "\n";
-    cout << "-------------------------------------------------\n";
-    for (auto& i : park_instances) {
-        // TODO: need some logic to only include from this month. scratch that,
-        // need to remove gen monthly
-        cout << i;
-    }
-    cout << "-------------------------------------------------\n\n";
-}
 
 //================================================================================================
 // functions that interact with the database
 
 void Customer::save_db() {
-    string statement{"insert into Customer values (, '', '', );"};
+    string statement{"insert into Customer values (, '', '', ,'');"};
     // after ( = 28)
+    statement.insert(41, telephone);
     statement.insert(38, to_string(int(vehicle)));
     statement.insert(36, password);
     statement.insert(32, name);
     statement.insert(29, to_string(id));
+    // cout << statement;
     SQLite::Transaction transaction(data::db);
     data::db.exec(statement);
     transaction.commit();
@@ -77,10 +69,14 @@ void Customer::save_db() {
 
 void Customer::update_db() {
     string statement =
-        "UPDATE Customer SET name = '', card_code = '' where id = '';";
+        "UPDATE Customer SET name = '', password = '', "
-    statement.insert(58, to_string(id));
+        "vehicle = '', telephone = '' where id = '';";
-    statement.insert(44, password);
+    statement.insert(87, to_string(id));
+    statement.insert(73, telephone);
+    statement.insert(57, to_string(int(vehicle)));
+    statement.insert(43, password);
     statement.insert(28, name);
+    // cout << statement;
     data::db.exec(statement);
 }
 

Interface.cpp

@@ -2,6 +2,9 @@
 
 // I added it to pass spots, because the parking options need it to check where
 // is free parking_spots is declared in main, and if i declare it
+// liberal use of
+// cin.ignore(10000, '\n');
+// so it skips to the next newline, in essence clearing the cin buffer
 
 void interface(vector<Park_spot>& spots) {
     int selector;
@@ -10,11 +13,16 @@ void interface(vector<Park_spot>& spots) {
     cout << "\n[1]Log in as member";
     cout << "\n[2]Log in as administrator";
     cin >> selector;
+    cin.ignore(10000, '\n');
     switch (selector) {
-    case 1:
+    case 1: {
         interface_member(spots);
-    case 2:
+        break;
+    }
+    case 2: {
         interface_admin(spots);
+        break;
+    }
     }
 }
 
@@ -23,25 +31,27 @@ void interface_member(vector<Park_spot>& spots) {
     string password;
     cout << "\nPlease input id:";
     cin >> id;
+    cin.ignore(10000, '\n');
     Customer c = query_customer_with_id(id);
     cout << "\nPlease input password:";
-    cin >> password;
+    std::getline(cin, password);
-
     while (!(verify_password(c.password, password))) {
-        cout << "ERROR: wrong password. Please retype your password \n";
+        cout << "ERROR: wrong password. Please retype your password:\n";
-        cin >> password;
+        std::getline(cin, password);
     }
 
     cout << "Logged in succesfully\n";
-    cout << "select an option\n [1] Parking options\n[2]other";
+    cout << "select an option\n [1] Parking options\n[2]monthy report\n";
     int option;
     cin >> option;
+    cin.ignore(10000, '\n');
     switch (option) {
     case 1: {
         park(c, spots);
+        break;
     }
     case 2: {
-        // other thing you want to add
+        cout << "Has not been implemented yet\n";
         break;
     }
 
@@ -50,7 +60,61 @@ void interface_member(vector<Park_spot>& spots) {
     }
 }
 
-void interface_admin(vector<Park_spot>& spots) {}
+void interface_admin(vector<Park_spot>& spots) {
+    cout << "Welcome to the admin interface. It is not completely ready yet.\n";
+    cout << "[1] See monthly report of ALL parking spots\n";
+    cout << "[2] See weekly report of ALL parking spots\n";
+    cout << "[3] See monthly report of a specific parking spot\n";
+    cout << "[4] See weekly report of a specific parking spot\n";
+    cout << "[5] See current status of parking spots\n";
+    cout << "[6] Make new customer\n";
+    cout << "[7] Make new parking spot\n";
+    cout << "option[1-7]:";
+    int option;
+    cin >> option;
+    cin.ignore(10000, '\n');
+    switch (option) {
+    case 1: {
+        reports_from_allparkspots();
+        break;
+    }
+    case 2: {
+        reports_from_allparkspots(true);
+        break;
+    }
+    case 3: {
+        cout << "Which parking spot would you like a report on?ID:";
+        int spotid;
+        cin >> spotid;
+        cin.ignore(10000, '\n');
+        reports_from_parkspot(spotid);
+        break;
+    }
+    case 4: {
+        cout << "Which parking spot would you like a report on?ID:";
+        int spotid;
+        cin >> spotid;
+        cin.ignore(10000, '\n');
+        reports_from_parkspot(spotid, true);
+        break;
+    }
+    case 5: {
+        current_status_parkspots(spots);
+        break;
+    }
+    case 6: {
+        new_customer();
+        break;
+    }
+    case 7: {
+        new_parkspot(spots);
+        break;
+    }
+
+    default:
+        break;
+    }
+}
 
 // --------- individual things.
 
@@ -68,6 +132,7 @@ void park(Customer& c, vector<Park_spot>& spots) {
         cout << "where do you want to park?";
         int parkid;
         cin >> parkid;
+        cin.ignore(10000, '\n');
         for (Park_spot& i : spots) {
             if (i.id == parkid) {
                 i.clock(c);
@@ -76,11 +141,11 @@ void park(Customer& c, vector<Park_spot>& spots) {
         }
 
     } else {
-        cout
+        cout << "You are parked at spot " << c.parked_at()
-            << "You are parked at spot " << c.parked_at()
+             << ", do you want to clock out?\n enter [1] for yes and [0] for no";
-            << ", do you want to clock out?\n enter [1] for yes and [0] for no";
         int answer = 0;
         cin >> answer;
+        cin.ignore(10000, '\n');
         if (answer) {
             query_parkspot_with_id(c.parked_at(), spots).clock(c);
             cout << "You have sucessfully clocked out.";
@@ -89,3 +154,32 @@ void park(Customer& c, vector<Park_spot>& spots) {
         }
     }
 }
+
+void new_customer() {
+    int vtype;
+    string name;
+    string password;
+    string telephone;
+    cout << "What's the name of the customer? ";
+    std::getline(cin, name);
+    cout << "What's the vehicle type? [1]twoweeler, [2] fourweeler: ";
+    cin >> vtype;
+    cin.ignore(10000, '\n');
+    cout << "What's the telephone number? ";
+    std::getline(cin, telephone);
+    cout << "What's the password?";
+    std::getline(cin, password);
+    Customer newcustomer{name, password, Vehicle_type(vtype), telephone};
+    cout << "New customer sucessfully created\n";
+    newcustomer.update_db();
+}
+
+void new_parkspot(vector<Park_spot>& spots) {
+    cout << "What type of parking spot? [1] twoweeler, [2] fourweeler: ";
+    int vtype;
+    cin >> vtype;
+    cin.ignore(10000, '\n');
+    Park_spot newspot{Vehicle_type(vtype)};
+    spots.push_back(newspot);
+    cout << "new parking spot sucessfully created.\n";
+}

Park_spot.cpp

@@ -7,14 +7,13 @@ Park_spot::Park_spot(Vehicle_type v_type_)
     save_db();
 }
 
-Park_spot::Park_spot(int id_, bool taken_, int parked,Vehicle_type v_type_)
+Park_spot::Park_spot(int id_, bool taken_, int parked, Vehicle_type v_type_)
     : parked_customer{parked},
       id{id_},
       v_type{v_type_},
       taken{taken_} // TODO: think about how init parked?
 {}
 
-
 // clock in en out, calls de juist(in/out) van de customer aan de hand van
 // internal state van taken
 void Park_spot::clock(Customer& c_customer) {
@@ -34,8 +33,7 @@ void Park_spot::clock(Customer& c_customer) {
 // --------------------- db functs
 
 void Park_spot::update_db() {
-    string statement =
+    string statement = "UPDATE Park_spot SET taken = '', customer_id  = '' where id = '';";
-        "UPDATE Park_spot SET taken = '', customer_id  = '' where id = '';";
     statement.insert(63, to_string(id));
     if (taken) {
         statement.insert(49, to_string(parked_customer));

Park_time.cpp

@@ -17,14 +17,11 @@ Park_time::Park_time(int c_id, int s_id)
     save_db();
 }
 /*
-this one initializes with data from the database. should probably only be used in the query functions.
+this one initializes with data from the database. should probably only be used in the query
+functions.
  */
-Park_time::Park_time(int id_, int customer_id_, int spot_id_, int start_,
+Park_time::Park_time(int id_, int customer_id_, int spot_id_, int start_, int duration_)
-                     int duration_)
+    : id{id_}, customer_id{customer_id_}, spot_id{spot_id_}, duration{duration_} {
-    : id{id_},
-      customer_id{customer_id_},
-      spot_id{spot_id_},
-      duration{duration_} {
     start = time_point<system_clock>(seconds(start_));
     end = time_point<system_clock>(seconds(start_ + duration_));
 }
@@ -48,8 +45,7 @@ void Park_time::clock_out(int c_id, int s_id) {
 
     if (!duration) {
         end = high_resolution_clock::now();
-        duration =
+        duration = duration_cast<seconds>(end - start).count(); // use mins later
-            duration_cast<seconds>(end - start).count(); // use mins later
         update_db();
 
     } else {
@@ -61,6 +57,7 @@ std::ostream& operator<<(std::ostream& os, const Park_time& pt) {
     std::time_t start_ = system_clock::to_time_t(pt.start);
     std::time_t end_ = system_clock::to_time_t(pt.end);
     os << "- - - - - - - - - - - - - - - - - - - -\n";
+    os << "Customer # " << pt.customer_id << "at parking spot " << pt.spot_id << "\n";
     os << "Clocked in :" << std::ctime(&start_);
     os << "clocked out : " << std::ctime(&end_);
     os << "duration : " << pt.duration << "\n";
@@ -96,8 +93,7 @@ void Park_time::save_db() {
 }
 // same as above
 void Park_time::update_db() {
-    string statement =
+    string statement = "UPDATE Park_time SET end = , duration =  where id = '';";
-        "UPDATE Park_time SET end = , duration =  where id = '';";
     statement.insert(53, to_string(id));
     statement.insert(40, to_string(duration));
     statement.insert(27, to_string(start_to_int() + duration));
@@ -114,7 +110,6 @@ int Park_time::auto_increment_db() {
     return id;
 }
 
-
 //------------------ test function to help test this
 
 void Wait(int sec)

Query.cpp

@@ -1,6 +1,5 @@
 #include "headers/Query.h"
 
-
 vector<Park_time> query_parktimes_for_customer(int cid) {
     /*
     This is needed to initialize the park_instances for the customer constructor
@@ -9,8 +8,7 @@ vector<Park_time> query_parktimes_for_customer(int cid) {
      */
     vector<Park_time> park_times;
 
-    SQLite::Statement query(data::db,
+    SQLite::Statement query(data::db, "SELECT * FROM Park_time WHERE customer_id = ?;");
-                            "SELECT * FROM Park_time WHERE customer_id = ?;");
     query.bind(1, cid);
     while (query.executeStep()) {
         int id = query.getColumn(0);
@@ -25,10 +23,8 @@ vector<Park_time> query_parktimes_for_customer(int cid) {
     return park_times;
 }
 
-
 //--------------------------------------------- customers
 
-
 vector<Customer> query_customer_with_name(string name) {
     /*
     We use this instead of plain customers because:
@@ -36,18 +32,18 @@ vector<Customer> query_customer_with_name(string name) {
     2. multiple customers could be returned with the same name.
      */
     vector<Customer> result;
-    SQLite::Statement query(
+    SQLite::Statement query(data::db,
-        data::db,
+                            "SELECT id, name, password, vehicle FROM Customer WHERE name = ?;");
-        "SELECT id, name, password, vehicle FROM Customer WHERE name = ?;");
     query.bind(1, name);
     while (query.executeStep()) {
         int id = query.getColumn(0);
         string name_ = query.getColumn(1);
         string password = query.getColumn(2);
         int vehicle = query.getColumn(3); // cast to vehicle
+        string telephone = query.getColumn(4);
         vector<Park_time> park_instances = query_parktimes_for_customer(id);
-        result.push_back(Customer{
+        result.push_back(
-            id, name_, password, Vehicle_type(vehicle), park_instances});
+            Customer{id, name_, password, Vehicle_type(vehicle), park_instances, telephone});
     }
     return result;
 }
@@ -66,33 +62,104 @@ Customer query_customer_with_id(int id) {
         string name = query.getColumn(1);
         string password = query.getColumn(2);
         int vehicle = query.getColumn(3); // cast to vehicle
+        string telephone = query.getColumn(4);
         vector<Park_time> park_instances = query_parktimes_for_customer(id);
-        Customer result{
+        Customer result{id, name, password, Vehicle_type(vehicle), park_instances, telephone};
-            id, name, password, Vehicle_type(vehicle), park_instances};
         // DEBUG
-        // cout << "{" << result.id << "," <<result.password <<"," << int(vehicle) << "}\n";
+        // cout << "{" << result.id << "," <<result.password <<"," <<
+        // int(vehicle) << "}\n";
         return result;
     }
 }
 
-//------------------------------- 
+//------------------------------- parkspot info
 
-Park_spot query_parkspot_with_id(int id, vector<Park_spot>& parkspots){
+Park_spot query_parkspot_with_id(int id, vector<Park_spot>& parkspots) {
-    for (Park_spot& i : parkspots){
+    for (Park_spot& i : parkspots) {
-        if (i.id == id){
+        if (i.id == id) {
             return i;
         }
     }
 }
 
+void reports_from_parkspot(int spotid, bool weekly) {
+    std::time_t t = std::time(0); // get time now
+    std::tm* now = std::localtime(&t);
+
+    if (weekly) {
+        now->tm_wday = 1;
+    } else {
+        now->tm_mday = 1;
+    }
+
+    int s_since_epoch = mktime(now);
+
+    vector<Park_time> park_times;
+    SQLite::Statement query(data::db, "SELECT * FROM Park_time WHERE spot_id = ? AND start > ?;");
+    query.bind(1, spotid);
+    query.bind(2, s_since_epoch);
+    while (query.executeStep()) {
+        int id = query.getColumn(0);
+        int cid = query.getColumn(1);
+        int start = query.getColumn(3);
+        int duration = query.getColumn(5);
+        Park_time result{id, cid, spotid, start, duration};
+        park_times.push_back(result);
+    }
+    query.reset();
+
+    for (auto i : park_times) {
+        cout << i;
+    }
+}
+
+void reports_from_allparkspots(bool weekly) {
+    std::time_t t = std::time(0); // get time now
+    std::tm* now = std::localtime(&t);
+    if (weekly) {
+        now->tm_wday = 1;
+    } else {
+        now->tm_mday = 1;
+    }
+
+    int s_since_epoch = mktime(now);
+
+    vector<Park_time> park_times;
+    SQLite::Statement query(data::db, "SELECT * FROM Park_time WHERE start > ?;");
+    query.bind(1, s_since_epoch);
+    while (query.executeStep()) {
+        int id = query.getColumn(0);
+        int cid = query.getColumn(1);
+        int spotid = query.getColumn(2);
+        int start = query.getColumn(3);
+        int duration = query.getColumn(5);
+        Park_time result{id, cid, spotid, start, duration};
+        park_times.push_back(result);
+    }
+    query.reset();
+
+    for (auto i : park_times) {
+        cout << i;
+    }
+}
+
+void current_status_parkspots(vector<Park_spot>& spots) {
+    for (auto& i : spots) {
+        cout << "---------------------------\n";
+        cout << "PS #" << i.id << "\n";
+        cout << "Taken: " << ((i.taken) ? "true" : "false") << "\n";
+        if (i.taken) {
+            cout << "Customer#" << i.parked_customer << "  parked there\n";
+        }
+    }
+}
 
 // -------------- paroking spots
 
-
-
 // vector<Park_spot> populate_spots(){
 //         vector<Park_spot> spots;
-//     SQLite::Statement query(data::db, "SELECT * FROM Park_spot WHERE id > 0;");
+//     SQLite::Statement query(data::db, "SELECT * FROM Park_spot WHERE id >
+//     0;");
 //     // query.bind(1, 2);
 //     while (query.executeStep()) {
 //         int id = query.getColumn(0);

data.cpp

@@ -6,8 +6,7 @@ SQLite::Database start_db() {
     /*
     Opens the database, creates it if it can't find the file.
      */
-    SQLite::Database db("test.db3",
+    SQLite::Database db("test.db3", SQLite::OPEN_READWRITE | SQLite::OPEN_CREATE);
-                        SQLite::OPEN_READWRITE | SQLite::OPEN_CREATE);
     while (sodium_init() < 0) {
         std::cout << "SODIUM NOT WORKING";
         /*
@@ -17,11 +16,9 @@ SQLite::Database start_db() {
         with any libsodium function.
          */
     }
-    //sql syntax is surprisingly readable.
     db.exec(
         "create table if not exists Customer (id integer primary key, name "
-        "text, password text, vehicle int)");
+        "text, password text, vehicle int, telephone text)");
-        // getting errors when using bool, so i used an int instead.
     db.exec(
         "create table if not exists Park_spot (id integer primary key, taken "
         "int, customer_id int, vehicle_type int)");

encrypt.cpp

@@ -15,11 +15,8 @@ string hash_password(string password) {
     int memory_limit = 3.2e+7; // 3.2e7 = 32e6 = 32 mb
     int cpu_limit = 1;         // this is n_threads
 
-    int result = crypto_pwhash_str(hashed_password_,
+    int result =
-                                   password_,
+        crypto_pwhash_str(hashed_password_, password_, strlen(password_), cpu_limit, memory_limit);
-                                   strlen(password_),
-                                   cpu_limit,
-                                   memory_limit);
     string hashed_password{hashed_password_};
 
     return hashed_password;
@@ -32,8 +29,7 @@ bool verify_password(string hashed_password, string unhashed_password) {
     const char* password_ = unhashed_password.c_str();
     const char* hashed_password_ = hashed_password.c_str();
 
-    if (crypto_pwhash_str_verify(
+    if (crypto_pwhash_str_verify(hashed_password_, password_, strlen(password_)) != 0) {
-            hashed_password_, password_, strlen(password_)) != 0) {
         return false;
     } else {
         return true;

headers/Customer.h

@@ -16,7 +16,7 @@ hood, it's still an int. This is here so you won't have to have global variables
 for these categories, or worse, use magic numbers in the code.
 
  */
-enum class Vehicle_type { bike = 1, small_car = 2, suv = 3, pickup = 4 };
+enum class Vehicle_type { twoweeler = 1, fourweeler = 2 };
 
 /*
 Customer constructors do the same stuff as all the other constructors.
@@ -38,9 +38,11 @@ class Customer {
     int id;
     string name;
     string password;
-    Customer(string name_, string password_, Vehicle_type vehicle_);
+    Vehicle_type vehicle;
+    string telephone;
+    Customer(string name_, string password_, Vehicle_type vehicle_, string telephone_);
     Customer(int id_, string name_, string password_, Vehicle_type vehicle_,
-             vector<Park_time> instances);
+             vector<Park_time> instances, string telephone_);
     void clock_in(int s_id);
     void clock_out(int s_id);
     bool parked();
@@ -49,9 +51,6 @@ class Customer {
     void update_db();
     void delete_db();
 
-    void gen_monthly();
-    Vehicle_type vehicle;
-
   private:
     vector<Park_time> park_instances;
     void save_db();

headers/Interface.h

@@ -2,11 +2,12 @@
 
 #include "Query.h"
 
+
 using std::cin;
 
-
-
 void interface(vector<Park_spot>& spots);
 void interface_member(vector<Park_spot>& spots);
 void interface_admin(vector<Park_spot>& spots);
 void park(Customer& c, vector<Park_spot>& spots);
+void new_customer();
+void new_parkspot(vector<Park_spot>& spots);

headers/Park_time.h

@@ -5,10 +5,10 @@
 #include "data.h"
 
 #include <chrono>
-#include <thread>
 #include <ctime>
 #include <iostream>
 #include <string>
+#include <thread>
 
 using namespace std::chrono;
 using std::cout;
@@ -32,21 +32,21 @@ operator<< is << overload, can(should) be used for report generation.
 
 
 // implementation stuff------------------------
-start and end are time points representing when someone clocks in and out. they're from the chrono namespace.
+start and end are time points representing when someone clocks in and out. they're from the chrono
+namespace.
 
 save and update save and update info in the database.
 auto_increment pulls the highest id stored in the db, to be used in the constructor.
 
-start_to_int() is used to convert the start timepoint to an integer that can be saved in the database
+start_to_int() is used to convert the start timepoint to an integer that can be saved in the
-SQL datetime and chrono datetime don't seem the most compatible.
+database SQL datetime and chrono datetime don't seem the most compatible.
 
 */
 
 class Park_time {
   public:
     Park_time(int c_id, int s_id);
-    Park_time(int id_, int customer_id_, int spot_id_, int start_,
+    Park_time(int id_, int customer_id_, int spot_id_, int start_, int duration_);
-              int duration_);
     int id;
     int customer_id;
     int spot_id;
@@ -64,8 +64,7 @@ class Park_time {
     int start_to_int();      // helper
 };
 
-
+// test funciton
-//test funciton
 void Wait(int sec);
 
 #endif // Park_time

headers/Query.h

@@ -46,7 +46,8 @@ finally{
     do more stuff
 }
 
-3. Ya boi needs to brush up on how to create custom exceptions class, and it will complicate code furhter.
+3. Ya boi needs to brush up on how to create custom exceptions class, and it will complicate code
+furhter.
 
  */
 
@@ -59,5 +60,8 @@ vector<Park_spot> populate_spots();
 
 Park_spot query_parkspot_with_id(int id, vector<Park_spot>& parkspots);
 
+void reports_from_parkspot(int spotid, bool weekly = false);
+void reports_from_allparkspots(bool weekly = false);
 
+void current_status_parkspots(vector<Park_spot>& spots);
 #endif // CUSTOMER_H

headers/encrypt.h

@@ -12,9 +12,9 @@ using std::string;
 hash_password takes the password, and encrypts it. This needs to be done,
 because storing passwords in plaintext is BAD!
 
-verify_password takes in a password and the hashed password, and then does magic encryption stuff(no, not
+verify_password takes in a password and the hashed password, and then does magic encryption
-really. It basically hashes the password with the same salt and other
+stuff(no, not really. It basically hashes the password with the same salt and other parameters) and
-parameters) and to see if the password stored and the given password match.
+to see if the password stored and the given password match.
  */
 
 string hash_password(string password);

main.cpp

@@ -1,8 +1,5 @@
 #include "headers/Interface.h"
 
-
-
-
 /*
 Code structure is like this:
 1. encrypt.cpp en /header/encrypt.h contain functions to hash passwords and
@@ -52,8 +49,6 @@ int main() {
     // er is een customer met id 1(testcustomer) met password "password"
 
     interface(parking_spots);
-
-
 }
 
 /*