SphinxFilters.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 "SphinxError.hpp"
#include "SphinxFilters.hpp"
#include "SphinxInputJsonMessage.hpp"

namespace HCE
{
namespace sphinx
{
//-----------------------------------------------------------------------------
SphinxFilter::SphinxFilter(void)
: filterType(SphinxFilter::FilterType::ftSimple), attributeName(""), attributeValues(), excludeValue(SphinxFilter::ExcludeType::etFalse)
{
}
//-----------------------------------------------------------------------------
void SphinxFilter::addAttributeValue(const std::string& value)
{
  attributeValues.push_back(value);
}
//-----------------------------------------------------------------------------
std::ostream& operator << (std::ostream& os, const SphinxFilter& filter)
{
  os << "Filter type = " << (unsigned int)(filter.getFilterType()) << " AttributeName: '" << filter.attributeName << "' attributeValues: '";
  for (size_t i=0;i<filter.attributeValues.size();++i)
  {
    os << filter.attributeValues[i];
    if (i<filter.attributeValues.size()-1)
      os << ", ";
  }
  os << " exclude: '" << std::boolalpha << static_cast<bool>(filter.excludeValue) << "'";
  return os << std::endl;
}
//-----------------------------------------------------------------------------
SphinxFilter& SphinxFilter::operator=(const SphinxFilter& sphinxFilter)
{
  filterType = sphinxFilter.getFilterType();
  attributeName = sphinxFilter.getAttributeName();
  attributeValues = const_cast<SphinxFilter&>(sphinxFilter).getAttributeValues();
  excludeValue = sphinxFilter.getExcludeValue();
  return *this;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
SphinxFiltersArray::SphinxFiltersArray(const std::string& json)
:inherited(), vecFilters()
{
  if (!json.empty())
    unserialize(json);
}
//-----------------------------------------------------------------------------
void SphinxFiltersArray::clear(void)
{
  vecFilters.clear();
}
//-----------------------------------------------------------------------------
void SphinxFiltersArray::addFilter(Poco::SharedPtr<SphinxFilter> pFilter)
{
  vecFilters.push_back(pFilter);
}
//-----------------------------------------------------------------------------
SphinxFiltersArray& SphinxFiltersArray::operator=(const SphinxFiltersArray& filtersArray)
{
  vecFilters = const_cast<SphinxFiltersArray&>(filtersArray).getFilters();
  return *this;
}
//-----------------------------------------------------------------------------
bool SphinxFiltersArray::serialize(std::string& json)
{
  _isError = false;
  errorMsg.clear();
  try
  {
    Poco::JSON::Array::Ptr pArrayFilters = new Poco::JSON::Array();
    for (size_t i=0;i<vecFilters.size();++i)
    {
      Poco::JSON::Object::Ptr obj = new Poco::JSON::Object();
      obj->set(input_json_message_const::filterType, static_cast<unsigned int>(vecFilters[i]->getFilterType()));
      obj->set(input_json_message_const::attributeName, vecFilters[i]->getAttributeName());

      Poco::JSON::Array::Ptr pArray = new Poco::JSON::Array();
      obj->set(input_json_message_const::attributeValues, pArray);
      for (size_t k=0;k<vecFilters[i]->getAttributeValues().size();++k)
        pArray->add(vecFilters[i]->getAttributeValues()[k]);

      obj->set(input_json_message_const::excludeValue, static_cast<unsigned int>(vecFilters[i]->getExcludeValue()));
      pArrayFilters->add(obj);
    }

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

  }
  catch(std::exception& e)
  {
    errorMsg = e.what();
    errorCode = ERROR_SERIALIZE;
    _isError = true;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
bool SphinxFiltersArray::unserialize(const std::string& json)
{
  vecFilters.clear();
  errorMsg.clear();
  _isError = false;
  try
  {
    Poco::JSON::Parser parser;
    Poco::Dynamic::Var res = parser.parse(json);
    Poco::JSON::Array::Ptr pArray = res.extract<Poco::JSON::Array::Ptr>();

    for (size_t i=0;i<pArray->size();++i)
    {
      Poco::Dynamic::Var tmp = pArray->get(i);
      if (tmp.type()==typeid(Poco::JSON::Object::Ptr))
      {
        Poco::SharedPtr<SphinxFilter> pFilter = new SphinxFilter;

        Poco::JSON::Object::Ptr obj = tmp.extract<Poco::JSON::Object::Ptr>();

        tmp = obj->get(input_json_message_const::filterType);
        if(tmp.isInteger() && !tmp.isSigned())
        {
          unsigned long filterType = tmp.convert<unsigned long>();

          if(filterType > 3)
            throw Poco::JSON::JSONException("Wrong filter type param. Input value = "+std::to_string(filterType));

          pFilter->setFilterType(static_cast<SphinxFilter::FilterType>(filterType));
        }

        tmp = obj->get(input_json_message_const::attributeName);
        if (tmp.isString())
        {
          std::string attributeName = tmp.convert<std::string>();
          if (attributeName.empty())
            throw Poco::JSON::JSONException("Attribute name is empty.");
          pFilter->setAttributeName(attributeName);
        }

        Poco::JSON::Array::Ptr pArrayVal = obj->getArray(input_json_message_const::attributeValues);
        if (!pArrayVal.isNull())
        {
          for (size_t j = 0;j <pArrayVal->size();++j)
          {
            tmp = pArrayVal->get(j);
            if (tmp.isString())
              pFilter->addAttributeValue(tmp.convert<std::string>());

            if(tmp.isInteger() && !tmp.isSigned())
              pFilter->addAttributeValue(std::to_string(tmp.convert<Poco::UInt64>()));
          }
          if (pFilter->getAttributeValues().empty())
            throw Poco::JSON::JSONException("Array attribute values is empty.");
        }
        else
          throw Poco::JSON::JSONException (std::string("array '").append(input_json_message_const::attributeValues).append("' not found"));

        SphinxFilter::ExcludeType excludeValue = SphinxFilter::ExcludeType::etFalse;
        tmp = obj->get(input_json_message_const::excludeValue);
        if(tmp.isInteger() && !tmp.isSigned())
          excludeValue = static_cast<SphinxFilter::ExcludeType>(tmp.convert<unsigned int>());

        if (tmp.isString())
          excludeValue = static_cast<SphinxFilter::ExcludeType>(std::stoul(tmp.convert<std::string>()));

        pFilter->setExcludeValue(excludeValue);
        addFilter(pFilter);
      }
    }
  }
  catch(Poco::JSON::JSONException& e)
  {
    errorMsg = e.displayText();
    errorCode = ERROR_UNSERIALIZE;
    _isError = true;
  }
  catch(std::exception& e)
  {
    errorMsg = e.what();
    errorCode = ERROR_UNSERIALIZE;
    _isError = true;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
std::ostream& operator << (std::ostream& os, const SphinxFiltersArray& filtersArray)
{
  for (size_t i=0;i<filtersArray.vecFilters.size();++i)
    os << *(filtersArray.vecFilters[i]);
  return os << std::endl;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} /* namespace sphinx */
} /* namespace HCE */