DRCEListAllTasks.cpp

Go to the documentation of this file.

#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 <sys/types.h>
#include <dirent.h>
#include "string.h"
#include "errno.h"

#include <Poco/File.h>
#include <Poco/Path.h>

#include "DRCEError.hpp"
#include "DRCEMessageConst.hpp"
#include "DRCEJsonMessageConst.hpp"
#include "DRCEFileStream.hpp"
#include "DRCEListAllTasks.hpp"

namespace HCE
{
namespace drce
{
//-----------------------------------------------------------------------------
TaskInfoData::TaskInfoData(void)
: taskId(0), infoData(""), timeModified(0)
{
}
//-----------------------------------------------------------------------------
TaskInfoData::TaskInfoData(const TaskInfoData& rhs)
: taskId(0), infoData(""), timeModified(0)
{
  (*this) = rhs;
}
//-----------------------------------------------------------------------------
TaskInfoData::TaskInfoData(TaskInfoData&& rhs)
: taskId(0), infoData(""), timeModified(0)
{
  (*this) = std::forward<TaskInfoData>(rhs);
}
//-----------------------------------------------------------------------------
TaskInfoData& TaskInfoData::operator=(const TaskInfoData& rhs)
{
  if (this != &rhs)
  {
    taskId = rhs.taskId;
    infoData = rhs.infoData;
    timeModified = rhs.timeModified;
  }
  return *this;
}
//-----------------------------------------------------------------------------
TaskInfoData& TaskInfoData::operator=(TaskInfoData&& rhs)
{
  if (this != &rhs)
  {
    taskId = std::move(rhs.taskId);
    infoData = std::move(rhs.infoData);
    timeModified = std::move(rhs.timeModified);
  }
  return *this;
}
//-----------------------------------------------------------------------------
void TaskInfoData::clear(void)
{
  taskId = 0;
  infoData.clear();
  timeModified = 0;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
DRCEListAllTasks::DRCEListAllTasks(void)
: DRCECommonList <TaskInfoData>(), IJsonSerializable()
{
}
//-----------------------------------------------------------------------------
bool DRCEListAllTasks::serialize(std::string& json)
{
  _isError = false;
  errorCode = NO_ERROR;
  errorMsg.clear();
  try
  {
    Poco::JSON::Array::Ptr pItems = new Poco::JSON::Array();
    if (pItems.isNull())
      throw Poco::Exception(message_const::objectInstanceWasNotCreated);

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

      if (!pItemElem.isNull())
      {
        TaskInfoData taskInfoData(getItem(i));
        pItemElem->set(drce_json_message_const::taskId, taskInfoData.taskId);
        pItemElem->set(drce_json_message_const::info, taskInfoData.infoData);
        pItemElem->set(drce_json_message_const::modified, taskInfoData.timeModified);
        pItems->add(pItemElem);
      }
    }

    std::stringstream ostr;
    Poco::JSON::Stringifier::stringify(pItems, ostr);
    json = ostr.str();
  }
  catch(std::exception& e)
  {
    _isError = true;
    errorMsg = e.what();
    errorCode = ERROR_SERIALIZE;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
bool DRCEListAllTasks::unserialize(const std::string& json)
{
  clear();
  _isError = false;
  errorCode = NO_ERROR;
  errorMsg.clear();

  try
  {
    Poco::JSON::Parser parser;
    Poco::Dynamic::Var res = parser.parse(json);
    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())
        {
          TaskInfoData taskInfoData;

          Poco::Dynamic::Var tmp = pItemElem->get(drce_json_message_const::taskId);
          taskInfoData.taskId = convertVarToNumeric<unsigned int>(tmp, 0);

          tmp = pItemElem->get(drce_json_message_const::info);
          if (tmp.isString())
            taskInfoData.infoData = tmp.convert<std::string>();

          tmp = pItemElem->get(drce_json_message_const::modified);
          taskInfoData.timeModified = convertVarToNumeric<time_t>(tmp, 0);

          addItem(std::forward<TaskInfoData>(taskInfoData));
        }
      }
    }
  }
  catch(Poco::JSON::JSONException& e)
  {
    _isError = true;
    errorMsg = e.message();
    errorCode = ERROR_UNSERIALIZE;
  }
  catch(Poco::Exception& e)
  {
    _isError = true;
    errorMsg = e.message();
    errorCode = e.code();
  }
  catch(std::exception& e)
  {
    _isError = true;
    errorMsg = e.what();
    errorCode = ERROR_UNSERIALIZE;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
bool DRCEListAllTasks::rebuild(const std::string& sourceDir)
{
  clear();
  _isError = false;
  errorCode = NO_ERROR;
  errorMsg.clear();
  try
  {
    Poco::File sources(sourceDir);
    if (sources.exists() && sources.isDirectory())
    {
      std::vector<std::string> files;
      sources.list(files);

      for (const std::string& fileName : files)
      {
        Poco::Path path(sourceDir);
        path.append(fileName);

        if (FileStream::isStatusFileName(path.toString()))
        {
          unsigned int taskId = 0;
          std::istringstream(path.getFileName()) >> taskId;

          if (taskId)
          {
            std::string fileContent;
            FileStream fileStream(path.toString(), FileStream::read);
            fileStream >> fileContent;
            fileStream.close();

            TaskInfoData taskInfoData;
            taskInfoData.taskId = taskId;
            taskInfoData.infoData = fileContent;
            taskInfoData.timeModified = Poco::File(path).getLastModified().epochTime();

            addItem(std::forward<TaskInfoData>(taskInfoData));
          }
        }
      }
    }
  }
  catch(Poco::Exception& e)
  {
    _isError = true;
    errorCode = ERROR_REBUILD_LIST_ALL_TASKS;
    errorMsg = e.message();
  }
  catch(std::exception& e)
  {
    _isError = true;
    errorCode = ERROR_REBUILD_LIST_ALL_TASKS;
    errorMsg = e.what();
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
std::string DRCEListAllTasks::toString(void)
{
  std::string json;
  serialize(json);
  return json;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
}// end namespace drce 
} // end namespace HCE