source: chevmsgr/trunk/msg.hpp@ 14

#pragma once

#include "cf/logger.h"

#include "json.h"

#include <iostream>
#include <string>
#include <vector>

typedef struct SFriend
{
    std::string id;
    std::string name;
} SFriend;

#define DELIMITER   "$"

// --------------------------------------------------------------

namespace ProtocolType
{
#define DECLARE_KEY(_t) static const std::string _t = #_t

    DECLARE_KEY(NONE);
    DECLARE_KEY(ID);
    DECLARE_KEY(TYPE);
    DECLARE_KEY(NAME);
    DECLARE_KEY(SMS);
    DECLARE_KEY(PHONE);
    DECLARE_KEY(JOIN);
    DECLARE_KEY(PW);
    DECLARE_KEY(LOGIN);
    DECLARE_KEY(LOGOUT);
    DECLARE_KEY(ADD_FRIEND);
    DECLARE_KEY(OPEN_SESSION);
    DECLARE_KEY(TO);
    DECLARE_KEY(LISTEN);
    DECLARE_KEY(TELL);
    DECLARE_KEY(FROM);
    DECLARE_KEY(SESSION_ID);
    DECLARE_KEY(MESSAGE);
    DECLARE_KEY(SENSITIVE);
    DECLARE_KEY(GET_FRIEND_LIST);
    DECLARE_KEY(FRIEND_LIST);
    DECLARE_KEY(ID_LIST);
    DECLARE_KEY(RESULT);
}

namespace Protocol
{
    class Message
    {
    public:
        json::Object mObject;

        Message();

        void parse(const std::string & message);

        template<typename T>
        T get(const std::string & key) const
        {
            return (T)mObject[key];
        }

        template<typename T>
        std::vector<T> getList(const std::string & key) const
        {
            std::vector<T> ret;
            json::Array ar = mObject[key];

            for (size_t iter = 0; iter < ar.size(); iter++)
                ret.push_back(ar[iter]);

            return ret;
        }

        std::vector<SFriend> getFriendList() const;

        std::string type() const;

        std::string serialize() const;
    };

    class IProtocol
    {
    public:
        virtual void makeTemplate(json::Object & obj, const std::string & type) const = 0;
    };

    class Request : public IProtocol
    {
    private:
        std::string mID;

    public:
        void setUserID(const std::string & id);

        const std::string & getUserID();

        void makeTemplate(json::Object & obj, const std::string & type) const;

        std::string sms(const std::string & phone) const;

        std::string join(const std::string & id, const std::string & pw, const std::string & sms);

        std::string login(const std::string & pw) const;

        std::string logout() const;

        std::string addFriend(const std::string & id) const;

        std::string openSession(const std::vector<std::string> & idList) const;

        std::string tell(const std::string & sessid, const std::string & message, const int sensitive) const;

        std::string getFriendList() const;
    };

    class Response : public IProtocol
    {
    public:
        void makeTemplate(json::Object & obj, const std::string & type) const;

        std::string result(const std::string & requestType, const bool status) const;

        std::string friendList(const std::vector<SFriend> & friendList) const;
    };
};

// --------------------------------------------------------------

#define LOG(message)    log(__FILE__,__func__,__LINE__,message)

static void log(const std::string & file,
                const std::string & func,
                const int line,
                const std::string & message)
{
    static cf::logger * logger = NULL;

    if (!logger)
    {
        logger = cf::logger::getInstance();
        logger->init(".");
        logger->setLevel(1);
        logger->add("messenger", 1, "INFO", 0);
    }

    logger->write(1, message);
    std::cerr << "[" << file << ":" << line << "][" << func << "] "
              << message << std::endl;
}

static std::string joinStrings(const std::vector<std::string> & strings)
{
    std::string concat = strings[0];

    for (size_t iter = 1; iter < strings.size(); iter++)
        concat += "," + strings[iter];

    return concat;
}