ConscienceServerCommandHandler.h

Go to the documentation of this file.

#ifndef ConscienceServerCommandHandler_hpp
#define ConscienceServerCommandHandler_hpp
 
#include "ArtificialIntelligence/CscEntityReflexion.h"
#include "ArtificialIntelligence/CscEntityReflexions.h"
#include <Bridging/EnvironmentInteractionCommands/CscCommandsProcessor.h>
#include "ConscienceCore/Communication/CscMessageHandler.h"
 
#include <CoreObjects/Exchange/ConscienceEncoder.h>
#include <Bridging/MJPGStreamer/CscMJPGStreamer.h>
#include "Simulator/CscEnvironmentSimulator.h"
#include "server/EngineInfos.h"
#include "server/entities/ServerEntities.h"
 
using std::vector, std::string, std::unique_ptr, std::shared_ptr, std::exception, conscience_utils::logging::CscLogger, conscience_core::bridging::ConscienceEncoder;
using namespace conscience_core::core_objects;
using namespace conscience_core::ai;
using namespace conscience_server;
using namespace conscience_core::communication;
using namespace conscience_server::entities;
using namespace conscience_core::mjpg_streamer;
 
namespace conscience_server {
 
struct ConscienceServerCommandResponse {
    bool valid;
    string responseCommandName;
    vector<string> responseArgs;
 
    string toCommunicationString() const {
        string fullResponse = responseCommandName;
        for (int i = 0; i < responseArgs.size(); i++) {
            fullResponse += ";" + responseArgs.at(i);
        }
        return fullResponse;
    }
};
 
typedef function<ConscienceServerCommandResponse(const vector<string> *arguments, ptr<CscMessagingRequestContext> requestContext)> ServerApiCallHandler;
 
class ServiceExecutionException : public exception {
public:
    ServiceExecutionException(string message) throw()
        : message(message) {
    }
    const char *what() const throw() {
        string what = "engine service execution failed: " + message;
        return what.c_str();
    }
 
    string getMessage() const {
        return message;
    }
 
private:
    string message;
};
 
class ConscienceServerCommandHandler : public CscMessageHandler {
public:
    ConscienceServerCommandHandler(const EngineInfos *const engineInfos, CscMJPGStreamer *mjpgStreamer);
 
    virtual optional<CscMessageHandlerResult> handleMessage(const string &messageSubject, const vector<string> &args, optional<int> knowledgeId, ptr<CscMessagingRequestContext> context) override;
 
    virtual optional<string> handleLowLevelMessage(const string &message) override;
 
    void setServerEntities(ServerEntities *serverEntities);
 
private:
 
    static ConscienceServerCommandResponse getEngineInfosResponse(const EngineInfos *engineInfos);
 
    ConscienceServerCommandResponse handleGetEngineInfos(const vector<string> *commandArguments);
 
    ConscienceServerCommandResponse handleGetRegisteredEntitiesSerialNumbers(const vector<string> *commandArguments);
 
    ConscienceServerCommandResponse handleGetStatusAiObjectives(const vector<string> *commandArguments);
 
    ConscienceServerCommandResponse handleGetCurrentEnvironment(const vector<string> *commandArguments);
 
    ConscienceServerCommandResponse handleSetEngineLogLevel(const vector<string> *commandArguments);
 
    ConscienceServerCommandResponse handleSetLoggerLogLevel(const vector<string> *commandArguments);
 
    ConscienceServerCommandResponse handleExecuteEnvironmentInteractionCommand(const vector<string> *commandArguments);
 
    ConscienceServerCommandResponse handleGetListLastExecutedCommand(const vector<string> *commandArguments);
 
    ConscienceServerCommandResponse handleGetLastDetectedObjectDistance(const vector<string> *commandArguments);
 
    ConscienceServerCommandResponse handleGetLastProcessedImage(const vector<string> *commandArguments);
 
    ConscienceServerCommandResponse handleSetEntityMJPGStreamQuality(const vector<string> *commandArguments);
 
    ConscienceServerCommandResponse handleDumpEnvironmentSimulator(const vector<string> *commandArguments);
 
    ConscienceServerCommandResponse handleGetLastEntityReflexionResult(const vector<string> *commandArguments);
 
    ConscienceServerCommandResponse handleIsEntityRunningCommand(const vector<string> *commandArguments);
 
    ConscienceServerCommandResponse handleGetEntities(const vector<string> *commandArguments);
    
    ConscienceServerCommandResponse handleGetEntitiesActivities(const vector<string> *commandArguments, ptr<CscMessagingRequestContext> requestContext);
 
    CscMJPGStreamer *mjpgStreamer = nullptr;
    ConscienceEncoder *conscienceEncoder = nullptr;
    ServerEntities *serverEntities = nullptr;
    const EngineInfos *const engineInfos = nullptr;
    const ptr<CscEntityReflexions> entityReflexions = CscEntityReflexions::getInstance();
 
    unique_ptr<CscLogger> logger = CscLogger::getForCategory("ConscienceServerCommandHandler");
 
    map<string, ServerApiCallHandler> handlers;
    void initHandlers();
 
    ptr<CscEntityReflexion> getEntityReflexion(const string &serialNumber) const;
};
}
 
#endif