DatabaseRequestHandler.h

/*
This program has been developed by students from the bachelor Computer Science at
Utrecht University within the Software Project course.
© Copyright Utrecht University (Department of Information and Computing Sciences)
*/
 
#pragma once
#include "Definitions.h"
#include "DatabaseHandler.h"
#include "Statistics.h"
 
#include <mutex>
#include <tuple>
#include <queue>
#include <unistd.h>
 
 
#define PROJECT_DATA_SIZE 9
#define METHOD_DATA_MIN_SIZE 5
#define HEX_CHARS "0123456789abcdef"
#define UUID_REGEX "[0-9a-fA-F]{8}\\-[0-9a-fA-F]{4}\\-[0-9a-fA-F]{4}\\-[0-9a-fA-F]{4}\\-[0-9a-fA-F]{12}"
#define HASHES_MAX_SIZE 1000
#define FILES_MAX_SIZE 500
 
class DatabaseRequestHandler
{
public:
    DatabaseRequestHandler(DatabaseHandler *database, Statistics *stats, std::string ip = IP, int port = DBPORT);
 
    std::string handleUploadRequest(std::string request, std::string client);
 
    std::string handleCheckRequest(std::string request);
 
    std::string handleCheckRequest(std::vector<Hash> hashes);
 
    std::string handleCheckUploadRequest(std::string request, std::string client);
 
    std::string handleExtractProjectsRequest(std::string request);
 
    std::string handlePrevProjectsRequest(std::string request);
 
    std::string handleGetAuthorRequest(std::string request);
 
    std::string handleGetMethodsByAuthorRequest(std::string request);
 
    std::string getExtension(std::string file);
 
private:
    ProjectIn requestToProject(std::string request);
 
    MethodIn dataEntryToMethod(std::string dataEntry);
 
    std::vector<Hash> requestToHashes(std::string request);
 
    bool isValidHash(Hash hash);
 
    std::string methodsToString(std::vector<MethodOut> methods, char dataDelimiter, char methodDelimiter);
 
    std::string projectsToString(std::vector<ProjectOut> projects, char dataDelimiter, char projectDelimiter);
 
    std::vector<MethodOut> getMethods(std::vector<Hash> hashes);
 
    std::vector<ProjectOut> getProjects(std::queue<std::pair<ProjectID, Version>> keys);
 
    std::vector<ProjectOut> getPrevProjects(std::queue<ProjectID> projectQueue);
 
    std::vector<MethodOut> singleHashToMethodsThread(std::queue<Hash> &hashes, std::mutex &queueLock);
 
    std::vector<ProjectOut> singleSearchProjectThread(std::queue<std::pair<ProjectID, Version>> &projectKeyQueue,
                                                      std::mutex &queueLock);
 
    std::vector<ProjectOut> singlePrevProjectThread(std::queue<ProjectID> &projectIDs, std::mutex &queueLock);
 
    void handleUploadThreads(ProjectIn project, std::queue<MethodIn> methodQueue, bool newProject,
                             ProjectOut prevProject, std::vector<File> unchangedFiles);
 
    void singleUploadThread(std::queue<MethodIn> &methods, std::mutex &queueLock, ProjectIn project,
                            long long prevVersion, long long parserVersion, bool newProject);
 
    void handleUpdateUnchangedFilesThreads(ProjectIn project, ProjectOut prevProject, 
                                           std::vector<File> unchangedFiles);
 
    std::vector<Hash>
    singleUpdateUnchangedFilesThread(std::queue<std::pair<std::vector<Hash>, std::vector<File>>> &hashFiles,
                                     std::mutex &queueLock, ProjectIn project, long long prevVersion);
 
    std::string authorsToString(std::vector<std::pair<Author, AuthorID>> authors);
 
    std::vector<std::pair<Author, AuthorID>> getAuthors(std::vector<AuthorID> authorIDs);
 
    std::vector<std::pair<Author, AuthorID>> singleIDToAuthorThread(std::queue<AuthorID> &authorIDs,
                                                                    std::mutex &queueLock);
 
    std::vector<std::pair<MethodID, AuthorID>> getMethodsByAuthor(std::vector<AuthorID> authorIDs);
 
    std::vector<std::pair<MethodID, AuthorID>> singleAuthorToMethodsThread(std::queue<AuthorID> &authorIDs,
                                                                           std::mutex &queueLock);
 
    std::string methodIDsToString(std::vector<std::pair<MethodID, AuthorID>> methods);
 
    std::tuple<> connectWithRetry(std::string ip, int port);
 
    bool tryUploadProjectWithRetry(ProjectIn project);
 
    std::tuple<> addMethodWithRetry(MethodIn method, ProjectIn project, long long prevVersion, long long parserVersion,
                                    bool newProject);
 
    ProjectOut getPrevProjectWithRetry(ProjectID projectID);
 
    std::vector<Hash> updateUnchangedFilesWithRetry(std::pair<std::vector<Hash>, std::vector<File>> hashFile,
                                                    ProjectIn project, long long prevVersion);
 
    std::vector<MethodOut> hashToMethodsWithRetry(Hash hash);
 
    ProjectOut searchForProjectWithRetry(ProjectID projectID, Version version);
 
    Author idToAuthorWithRetry(AuthorID id);
 
    std::vector<MethodID> authorToMethodsWithRetry(AuthorID authorID);
 
    template <class T> std::vector<std::vector<T>> toChunks(std::vector<T> list, int chunkSize)
    {
        std::vector<T> currentChunk = {};
        std::vector<std::vector<T>> chunks = {};
        for (T element : list)
        {
            currentChunk.push_back(element);
            if (currentChunk.size() >= chunkSize)
            {
                chunks.push_back(currentChunk);
                currentChunk.clear();
            }
        }
        if (currentChunk.size() > 0)
        {
            chunks.push_back(currentChunk);
        }
 
        return chunks;
    };
 
    template <class T1, class T2>
    std::queue<std::pair<std::vector<T1>, std::vector<T2>>> cartesianProductQueue(std::vector<std::vector<T1>> listT1,
                                                                                  std::vector<std::vector<T2>> listT2)
    {
        std::queue<std::pair<std::vector<T1>, std::vector<T2>>> pairQueue;
        for (std::vector<T1> elemT1 : listT1)
        {
            for (std::vector<T2> elemT2 : listT2)
            {
                pairQueue.push(std::make_pair(elemT1, elemT2));
            }
        }
 
        return pairQueue;
    };
 
    DatabaseHandler *database;
    Statistics *stats;
};