DRCEResultDataSerializator.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 "DRCEEncodeDecodeBase64.hpp"
#include "DRCEError.hpp"
#include "DRCEResultDataSerializator.hpp"

namespace HCE
{
namespace drce
{
//-----------------------------------------------------------------------------
DRCEResultDataSerializator::DRCEResultDataSerializator(DRCEResultData& resultData_)
: inherited(), resultData(resultData_)
{
}
//-----------------------------------------------------------------------------
bool DRCEResultDataSerializator::serialize(std::string& json)
{
  errorCode = NO_ERROR;
  errorMsg.clear();
  try
  {
    Poco::JSON::Array::Ptr pItems = new Poco::JSON::Array();

    for (size_t i=0;i<resultData.getItemsCount();++i)
    {
      Poco::JSON::Object::Ptr pItemElem = new Poco::JSON::Object();

      pItemElem->set(drce_json_message_const::stdoutStream, resultData.getDataItem(i).getStdoutStream());
      pItemElem->set(drce_json_message_const::stderrStream, resultData.getDataItem(i).getStderrStream());
      pItemElem->set(drce_json_message_const::nodeName, resultData.getDataItem(i).getNodeName());
      pItemElem->set(drce_json_message_const::time, resultData.getDataItem(i).getTime());
      pItemElem->set(drce_json_message_const::exitStatus, resultData.getDataItem(i).getExitStatus());

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

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

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

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

  try
  {
    Poco::JSON::Parser parser;
    Poco::Dynamic::Var res = parser.parse(json);

    Poco::Dynamic::Var tmp;
    Poco::JSON::Array::Ptr pItems = res.extract<Poco::JSON::Array::Ptr>();
    if (!pItems.isNull())
    {
      for (size_t i=0;i<pItems->size();++i)
      {
        Poco::JSON::Object::Ptr pItemElem = pItems->getObject(i);
        if (!pItemElem.isNull())
        {
          DRCEResultDataItem dataItem;
          tmp = pItemElem->get(drce_json_message_const::stdoutStream);
          if (tmp.isString())
            dataItem.setStdoutStream(tmp.convert<std::string>());

          tmp = pItemElem->get(drce_json_message_const::stderrStream);
          if (tmp.isString())
            dataItem.setStderrStream(tmp.convert<std::string>());

          tmp = pItemElem->get(drce_json_message_const::nodeName);
          if (tmp.isString())
            dataItem.setNodeName(tmp.convert<std::string>());

          tmp = pItemElem->get(drce_json_message_const::time);
          dataItem.setTime(convertVarToNumeric<unsigned int>(tmp, 0));

          tmp = pItemElem->get(drce_json_message_const::exitStatus);
          dataItem.setExitStatus(convertVarToNumeric<unsigned int>(tmp, 0));

          Poco::JSON::Array::Ptr pFiles = pItemElem->getArray(drce_json_message_const::filesArray);
          if (!pFiles.isNull())
          {
            for (size_t k=0;k<pFiles->size();++k)
            {
              Poco::JSON::Object::Ptr pFileElem = pFiles->getObject(k);
              if (!pFileElem.isNull())
              {
                FileItem fileItem;

                tmp = pFileElem->get(drce_json_message_const::fileName);
                if (tmp.isString())
                  fileItem.name = tmp.convert<std::string>();

                tmp = pFileElem->get(drce_json_message_const::fileData);
                if (tmp.isString())
                  fileItem.data = tmp.convert<std::string>();

                tmp = pFileElem->get(drce_json_message_const::actionTypeMask);
                fileItem.actionType = convertVarToNumeric<unsigned int>(tmp, 0);

                dataItem.addFileItem(std::forward<FileItem>(fileItem));
              }
            }
          }
          resultData.addDataItem(std::forward<DRCEResultDataItem>(dataItem));
        }
      }
    }
    _isError = false;
  }
  catch(Poco::JSON::JSONException& e)
  {
    _isError = true;
    errorMsg = e.displayText();
    errorCode = ERROR_UNSERIALIZE;
  }
  catch(Poco::Exception& e)
  {
    _isError = true;
    errorMsg = e.displayText();
    errorCode = ERROR_UNSERIALIZE;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // namespace drce
} // namespace HCE