Parkmanne/headers/bigheader.h

#ifndef ENCRYPT_H
#define ENCRYPT_H
#pragma once

#include "../thirdparty/SQLiteCpp/include/SQLiteCpp/SQLiteCpp.h"

#include <chrono>
#include <cstring>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <sodium.h>
#include <string>
#include <thread>
#include <vector>

using std::pair;
using namespace std::chrono;
using std::cin;
using std::cout;
using std::flush;
using std::string;
using std::to_string;
using std::vector;
using std::this_thread::sleep_for;
/*
hash_password takes the password, and encrypts it. This needs to be done,
because storing passwords in plaintext is BAD, no matter if it's just for a school project!

verify_password takes in a password and the hashed password, and then does magic encryption
stuff(no, not really. It basically hashes the password with the same salt and other parameters, but
that's not that important to know) and to see if the password stored and the given password match.
call these whenever you are working with passwords.
so to check if passwords match, use something like verifypassword(customer.password,
someplainpassword) see libsodium documentation for more info
 */

string hash_password(string password);
bool verify_password(string hashed_password, string unhashed_password);

namespace data {

/*
start_db is the function that opens the database, and
if the necesary tables are not there, creates them.
db is the database, and is static to avoid multiple redefinition errors,
 because multiple cpp files import this header.
 TODO: remove this namespace, we didn't add more functions here like originally planned.

 */
SQLite::Database start_db();
static SQLite::Database db = start_db();

} // namespace data

/*


Record of who parked at what park_spot and at what time.
public interface-------------------------------------------

The constructors. one for creating new customers, the other one used by the
query functions to construct the object from information stored in the database.

clock_out is the function that gets called from customer.clock_out().
It verifies that the customer is clocking out at the correct parkspot, and saves
the current time of clocking out in end. It also calculates duration so it
doesn't have to be calculated more than once.

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.

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 SQL datetime and chrono datetime don't seem the most compatible.

We choose chrono because it's the recomended way from c++11 onwards, and is more typesafe and
acurate https://stackoverflow.com/questions/36095323/what-is-the-difference-between-chrono-and-ctime
but, it does not have parsing and formatting for human readable time.
It will get that in c++20, but that's a little too late for us :(
So for now, conversion to/from ctime objects it is....

*/

class Park_time {
  public:
    Park_time(int c_id, int s_id);
    Park_time(int id_, int customer_id_, int spot_id_, int start_, int duration_);
    int id;
    int customer_id;
    int spot_id;
    int duration;

    void clock_out(int c_id, int s_id);
    friend std::ostream& operator<<(std::ostream& os, const Park_time& pt);

  private:
    high_resolution_clock::time_point start;
    high_resolution_clock::time_point end;
    void save_db();
    void update_db();
    int auto_increment_db(); // helper
    int start_to_int();      // helper
};

// function that slowly outputs each character one by one
void text_animation(const string& text, unsigned int pause_time);

/*
enum classes make it easy to represent categories.
So you can use something like Vehicle_type::twowheeler instead of 2 in code, so you know it's that.
but under the hood, it's still an int.
This is so you don't have to polute the global namespace with unnecesary variables.
enum classes do not permit implicit conversion between int and the enum class, and are in the
Enumclass:: scope in contrast to plain enums. https://en.cppreference.com/w/cpp/language/enum
 */
enum class Vehicle_type { twoweeler = 1, fourweeler = 2 };

/*
Customer constructors do the same stuff as all the other constructors.
clock_in and out create and modify park_time objects and store them to
park_instances. Technically, now that we have a working db, we don't need it.
It might have some performance benefits to keeping it, though.
TODO: test or fix this.
save, update, delete and auto increment are the same as in park_time but for customers.
 */

class Customer {
  public:
    int id;
    string name;
    string password;
    Vehicle_type vehicle;
    string telephone;
    int role;
    Customer(string name_, string password_, Vehicle_type vehicle_, string telephone_, int role_);
    Customer(int id_, string name_, string password_, Vehicle_type vehicle_,
             vector<Park_time> instances, string telephone_, int role_);
    void clock_in(int s_id);
    void clock_out(int s_id);
    bool parked();
    int parked_at();

    void update_db();
    void delete_db();

  private:
    vector<Park_time> park_instances;
    void save_db();
    int auto_increment_db();
};

class Park_spot {
  public:
    int id;
    bool taken;
    int parked_customer;
    Vehicle_type v_type;

    Park_spot(Vehicle_type v_type_);
    Park_spot(int id_, bool taken_, int parked, Vehicle_type v_type_);
    void clock(Customer& c_customer);

  private:
    void save_db();
    void update_db();
    void delete_db();
    int auto_increment_db();
};

/*these are the functions that search the database and create objects from it.
query_parktimes_for_customer searches for the parktimes  that are needed in
customer initialisaiton. generally, i see no use outside of that.

query_customer_with_name searches for customer data by name.
NOTE: query_customer_with_name has been removed, nothing is using it
query_customer_with_id does what the above does, but with id.

query_parkspot_with_id does what the above do, but with a vector and not to the db.

populate_spots is used to query for all the park_spots in db and return them in a vector.
We can keep that in memory to reduce calls to the db, but increasing the memory footprint of this
program

reports_from_x functions query the db for parktimes with various conditions
current_status_parkspots takes in a vector and outputs the status of them

 */

vector<Park_time> query_parktimes_for_customer(int cid);
Customer query_customer_with_id(int id);
Park_spot query_parkspot_with_id(int id, vector<Park_spot>& parkspots);
int query_role_customer(int id);

vector<Park_spot> populate_spots();

void reports_from_parkspot(int spotid, pair<int, int> period);
void reports_from_allparkspots(pair<int, int> period);
void current_status_parkspots(vector<Park_spot>& spots);
vector<Park_time> reports_from_customer(int cid, pair<int, int> period);

// interface functions
void interface(vector<Park_spot>& spots);
void interface_member(vector<Park_spot>& spots, Customer& c);
void interface_admin(vector<Park_spot>& spots);
void park(Customer& c, vector<Park_spot>& spots);
void new_customer();
void new_admin();
void new_parkspot(vector<Park_spot>& spots);
void edit_information(Customer&);

// time creation
pair<int, int> create_month_period();
pair<int, int> create_week_period();

// report functions
void report_single_spot(bool weekly = false);
void report_all_spots(bool weekly = false);
void report_customer(int customerID, bool weekly = false);

// confirmation function
bool confirm();
#endif