AyonCppApi.h

Go to the documentation of this file.

#ifndef AYONCPPAPI_H
#define AYONCPPAPI_H
#include "AyonCppApiCrossPlatformMacros.h"
#include <sys/types.h>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <mutex>
#include <regex>
#include <shared_mutex>
#include <string>
#include <utility>
#include <vector>
#include "AyonLogger.h"
#include "appDataFoulder.h"
#include "httplib.h"
#include "nlohmann/json_fwd.hpp"
 
class AyonApi {
    public:
        AyonApi();
        ~AyonApi();
 
        std::string getKey();
        std::string getUrl();
 
        nlohmann::json GET(const std::shared_ptr<std::string> endPoint,
                           const std::shared_ptr<httplib::Headers> headers,
                           uint8_t sucsessStatus);
 
        nlohmann::json SPOST(const std::shared_ptr<std::string> endPoint,
                             const std::shared_ptr<httplib::Headers> headers,
                             nlohmann::json jsonPayload,
                             const std::shared_ptr<uint8_t> sucsessStatus);
        nlohmann::json CPOST(const std::shared_ptr<std::string> endPoint,
                             const std::shared_ptr<httplib::Headers> headers,
                             nlohmann::json jsonPayload,
                             const std::shared_ptr<uint8_t> sucsessStatus);
 
        std::pair<std::string, std::string> resolvePath(const std::string &uriPath);
        std::unordered_map<std::string, std::string> batchResolvePath(std::vector<std::string> &uriPaths);
 
        std::pair<std::string, std::string> getAssetIdent(const nlohmann::json &uriResolverRespone);
 
        bool loadEnvVars();
 
        std::shared_ptr<AyonLogger> logPointer();
 
        std::unordered_map<std::string, std::string>*
        getSiteRoots();   // TODO think about if this should only support current project or multiple projects
 
        std::string rootReplace(const std::string &rootLessPath);
 
    private:
        std::string serialCorePost(const std::string &endPoint,
                                   httplib::Headers headers,
                                   std::string &Payload,
                                   const int &sucsessStatus);
        std::string GenerativeCorePost(const std::string &endPoint,
                                       httplib::Headers headers,
                                       std::string &Payload,
                                       const int &sucsessStatus);
 
        std::string convertUriVecToString(const std::vector<std::string> &uriVec);
 
        // ----- Env Varibles
 
        std::unique_ptr<httplib::Client> AyonServer;
 
        std::unordered_map<std::string, std::string> siteRoots;
 
        const char* authKey;
        const char* serverUrl;
        std::string ayonProjectName;
 
        std::string ayonAppData = getAppDataDir() + "/AYON";
 
        // ---- Server Vars
        std::string siteId;
        std::string userName;
 
        // --- Runtime Dep Vars
 
        // Async Grp Generation Varibles
        u_int8_t minGrpSizeForAsyncRequests = 10;
        u_int16_t regroupSizeForAsyncRequests = 200;
        u_int16_t maxGroupSizeForAsyncRequests = 300;
        u_int16_t minVecSizeForGroupSplitAsyncRequests = 50;
        u_int8_t maxCallRetrys = 8;
        u_int16_t retryWaight = 800;
 
        const int num_threads;   // set by constructor
        std::shared_ptr<AyonLogger> Log;
        std::string uriResolverEndpoint = "/api/resolve";
        std::string uriResolverEndpointPathOnlyVar = "?pathOnly=true";
        bool pathOnlyReselution = true;
 
        std::mutex ConcurentRequestAfterffoMutex;
        uint8_t maxConcurentRequestAfterffo = 8;
 
        uint16_t GenerativeCorePostMaxLoopIterations = 200;
 
        u_int16_t connectionTimeOutMax = 200;
        u_int8_t readTimeOutMax = 160;
        // bool enableThreadWaithing = false;
        // bool enableBigBlockThreadWaithing = true;
        bool batchResolveOptimizeVector = true;
 
        uint16_t ServerBusyCode = 503;
        uint16_t RequestDelayWhenServerBusy = 10000;
        // std::mutex allowRequest;
 
        bool serverBusy = false;
 
        std::mutex AyonServerMutex;
};
 
#endif   // !AYONCPPAPI_H