source: chevmsgr/trunk/msg.cpp@ 8

#include "msg.hpp"

#define DECLARE_TEMPLATE_OBJECT(_obj, _type)    \
    json::Object _obj;                          \
    makeTemplate(_obj, _type);                  \

namespace Protocol
{
    // parser
    void Message::parse(const std::string & message)
    {
        mObject = json::Deserialize(message);
    }

    std::string Message::type() const
    {
        return get<std::string>("type");
    }

    std::vector<SFriend> Message::getFriendList() const
    {
        json::Array ar = mObject[ProtocolType::FRIEND_LIST];

        std::vector<SFriend> friendList;

        std::vector<json::Value>::iterator iter;
        for (iter = ar.begin(); iter != ar.end(); iter++)
        {
            SFriend fr;

            fr.id   = (*iter)[ProtocolType::ID  ];
            fr.name = (*iter)[ProtocolType::NAME];

            friendList.push_back(fr);
        }

        return friendList;
    }

    // request
    void Request::setUserID(const std::string & id)
    {
        mID = id;
    }

    const std::string & Request::getUserID()
    {
        return mID;
    }

    void Request::makeTemplate(json::Object & obj, const std::string & type) const
    {
        obj[ProtocolType::ID] = mID;
        obj[ProtocolType::TYPE] = type;
    }

    std::string Request::sms(const std::string & phone) const
    {
        DECLARE_TEMPLATE_OBJECT(obj, ProtocolType::SMS);

        obj[ProtocolType::PHONE] = phone;

        return json::Serialize(obj);
    }

    std::string Request::join(const std::string & id, const std::string & pw, const std::string & sms)
    {
        DECLARE_TEMPLATE_OBJECT(obj, ProtocolType::JOIN);

        obj[ProtocolType::ID] = id;
        obj[ProtocolType::PW] = pw;
        obj[ProtocolType::SMS] = sms;

        return json::Serialize(obj);
    }

    std::string Request::login(const std::string & pw) const
    {
        DECLARE_TEMPLATE_OBJECT(obj, ProtocolType::LOGIN);

        obj[ProtocolType::PW] = mID + DELIMITER + pw;

        return json::Serialize(obj);
    }

    std::string Request::addFriend(const std::string & id) const
    {
        DECLARE_TEMPLATE_OBJECT(obj, ProtocolType::ADD_FRIEND);

        obj[ProtocolType::ID] = id;

        return json::Serialize(obj);
    }

    std::string Request::openSession(const std::string & to) const
    {
        DECLARE_TEMPLATE_OBJECT(obj, ProtocolType::OPEN_SESSION);

        obj[ProtocolType::TO] = to;

        return json::Serialize(obj);
    }

    std::string Request::chat(const std::string & sessid, const std::string & message, const int sensitive) const
    {
        DECLARE_TEMPLATE_OBJECT(obj, ProtocolType::CHAT);

        obj[ProtocolType::FROM] = mID;
        obj[ProtocolType::SESSION_ID] = sessid;
        obj[ProtocolType::MESSAGE] = message;
        obj[ProtocolType::SENSITIVE] = sensitive;

        return json::Serialize(obj);
    }

    std::string Request::getFriendList() const
    {
        DECLARE_TEMPLATE_OBJECT(obj, ProtocolType::GET_FRIEND_LIST);

        return json::Serialize(obj);
    }

    // response
    void Response::makeTemplate(json::Object & obj, const std::string & type) const
    {
        obj[ProtocolType::TYPE] = type;
    }

    std::string Response::result(const std::string & requestType, const bool status) const
    {
        DECLARE_TEMPLATE_OBJECT(obj, ProtocolType::RESULT);

        obj[ProtocolType::RESULT] = status;

        return json::Serialize(obj);
    }

    std::string Response::friendList(const std::vector<SFriend> & friendList) const
    {
        DECLARE_TEMPLATE_OBJECT(obj, ProtocolType::FRIEND_LIST);

        json::Array ar;
        std::vector<SFriend>::const_iterator iter;
        for (iter = friendList.begin() ; iter != friendList.end() ; iter++)
        {
            json::Object fr;

            fr[ProtocolType::ID  ] = iter->id;
            fr[ProtocolType::NAME] = iter->name;

            ar.push_back(fr);
        }

        obj[ProtocolType::FRIEND_LIST] = ar;

        return json::Serialize(obj);
    }
};