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

namespace HCE
{
namespace sphinx
{
//-----------------------------------------------------------------------------
SphinxInputJsonMessageSearch::SphinxInputJsonMessageSearch(const std::string& json)
:inherited(), queryString(""),
 queryParams(), orderParams(), filtersArray(), externalFields(), orderFields()
{
  if (!json.empty())
    unserialize(json);
}
//----------------------------------------------------------------------------
void SphinxInputJsonMessageSearch::addQueryParameters(const std::string& paramName, const std::string& paramValue)
{
  queryParams.push_back(std::make_pair(paramName, paramValue));
}
//-----------------------------------------------------------------------------
void SphinxInputJsonMessageSearch::addOrderParameters(const std::string& paramName, const std::string& paramValue)
{
  orderParams.push_back(std::make_pair(paramName, paramValue));
}
//-----------------------------------------------------------------------------
void SphinxInputJsonMessageSearch::addFilter(Poco::SharedPtr<SphinxFilter> pFilter)
{
  filtersArray.addFilter(pFilter);
}
//-----------------------------------------------------------------------------
void SphinxInputJsonMessageSearch::addFilter(SphinxFilter::FilterType filterType, const std::string& attributeName,
      std::vector<std::string> attributeValues, SphinxFilter::ExcludeType exclude)
{
  Poco::SharedPtr<SphinxFilter> pFilter(new SphinxFilter());
  pFilter->setFilterType(filterType);
  pFilter->setAttributeName(attributeName);
  pFilter->setAttributeValues(attributeValues);
  pFilter->setExcludeValue(exclude);
  filtersArray.addFilter(pFilter);
}
//-----------------------------------------------------------------------------
void SphinxInputJsonMessageSearch::addExternalFields(const std::string& fieldName)
{
  externalFields.push_back(fieldName);
}
//-----------------------------------------------------------------------------
void SphinxInputJsonMessageSearch::addOrderFields(const std::string& fieldName)
{
  orderFields.push_back(fieldName);
}
//-----------------------------------------------------------------------------
std::string SphinxInputJsonMessageSearch::convertVarToString(Poco::Dynamic::Var& var) throw (std::exception)
{
  std::string result;
  if (var.isString())
    result = var.convert<std::string>();
  else if(var.isNumeric())
  {
    if(var.isInteger())
    {
      if(var.isSigned())
        result = std::to_string(var.convert<long>());
      else
        result = std::to_string(var.convert<unsigned long>());
    }
    else
    {
      result = std::to_string(var.convert<double>());
    }
  }
  return result;
}
//-----------------------------------------------------------------------------
bool SphinxInputJsonMessageSearch::serialize(std::string& json)
{
  _isError = false;
  errorMsg.clear();
  try
  {
    Poco::JSON::Object::Ptr obj = new Poco::JSON::Object();
    obj->set(input_json_message_const::queryString, HCE::encodeBase64(queryString));

    // serialize query parameters
    Poco::JSON::Array::Ptr queryParameters = new Poco::JSON::Array();
    obj->set(input_json_message_const::queryParameters, queryParameters);
    Poco::JSON::Object::Ptr elem = new Poco::JSON::Object();
    queryParameters->add(elem);
    for (size_t i=0;i<queryParams.size();++i)
      elem->set(queryParams[i].first, queryParams[i].second);
    // add ext fields array to query parameters
    Poco::JSON::Array::Ptr extArray = new Poco::JSON::Array();
    elem->set(input_json_message_const::externalFieldsNames, extArray);
    for (size_t i=0;i<externalFields.size();++i)
      extArray->add(externalFields[i]);

    // serialize order param
    Poco::JSON::Array::Ptr orderParameters = new Poco::JSON::Array();
    obj->set(input_json_message_const::orderParameters, orderParameters);
    Poco::JSON::Object::Ptr elemOrder = new Poco::JSON::Object();
    orderParameters->add(elemOrder);
    for (size_t i=0;i<orderParams.size();++i)
      elemOrder->set(orderParams[i].first, orderParams[i].second);
    // add order ext fields to order param
    Poco::JSON::Array::Ptr orderArray = new Poco::JSON::Array();
    elemOrder->set(input_json_message_const::orderFieldsNames, orderArray);
    for (size_t i=0;i<orderFields.size();++i)
      orderArray->add(orderFields[i]);

    std::string filterString;
    if (!filtersArray.serialize(filterString))
      throw Poco::Exception(filtersArray.getErrorMsg());
    obj->set(input_json_message_const::filtersJsonArray, encodeBase64(filterString));

    std::stringstream ostr;
    Poco::JSON::Stringifier::stringify(obj, ostr);
    json = ostr.str();
  }
  catch(std::exception& e)
  {
    errorMsg = e.what();
    errorCode = ERROR_SERIALIZE;
    _isError = true;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
bool SphinxInputJsonMessageSearch::unserialize(const std::string& json)
{
  queryString.clear();
  queryParams.clear();
  orderParams.clear();
  filtersArray.clear();
  externalFields.clear();
  errorMsg.clear();
  _isError = false;
  try
  {
    Poco::JSON::Parser parser;
    Poco::Dynamic::Var res = parser.parse(json);
    Poco::JSON::Object::Ptr obj = res.extract<Poco::JSON::Object::Ptr>();

//    std::vector<std::string> keys;
//    obj->getNames(keys);
//    for (size_t i=0;i<keys.size();++i)
//      std::cout << "[" << i << "]= " << keys[i] << std::endl << std::endl;

    Poco::Dynamic::Var tmp = obj->get(input_json_message_const::queryString);
    if (tmp.isString())
      queryString = decodeBase64(tmp.convert<std::string>());

    Poco::JSON::Array::Ptr queryParameters = obj->getArray(input_json_message_const::queryParameters);
    if (queryParameters.isNull())
      throw Poco::JSON::JSONException (std::string("array '").append(input_json_message_const::queryParameters).append("' not found"));

    for (size_t j = 0;j <queryParameters->size();++j)
    {
      tmp = queryParameters->get(j);
      if (tmp.type() == typeid(Poco::JSON::Object::Ptr))
      {
        Poco::JSON::Object::Ptr elem = tmp.extract<Poco::JSON::Object::Ptr>();
        std::vector<std::string> vecNames;
        elem->getNames(vecNames);
        for (size_t i=0;i<vecNames.size();++i)
        {
          tmp = elem->get(vecNames[i]);
          if(tmp.isEmpty())   // check exists content
            continue;

          if (vecNames[i]==input_json_message_const::externalFieldsNames)
          {

            Poco::JSON::Array::Ptr extArray = elem->getArray(input_json_message_const::externalFieldsNames);
            if (extArray.isNull())
              throw Poco::JSON::JSONException (std::string("array '").append(input_json_message_const::externalFieldsNames).append("' not found"));

            for (size_t k=0;k<extArray->size();++k)
            {
              tmp = extArray->get(k);
              if (tmp.isString())
                externalFields.push_back(tmp.convert<std::string>());
            }
          }
          else
            queryParams.push_back(std::make_pair(vecNames[i], convertVarToString(tmp)));  // analyze type and convert if input type Numeric or String
        }
      }
    }

    Poco::JSON::Array::Ptr orderParameters = obj->getArray(input_json_message_const::orderParameters);
    if (!orderParameters.isNull())
    {
      for (size_t j = 0;j <orderParameters->size();++j)
      {
        tmp = orderParameters->get(j);
        if (tmp.type() == typeid(Poco::JSON::Object::Ptr))
        {
          Poco::JSON::Object::Ptr elem = tmp.extract<Poco::JSON::Object::Ptr>();
          std::vector<std::string> vecNames;
          elem->getNames(vecNames);
          for (size_t i=0;i<vecNames.size();++i)
          {
            tmp = elem->get(vecNames[i]);
            if(tmp.isEmpty())   // check exists content
              continue;

            if (vecNames[i]==input_json_message_const::orderFieldsNames)
            {

              Poco::JSON::Array::Ptr extArray = elem->getArray(input_json_message_const::orderFieldsNames);
              if (extArray.isNull())
                throw Poco::JSON::JSONException (std::string("array '").append(input_json_message_const::orderFieldsNames).append("' not found"));

              for (size_t k=0;k<extArray->size();++k)
              {
                tmp = extArray->get(k);
                if (tmp.isString())
                  orderFields.push_back(tmp.convert<std::string>());
              }
            }
            else
              orderParams.push_back(std::make_pair(vecNames[i], convertVarToString(tmp)));  // analyze type and convert if input type Numeric or String

          }
        }
      }
    }

    tmp = obj->get(input_json_message_const::filtersJsonArray);
    if (tmp.isString())
    {
      std::string filterString = decodeBase64(tmp.convert<std::string>());
      if (!filtersArray.unserialize(filterString))
        throw Poco::Exception(filtersArray.getErrorMsg());
    }

  }
  catch(Poco::JSON::JSONException& e)
  {
    errorMsg = e.message();
    errorCode = ERROR_UNSERIALIZE;
    _isError = true;
  }
  catch(std::exception& e)
  {
    errorMsg = e.what();
    errorCode = ERROR_UNSERIALIZE;
    _isError = true;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
std::istream& operator>>(std::istream& is, SphinxInputJsonMessageSearch& messageSearch)
{
  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());
  messageSearch.unserialize(json);
  return is;
}
//-----------------------------------------------------------------------------
std::ostream& operator<<(std::ostream& os, const SphinxInputJsonMessageSearch& messageSearch)
{
  std::string json;
  const_cast<SphinxInputJsonMessageSearch&>(messageSearch).serialize(json);
  return os << json;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // end namespace sphinx
} // end namespace HCE