relation/server/imserver/guildmgr.cc

#include "precompile.h"

#include "guild.h"
#include "guildmgr.h"
#include "cs_msgid.pb.h"
#include "cs_proto.pb.h"
#include "ss_proto.pb.h"
#include "MSConnMgr.h"
#include "asynctaskmgr.h"

class AsyncGuildTask
{
public:
    long long watch_guild_id = 0;
    time_t time = 0;
    ss::SS_IM_ForwardGuildCMMsg forward_msg;

    virtual ~AsyncGuildTask() {}
    virtual void Execute() {}
    virtual void OnError() {}
};

class CMGuildInfoTask : public AsyncGuildTask
{
private:
    cs::CMGuildInfo cmmsg;
};

class CMGuildJoinTask : public AsyncGuildTask
{
private:
    cs::CMGuildJoin cmmsg;
};

class CMGuildAgreeTask : public AsyncGuildTask
{
private:
    cs::CMGuildAgree cmmsg;
};

class CMGuildAgreeKick : public AsyncGuildTask
{
private:
    cs::CMGuildKick cmmsg;
};

class CMGuildAgreeTak : public AsyncGuildTask
{
private:
    cs::CMGuildQuit cmmsg;
};

class CMGuildDismissTask : public AsyncGuildTask
{
private:
    cs::CMGuildDismiss cmmsg;
};

class CMGuildRenameTask : public AsyncGuildTask
{
private:
    cs::CMGuildRename cmmsg;
};

class CMGuildMemberListTask : public AsyncGuildTask
{
private:
    cs::CMGuildMemberList cmmsg;
};

class CMGuildLogTask : public AsyncGuildTask
{
private:
    cs::CMGuildLog cmmsg;
};

void GuildMgr::Init()
{

}

void GuildMgr::UnInit()
{

}

void GuildMgr::_SS_IM_ForwardGuildCMMsg(f8::MsgHdr& hdr, const ss::SS_IM_ForwardGuildCMMsg& msg)
{
    if (msg.msgid() < cs::CMMessageId_e::_CMGuildMsgBegin ||
        msg.msgid() > cs::CMMessageId_e::_CMGuildMsgEnd) {
        return;
    }
    if (!IsValidGuildId(msg.context().user_info().base_data().guild_id())) {
        ss::SS_CommonError respmsg;
        respmsg.set_errcode(SERVER_INTERNAL_ERROR);
        respmsg.set_errmsg("服务器内部错误");
        ForwardGuildSMMsg(msg.context(), msg.msgid(), respmsg);
        return;
    }
    switch (msg.msgid()) {
    case cs::CMMessageId_e::_CMGuildInfo:
        {
            cs::CMGuildInfo cmmsg;
            cmmsg.ParseFromArray(msg.payload().data(), msg.payload().size());
            CMGuildInfoTask* task = new CMGuildInfoTask;
            AddAsyncTask(cmmsg.guild_id(), task);
        }
        break;
    case cs::CMMessageId_e::_CMGuildCreate:
        {
            cs::CMGuildCreate cmmsg;
            cmmsg.ParseFromArray(msg.payload().data(), msg.payload().size());
            _CMGuildCreate(msg.context(), cmmsg);
        }
        break;
    case cs::CMMessageId_e::_CMGuildJoin:
        {
            cs::CMGuildJoin cmmsg;
            cmmsg.ParseFromArray(msg.payload().data(), msg.payload().size());
            CMGuildJoinTask* task = new CMGuildJoinTask;
            //AddAsyncTask(cmmsg.guild_id(), task);
        }
        break;
    case cs::CMMessageId_e::_CMGuildAgree:
        {
            cs::CMGuildAgree cmmsg;
            cmmsg.ParseFromArray(msg.payload().data(), msg.payload().size());
        }
        break;
    case cs::CMMessageId_e::_CMGuildKick:
        {
            cs::CMGuildKick cmmsg;
            cmmsg.ParseFromArray(msg.payload().data(), msg.payload().size());
        }
        break;
    case cs::CMMessageId_e::_CMGuildQuit:
        {
            cs::CMGuildQuit cmmsg;
            cmmsg.ParseFromArray(msg.payload().data(), msg.payload().size());
        }
        break;
    case cs::CMMessageId_e::_CMGuildDismiss:
        {
            cs::CMGuildDismiss cmmsg;
            cmmsg.ParseFromArray(msg.payload().data(), msg.payload().size());
        }
        break;
    case cs::CMMessageId_e::_CMGuildRename:
        {
            cs::CMGuildRename cmmsg;
            cmmsg.ParseFromArray(msg.payload().data(), msg.payload().size());
        }
        break;
    case cs::CMMessageId_e::_CMGuildSearch:
        {
            cs::CMGuildSearch cmmsg;
            cmmsg.ParseFromArray(msg.payload().data(), msg.payload().size());
            _CMGuildSearch(msg.context(), cmmsg);
        }
        break;
    case cs::CMMessageId_e::_CMGuildRank:
        {
            cs::CMGuildRank cmmsg;
            cmmsg.ParseFromArray(msg.payload().data(), msg.payload().size());
            _CMGuildRank(msg.context(), cmmsg);
        }
        break;
    case cs::CMMessageId_e::_CMGuildMemberList:
        {
            cs::CMGuildMemberList cmmsg;
            cmmsg.ParseFromArray(msg.payload().data(), msg.payload().size());
        }
        break;
    case cs::CMMessageId_e::_CMGuildLog:
        {
            cs::CMGuildLog cmmsg;
            cmmsg.ParseFromArray(msg.payload().data(), msg.payload().size());
        }
        break;
    default:
        {
            break;
        }
    }
}

