relation/server/imserver/guild.cc

#include "precompile.h"

#include <a8/timer.h>
#include <a8/mutable_xobject.h>

#include "guild.h"
#include "cs_proto.pb.h"
#include "ss_proto.pb.h"
#include "dbengine.h"
#include "app.h"
#include "guildmgr.h"
#include "typeconvert.h"
#include "utils.h"
#include "dbhelper.h"

const int GUILD_MAX_MEMBER_NUM = 50;

void Guild::Init()
{
    logdb_ = new ss::MFGuildLogDB;
}

void Guild::UnInit()
{
    for (auto& pair : member_hash_) {
        delete pair.second;
    }
    member_hash_.clear();
    A8_SAFE_DELETE(logdb_);
}

GuildMember* Guild::GetMember(const std::string& account_id)
{
    auto itr = member_hash_.find(account_id);
    return itr != member_hash_.end() ? itr->second : nullptr;
}

bool Guild::IsFull()
{
    return member_hash_.size() < GUILD_MAX_MEMBER_NUM;
}

void Guild::AddMember(GuildMember* member)
{
    if (member_hash_.find(member->account_id) != member_hash_.end()) {
        abort();
    }
    member_hash_[member->account_id] = member;
    GenSortedMembers();

    MarkDirty();
    if (dirty_timer_) {
        a8::Timer::Instance()->ModifyTimer(dirty_timer_, 100);
    }
}

void Guild::RemoveMember(const std::string& account_id)
{
    GuildMember* member = GetMember(account_id);
    if (member) {
        member_hash_.erase(account_id);
        A8_SAFE_DELETE(member);
        GenSortedMembers();
    }

    MarkDirty();
    if (dirty_timer_) {
        a8::Timer::Instance()->ModifyTimer(dirty_timer_, 100);
    }
}

void Guild::MarkDirty()
{
    if (!dirty_) {
        dirty_ = true;
        dirty_timer_ = a8::Timer::Instance()->AddDeadLineTimerAndAttach
            (1000 * 60,
             a8::XParams()
             .SetSender((void*)this),
             [] (const a8::XParams& param)
             {
                 Guild* guild = (Guild*)param.sender.GetUserData();
                 guild->SaveToDB();
             },
             &timer_attacher.timer_list_,
             [] (const a8::XParams& param)
             {
                 Guild* guild = (Guild*)param.sender.GetUserData();
                 guild->dirty_timer_ = nullptr;
             }
             );
    }
}

void Guild::Deserialize(const std::string& guild_data, const std::string& guild_log)
{
    logdb_->ParseFromString(guild_log);

    ss::MFGuildDB guilddb;
    guilddb.ParseFromString(guild_data);
    for (auto& member_pb : guilddb.members()) {
        GuildMember* member = new GuildMember;
        TypeConvert::Convert(member_pb.base_data(), *member);
        member_hash_[member->account_id] = member;
    }
    GenSortedMembers();
}

void Guild::_CMGuildInfo(f8::MsgHdr& hdr, const cs::CMGuildInfo& msg)
{
    ss::SS_IM_ForwardGuildCMMsg *forward_msg = (ss::SS_IM_ForwardGuildCMMsg*)hdr.user_data;

    cs::SMGuildInfo respmsg;
    FillGuildBasic(respmsg.mutable_info());
    GuildMgr::Instance()->ForwardGuildSMMsg(hdr.socket_handle,
                                            forward_msg->context(),
                                            respmsg);
}

void Guild::_CMGuildJoin(f8::MsgHdr& hdr, const cs::CMGuildJoin& msg)
{
    ss::SS_IM_ForwardGuildCMMsg *forward_msg = (ss::SS_IM_ForwardGuildCMMsg*)hdr.user_data;

    cs::SMGuildJoin respmsg;
    GuildMgr::Instance()->ForwardGuildSMMsg(hdr.socket_handle,
                                            forward_msg->context(),
                                            respmsg);
    DBHelper::Instance()->AddGuildApply(this, forward_msg->context().user_info());
}

