DRCEInputJsonMessage.cpp

Go to the documentation of this file.

#include <Poco/JSON/Object.h>
#include <Poco/JSON/Array.h>
#include <Poco/JSON/JSON.h>
#include <Poco/JSON/Stringifier.h>
#include <Poco/JSON/Parser.h>
#include <Poco/JSON/JSONException.h>
#include <Poco/Dynamic/Var.h>
#include <utility>

#include "DRCEError.hpp"
#include "DRCEInputJsonMessage.hpp"
#include "DRCEEncodeDecodeBase64.hpp"

namespace HCE
{
namespace drce
{
//-----------------------------------------------------------------------------
DRCEInputJsonMessage::DRCEInputJsonMessage(const std::string& json)
:IJsonSerializable(), DRCEFilesList(), sessionOptions(), commandLine(""), inputStream("")
{
  if (!json.empty())
    unserialize(json);
}
//-----------------------------------------------------------------------------
void DRCEInputJsonMessage::setSessionOptions(SessionOptions&& sessionOptions_)
{
  sessionOptions = std::move(std::forward<SessionOptions>(sessionOptions_));
}
//-----------------------------------------------------------------------------
void DRCEInputJsonMessage::clear(void)
{
  sessionOptions.clear();
  commandLine.clear();
  inputStream.clear();
  files.clear();
}
//-----------------------------------------------------------------------------
bool DRCEInputJsonMessage::serialize(std::string& json)
{
  errorCode = NO_ERROR;
  errorMsg.clear();
  try
  {
    Poco::JSON::Object::Ptr obj = new Poco::JSON::Object();

    Poco::JSON::Object::Ptr pSessionOptions = new Poco::JSON::Object();
    pSessionOptions->set(drce_json_message_const::sessionType, static_cast<unsigned int>(sessionOptions.sessionType));
    pSessionOptions->set(drce_json_message_const::port, sessionOptions.port);
    pSessionOptions->set(drce_json_message_const::userName, sessionOptions.userName);
    pSessionOptions->set(drce_json_message_const::userPassword, sessionOptions.userPassword);
    pSessionOptions->set(drce_json_message_const::shellName, sessionOptions.shellName);
    pSessionOptions->set(drce_json_message_const::timeout, sessionOptions.timeout);
    pSessionOptions->set(drce_json_message_const::tmode, sessionOptions.tmode);

    Poco::JSON::Array::Ptr pEnviroment = new Poco::JSON::Array();
    for (size_t i=0;i<sessionOptions.environments.size();++i)
    {
      Poco::JSON::Object::Ptr pEnviromentElem = new Poco::JSON::Object();
      pEnviromentElem->set(sessionOptions.environments[i].first, sessionOptions.environments[i].second);
      pEnviroment->add(pEnviromentElem);
    }
    pSessionOptions->set(drce_json_message_const::environment, pEnviroment);

    obj->set(drce_json_message_const::sessionOptions, pSessionOptions);
    obj->set(drce_json_message_const::commandLine, commandLine);
    obj->set(drce_json_message_const::inputStream, inputStream);

    Poco::JSON::Array::Ptr pFiles = new Poco::JSON::Array();

    const size_t filesCount = getFilesCount();
    for (size_t i=0;i<filesCount;++i)
    {
      Poco::JSON::Object::Ptr pFileElem = new Poco::JSON::Object();
      pFileElem->set(drce_json_message_const::actionTypeMask, getFileItem(i).actionType);
      pFileElem->set(drce_json_message_const::fileName, getFileItem(i).name);
      pFileElem->set(drce_json_message_const::fileData, getFileItem(i).data);
      pFiles->add(pFileElem);
    }
    obj->set(drce_json_message_const::filesArray, pFiles);

    std::stringstream ostr;
    Poco::JSON::Stringifier::stringify(obj, ostr);
    json = ostr.str();

    _isError = false;
  }
  catch(std::exception& e)
  {
    _isError = true;
    errorMsg = e.what();
    errorCode = ERROR_SERIALIZE;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
bool DRCEInputJsonMessage::unserialize(const std::string& json)
{
  clear();
  errorCode = NO_ERROR;
  errorMsg.clear();

  try
  {
    Poco::JSON::Parser parser;
    Poco::Dynamic::Var res = parser.parse(json);
    Poco::JSON::Object::Ptr obj = res.extract<Poco::JSON::Object::Ptr>();

    Poco::Dynamic::Var tmp;
    Poco::JSON::Object::Ptr pSessionOptions = obj->getObject(drce_json_message_const::sessionOptions);
    if (!pSessionOptions.isNull())
    {
      tmp = pSessionOptions->get(drce_json_message_const::sessionType);
      sessionOptions.sessionType = static_cast<SessionOptions::SessionType>(convertVarToNumeric<unsigned int>(tmp, 0));

      tmp = pSessionOptions->get(drce_json_message_const::port);
      sessionOptions.port = convertVarToNumeric<unsigned int>(tmp, 0);

      tmp = pSessionOptions->get(drce_json_message_const::userName);
      if (tmp.isString())
        sessionOptions.userName = tmp.convert<std::string>();

      tmp = pSessionOptions->get(drce_json_message_const::userPassword);
      if (tmp.isString())
        sessionOptions.userPassword = tmp.convert<std::string>();

      tmp = pSessionOptions->get(drce_json_message_const::shellName);
      if (tmp.isString())
        sessionOptions.shellName = tmp.convert<std::string>();

      tmp = pSessionOptions->get(drce_json_message_const::timeout);
      sessionOptions.timeout = convertVarToNumeric<unsigned int>(tmp, 0);

      tmp = pSessionOptions->get(drce_json_message_const::tmode);
      sessionOptions.tmode = convertVarToNumeric<unsigned int>(tmp, 0);

      Poco::JSON::Array::Ptr pEnviroment = pSessionOptions->getArray(drce_json_message_const::environment);
      if (!pEnviroment.isNull())
      {
        for (size_t j=0;j<pEnviroment->size();++j)
        {
          Poco::JSON::Object::Ptr pEnviromentElem = pEnviroment->getObject(j);
          if (!pEnviromentElem.isNull())
          {
            std::vector<std::string> names;
            pEnviromentElem->getNames(names);
            for (size_t k=0;k<names.size();++k)
            {
              tmp = pEnviromentElem->get(names[k]);
              if (tmp.isString())
                sessionOptions.environments.push_back(std::make_pair(names[k], tmp.convert<std::string>()));
            }
          }
        }
      }
    }

    tmp = obj->get(drce_json_message_const::commandLine);
    if (tmp.isString())
      commandLine = tmp.convert<std::string>();

    tmp = obj->get(drce_json_message_const::inputStream);
    if (tmp.isString())
      inputStream = tmp.convert<std::string>();

    Poco::JSON::Array::Ptr pFiles = obj->getArray(drce_json_message_const::filesArray);
    if (!pFiles.isNull())
    {
      for (size_t i=0;i<pFiles->size();++i)
      {
        Poco::JSON::Object::Ptr pFileElem = pFiles->getObject(i);
        if (!pFileElem.isNull())
        {
          FileItem fileItem;
          fileItem.actionType = pFileElem->getValue<unsigned int>(drce_json_message_const::actionTypeMask);
          fileItem.name = pFileElem->getValue<std::string>(drce_json_message_const::fileName);
          fileItem.data = pFileElem->getValue<std::string>(drce_json_message_const::fileData);
          addFileItem(std::forward<FileItem>(fileItem));
        }
      }
    }

    _isError = false;
  }
  catch(Poco::JSON::JSONException& e)
  {
    _isError = true;
    errorMsg = e.message();
    errorCode = ERROR_UNSERIALIZE;
  }
  catch(Poco::Exception& e)
  {
    _isError = true;
    errorMsg = e.message();
    errorCode = ERROR_UNSERIALIZE;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
std::istream& operator>>(std::istream& is, DRCEInputJsonMessage& inputJsonMessage)
{
  std::string json;
  is.seekg(0, std::ios::end);
  json.resize(is.tellg());
  is.seekg(0, std::ios::beg);
  is.read(const_cast<char*>(json.c_str()), json.size());
  inputJsonMessage.unserialize(json);
  return is;
}
//-----------------------------------------------------------------------------
std::ostream& operator<<(std::ostream& os, const DRCEInputJsonMessage& inputJsonMessage)
{
  std::string json;
  const_cast<DRCEInputJsonMessage&>(inputJsonMessage).serialize(json);
  return os << json;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // namespace drce
} // namespace HCE