void GuildMgr::_CMGuildCreate(const ss::MFIMMsgConext& context, const cs::CMGuildCreate& msg)
{
    Guild* guild = GetGuild(context.user_info().base_data().guild_id());
    if (guild) {
        cs::SMGuildCreate respmsg;
        respmsg.set_errcode(1);
        respmsg.set_errmsg("群id已经存在");
        ForwardGuildSMMsg(context, respmsg);
        return;
    }
    AsyncTaskMgr::Instance()->CreateNewGuildTask(context, msg);
}

void GuildMgr::_CMGuildSearch(const ss::MFIMMsgConext& context, const cs::CMGuildSearch& msg)
{

}

void GuildMgr::_CMGuildRank(const ss::MFIMMsgConext& context, const cs::CMGuildRank& msg)
{

}

void GuildMgr::AddAsyncTask(long long guild_id, AsyncGuildTask* task)
{
    Guild* guild = GetGuild(guild_id);
    if (guild) {
        task->Execute();
        delete task;
        return;
    }
    auto itr = task_hash_.find(guild_id);
    if (itr != task_hash_.end()) {
        itr->second.push_back(task);
    } else {
        task_hash_[guild_id] = std::list<AsyncGuildTask*>({task});
        LoadGuild(guild_id);
    }
}

void GuildMgr::LoadGuild(long long guild_id)
{
    if (GetGuild(guild_id)) {
        return;
    }
    if (pending_guild_hash_.find(guild_id) != pending_guild_hash_.end()) {
        return;
    }
    pending_guild_hash_.insert(guild_id);
}

bool GuildMgr::IsValidGuildId(long long guild_id)
{
    return true;
}

Guild* GuildMgr::GetGuild(long long guild_id)
{
    auto itr = id_hash_.find(guild_id);
    return itr != id_hash_.end() ? itr->second : nullptr;
}

void GuildMgr::ForwardGuildSMMsg(const ss::MFIMMsgConext& context,
                                 int msgid,
                                 const ::google::protobuf::Message& smmsg)
{
    ss::SS_IM_ForwardGuildSMMsg msg;
    *msg.mutable_context() = context;
    msg.set_msgid(msgid);
    smmsg.SerializeToString(msg.mutable_payload());
    MSConnMgr::Instance()->SendMsg(msg, 0);
}