void Guild::_CMGuildAgree(f8::MsgHdr& hdr, const cs::CMGuildAgree& msg)
{
    ss::SS_IM_ForwardGuildCMMsg *forward_msg = (ss::SS_IM_ForwardGuildCMMsg*)hdr.user_data;

    cs::SMGuildAgree respmsg;
    #if 0
    GuildMgr::Instance()->ForwardGuildSMMsg(socket_handle, context, respmsg);
    #endif
}

void Guild::_CMGuildKick(f8::MsgHdr& hdr, const cs::CMGuildKick& msg)
{
    cs::SMGuildKick respmsg;
    #if 0
    GuildMember* member = GetMember(context.user_info().base_data().account_id());
    if (!member) {
        return;
    }
    GuildMgr::Instance()->ForwardGuildSMMsg(socket_handle, context, respmsg);
    #endif
}

void Guild::_CMGuildQuit(f8::MsgHdr& hdr, const cs::CMGuildQuit& msg)
{
    cs::SMGuildQuit respmsg;
    #if 0
    GuildMember* member = GetMember(context.user_info().base_data().account_id());
    if (!member) {
        return;
    }
    if (member->guild_job == kGuildOwner) {
        return;
    }
    RemoveMember(member->account_id);
    GuildMgr::Instance()->ForwardGuildSMMsg(socket_handle, context, respmsg);
    #endif
}

void Guild::_CMGuildDismiss(f8::MsgHdr& hdr, const cs::CMGuildDismiss& msg)
{
    cs::SMGuildDismiss respmsg;
    #if 0
    GuildMember* member = GetMember(context.user_info().base_data().account_id());
    if (!member) {
        return;
    }
    if (member->guild_job != kGuildOwner) {
        return;
    }
    guild_status = kGuildDismissed;
    SaveToDB();
    GuildMgr::Instance()->ForwardGuildSMMsg(socket_handle, context, respmsg);
    #endif
}

void Guild::_CMGuildRename(f8::MsgHdr& hdr, const cs::CMGuildRename& msg)
{
    guild_name = msg.new_name();
    cs::SMGuildRename respmsg;
    #if 0
    GuildMgr::Instance()->ForwardGuildSMMsg(socket_handle, context, respmsg);
    MarkDirty();
    #endif
}

void Guild::_CMGuildMemberList(f8::MsgHdr& hdr, const cs::CMGuildMemberList& msg)
{
    cs::SMGuildMemberList respmsg;
    *respmsg.mutable_paging() = msg.paging();
    if (respmsg.paging().page_size() <= 0) {
        respmsg.mutable_paging()->set_page_size(10);
    }
    AdjustPaging(respmsg.mutable_paging(), sorted_members_.size());
    for (size_t i = respmsg.paging().curr_page() * respmsg.paging().page_size();
         i < sorted_members_.size();
         ++i) {
        if (respmsg.member_list().size() >= respmsg.paging().page_size()) {
            break;
        }
        auto p = respmsg.add_member_list();
        TypeConvert::Convert(*sorted_members_[i], *p);
    }
    #if 0
    GuildMgr::Instance()->ForwardGuildSMMsg(socket_handle, context, respmsg);
    #endif
}

void Guild::_CMGuildLog(f8::MsgHdr& hdr, const cs::CMGuildLog& msg)
{
    cs::SMGuildLog respmsg;
    *respmsg.mutable_paging() = msg.paging();
    if (respmsg.paging().page_size() <= 0) {
        respmsg.mutable_paging()->set_page_size(10);
    }
    AdjustPaging(respmsg.mutable_paging(), logdb_->logs().size());
    for (int i = respmsg.paging().curr_page() * respmsg.paging().page_size();
         i < logdb_->logs().size();
         ++i) {
        #if 0
        if (respmsg.member_list().size() >= respmsg.paging().page_size()) {
            break;
        }
        auto p = respmsg.add_member_list();
        TypeConvert::Convert(*sorted_members_[i], *p);
        #endif
    }
    #if 0
    GuildMgr::Instance()->ForwardGuildSMMsg(socket_handle, context, respmsg);
    #endif
}

void Guild::FillGuildBasic(cs::MFGuildBasic* guild_basic)
{
    guild_basic->set_guild_id(guild_id);
    guild_basic->set_guild_name(guild_name);
    guild_basic->set_guild_lv(guild_lv);
    guild_basic->set_guild_exp(guild_exp);
    guild_basic->set_guild_badge(guild_badge);
    guild_basic->set_member_num(member_hash_.size());
    guild_basic->set_guild_declaration(guild_declaration);
    guild_basic->set_guild_owner_id(owner_id);
    guild_basic->set_guild_owner_name(owner_name);
    guild_basic->set_guild_owner_avatar_url(owner_avatar_url);
}

void Guild::FillGuildDB(ss::MFGuildDB& guild_pb)
{
    for (auto& pair : member_hash_) {
        auto p = guild_pb.add_members();
        TypeConvert::Convert(*pair.second, *p->mutable_base_data());
    }
}

void Guild::SerializeMembers(std::string& guild_members)
{
    a8::MutableXObject* members_xobj = a8::MutableXObject::NewArray();
    for (auto& pair : member_hash_) {
        a8::MutableXObject* member_xobj = a8::MutableXObject::NewObject();
        member_xobj->SetVal("account_id", pair.second->account_id);
        member_xobj->SetVal("nickname", pair.second->nickname);
        member_xobj->SetVal("guild_job", pair.second->guild_job);
        members_xobj->Push(*member_xobj);
        delete member_xobj;
    }
    members_xobj->ToJsonStr(guild_members);
    delete members_xobj;
}

void Guild::SaveToDB()
{
    std::string guild_data;
    std::string guild_log;
    std::string guild_members;
    {
        ss::MFGuildDB guild_db;
        FillGuildDB(guild_db);
        guild_db.SerializeToString(&guild_data);
    }
    {
        logdb_->SerializeToString(&guild_log);
        SerializeMembers(guild_members);
    }

    auto on_ok =
        [] (a8::XParams& param, const f8::DataSet* data_set)
        {

        };
    auto on_error =
        [] (a8::XParams& param, int error_code, const std::string& error_msg)
        {

        };

    a8::XObject conn_info = DBEngine::Instance()->GetConnInfo(guild_id);
    DBEngine::Instance()->ExecAsyncScript
        (
         conn_info,
         "UPDATE `guild` SET guild_name='%s', guild_lv=%d, guild_exp=%d, guild_badge=%d, "
         "  guild_apply_num=%d, guild_members='%s', guild_notice='%s', guild_declaration='%s', "
         "  guild_log='%s', owner_id='%s', owner_name='%s', owner_avatar_url='%s', "
         "  creator_id='%s', creator_name='%s', creator_avatar_url='%s', guild_data='%s', guild_status='%d', "
         "  modifytime=%d "
         "WHERE guild_id=%d;",
         {
          guild_name,
          guild_lv,
          guild_exp,
          guild_badge,
          guild_apply_num,
          guild_members,
          guild_notice,
          guild_declaration,
          guild_log,
          owner_id,
          owner_name,
          owner_avatar_url,
          creator_id,
          creator_name,
          creator_avatar_url,
          guild_data,
          guild_status,
          App::Instance()->nowtime,
          guild_id
         },
         a8::XParams(),
         on_ok,
         on_error,
         guild_id
         );
}

void Guild::GenSortedMembers()
{
    sorted_members_.clear();
    for (auto& pair : member_hash_) {
        sorted_members_.push_back(pair.second);
    }
}