742 lines
27 KiB
C++
742 lines
27 KiB
C++
#include "precompile.h"
|
|
|
|
#include <a8/udplog.h>
|
|
#include <a8/timer.h>
|
|
|
|
#include "guildmgr.h"
|
|
#include "typeconvert.h"
|
|
#include "ss_proto.pb.h"
|
|
#include "cs_proto.pb.h"
|
|
#include "dbengine.h"
|
|
#include "app.h"
|
|
#include "jsondatamgr.h"
|
|
#include "IMListener.h"
|
|
#include "metamgr.h"
|
|
|
|
const size_t MAX_RANK_HUMAN_NUM = 50;
|
|
const char* const NAME_MAGIC_SYMBOL = "@";
|
|
|
|
void GuildMgr::Init()
|
|
{
|
|
auto mysql_cluster_conf = JsonDataMgr::Instance()->GetMysqlClusterConf();
|
|
for (int i = 0; i < mysql_cluster_conf->Size(); ++i) {
|
|
int instance_id = mysql_cluster_conf->At(i)->At("instance_id")->AsXValue();
|
|
pending_db_hash_[instance_id] = 0;
|
|
sync_db_hash_[instance_id] = App::Instance()->nowtime;
|
|
LoadGuild(instance_id, 0);
|
|
}
|
|
}
|
|
|
|
void GuildMgr::UnInit()
|
|
{
|
|
|
|
}
|
|
|
|
void GuildMgr::__GuildCreate(f8::JsonHttpRequest* request)
|
|
{
|
|
if (!load_done_) {
|
|
request->resp_xobj->SetVal("errcode", 2);
|
|
request->resp_xobj->SetVal("errmsg", "");
|
|
return;
|
|
}
|
|
|
|
long long guild_id = request->request.At("guild_id")->AsXValue();
|
|
if (GetGuildById(guild_id)) {
|
|
request->resp_xobj->SetVal("errcode", 1);
|
|
request->resp_xobj->SetVal("errmsg", "guild_id已经存在");
|
|
return;
|
|
}
|
|
|
|
std::string guild_data;
|
|
cs::MFGuildBasic* guild = new cs::MFGuildBasic;
|
|
TypeConvert::Convert(request, guild);
|
|
if (guild->guild_name().empty()) {
|
|
request->resp_xobj->SetVal("errcode", 2);
|
|
request->resp_xobj->SetVal("errmsg", "公会名字不能为空");
|
|
delete guild;
|
|
return;
|
|
}
|
|
if (GetGuildByName(
|
|
guild->_gameid(),
|
|
guild->_channel(),
|
|
guild->guild_name()
|
|
)) {
|
|
request->resp_xobj->SetVal("errcode", 3);
|
|
request->resp_xobj->SetVal("errmsg", "公会名已经存在");
|
|
delete guild;
|
|
return;
|
|
}
|
|
if (MetaMgr::Instance()->HasDirtyWord(guild->guild_name())) {
|
|
request->resp_xobj->SetVal("errcode", 4);
|
|
request->resp_xobj->SetVal("errmsg", "公会名含有违禁字符");
|
|
delete guild;
|
|
return;
|
|
}
|
|
if (MetaMgr::Instance()->HasDirtyWord(guild->guild_declaration())) {
|
|
request->resp_xobj->SetVal("errcode", 5);
|
|
request->resp_xobj->SetVal("errmsg", "公会宣言含有违禁字符");
|
|
delete guild;
|
|
return;
|
|
}
|
|
|
|
request->pending = true;
|
|
request->resp_xobj->SetVal("errcode", 0);
|
|
request->resp_xobj->SetVal("errmsg", "");
|
|
a8::XObject conn = DBEngine::Instance()->GetConnInfo(guild_id);
|
|
guild->set_member_num(1);
|
|
DBEngine::Instance()->ExecAsyncScript
|
|
(
|
|
conn,
|
|
"INSERT INTO `guild`(gameid, channel, guild_id, guild_name, guild_lv, guild_exp, guild_badge, "
|
|
" guild_apply_num, guild_notice, guild_declaration, guild_log, owner_id, "
|
|
" owner_name, owner_avatar_url, creator_id, creator_name, creator_avatar_url, guild_member_num, "
|
|
" guild_data, guild_status, join_unlimited, join_cond1, join_cond2, createtime, modifytime)"
|
|
"VALUES(%d, %d, %d, '%s', %d, %d, %d, %d, '%s', '%s', '%s', '%s', "
|
|
" '%s', '%s', '%s', '%s', '%s', 1, "
|
|
" '%s', %d, %d, %d, %d, %d, %d);",
|
|
{
|
|
guild->_gameid(),
|
|
guild->_channel(),
|
|
guild->guild_id(),
|
|
guild->guild_name(),
|
|
guild->guild_lv(),
|
|
guild->guild_exp(),
|
|
guild->guild_badge(),
|
|
0,
|
|
"",
|
|
guild->guild_declaration(),
|
|
"",
|
|
guild->owner_id(),
|
|
guild->owner_name(),
|
|
guild->owner_avatar_url(),
|
|
guild->owner_id(),
|
|
guild->owner_name(),
|
|
guild->owner_avatar_url(),
|
|
guild_data,
|
|
guild->member_num(),
|
|
guild->join_unlimited(),
|
|
guild->join_cond1(),
|
|
guild->join_cond2(),
|
|
App::Instance()->nowtime,
|
|
App::Instance()->nowtime
|
|
},
|
|
a8::XParams()
|
|
.SetSender(request)
|
|
.SetParam1(guild),
|
|
[] (a8::XParams& param, const f8::DataSet* data_set)
|
|
{
|
|
f8::JsonHttpRequest* request = (f8::JsonHttpRequest*)param.sender.GetUserData();
|
|
cs::MFGuildBasic* guild = (cs::MFGuildBasic*)param.param1.GetUserData();
|
|
|
|
GuildMgr::Instance()->AddGuild(guild);
|
|
|
|
{
|
|
std::string response;
|
|
request->resp_xobj->ToJsonStr(response);
|
|
IMListener::Instance()->SendText(request->socket_handle, a8::HttpResponse(response));
|
|
}
|
|
|
|
delete request;
|
|
},
|
|
[] (a8::XParams& param, int error_code, const std::string& error_msg)
|
|
{
|
|
f8::JsonHttpRequest* request = (f8::JsonHttpRequest*)param.sender.GetUserData();
|
|
cs::MFGuildBasic* guild = (cs::MFGuildBasic*)param.param1.GetUserData();
|
|
|
|
{
|
|
std::string response;
|
|
request->resp_xobj->SetVal("errcode", 2);
|
|
request->resp_xobj->SetVal("errmsg", "服务器内部错误");
|
|
request->resp_xobj->ToJsonStr(response);
|
|
IMListener::Instance()->SendText(request->socket_handle, a8::HttpResponse(response));
|
|
}
|
|
|
|
delete guild;
|
|
delete request;
|
|
},
|
|
0);
|
|
}
|
|
|
|
void GuildMgr::__GuildSearch(f8::JsonHttpRequest* request)
|
|
{
|
|
if (!load_done_) {
|
|
request->resp_xobj->SetVal("errcode", 2);
|
|
request->resp_xobj->SetVal("errmsg", "");
|
|
return;
|
|
}
|
|
int curr_page = request->request.At("curr_page")->AsXValue();
|
|
int page_size = request->request.At("page_size")->AsXValue();
|
|
std::string search_name = request->request.At("guild_name")->AsXValue().GetString();
|
|
if (curr_page < 0) {
|
|
curr_page = 0;
|
|
}
|
|
if (page_size < 1) {
|
|
page_size = 1;
|
|
}
|
|
int total_page = 0;
|
|
int total_count = 0;
|
|
std::vector<cs::MFGuildBasic*> last_page_data;
|
|
|
|
request->resp_xobj->SetVal("errcode", 0);
|
|
request->resp_xobj->SetVal("errmsg", "");
|
|
request->resp_xobj->SetVal("curr_page", curr_page);
|
|
request->resp_xobj->SetVal("page_size", page_size);
|
|
a8::MutableXObject* guild_list = a8::MutableXObject::NewArray();
|
|
for (auto& pair : id_hash_) {
|
|
cs::MFGuildBasic* guild = pair.second;
|
|
if (guild->guild_name().find(search_name) != std::string::npos) {
|
|
++total_count;
|
|
last_page_data.push_back(guild);
|
|
if (last_page_data.size() % page_size == 0) {
|
|
last_page_data.clear();
|
|
}
|
|
if (total_count >= curr_page * page_size && guild_list->Size() < page_size) {
|
|
a8::MutableXObject* guild_xobj = a8::MutableXObject::NewObject();
|
|
TypeConvert::Convert(guild, guild_xobj);
|
|
guild_list->Push(*guild_xobj);
|
|
delete guild_xobj;
|
|
}
|
|
}
|
|
}
|
|
total_page = std::ceil((double)total_count / page_size);
|
|
if (curr_page >= total_page) {
|
|
for (auto& guild : last_page_data) {
|
|
a8::MutableXObject* guild_xobj = a8::MutableXObject::NewObject();
|
|
TypeConvert::Convert(guild, guild_xobj);
|
|
delete guild_xobj;
|
|
}
|
|
curr_page = total_page - 1;
|
|
}
|
|
request->resp_xobj->SetVal("_total_page", total_page);
|
|
request->resp_xobj->SetVal("_total_count", total_count);
|
|
request->resp_xobj->SetVal("guild_list", *guild_list);
|
|
delete guild_list;
|
|
}
|
|
|
|
void GuildMgr::__GuildUpdate(f8::JsonHttpRequest* request)
|
|
{
|
|
if (!load_done_) {
|
|
request->resp_xobj->SetVal("errcode", 2);
|
|
request->resp_xobj->SetVal("errmsg", "");
|
|
return;
|
|
}
|
|
long long guild_id = request->request.At("guild_id")->AsXValue();
|
|
cs::MFGuildBasic* guild = GetGuildById(guild_id);
|
|
if (guild) {
|
|
#if 0
|
|
guild->set_guild_name(request->request.At("guild_name")->AsXValue().GetString());
|
|
#endif
|
|
guild->set_guild_badge(request->request.At("guild_badge")->AsXValue());
|
|
guild->set_guild_lv(request->request.At("guild_lv")->AsXValue());
|
|
guild->set_guild_exp(request->request.At("guild_exp")->AsXValue());
|
|
guild->set_guild_declaration(request->request.At("guild_declaration")->AsXValue().GetString());
|
|
guild->set_owner_id(request->request.At("owner_id")->AsXValue());
|
|
guild->set_owner_name(request->request.At("owner_name")->AsXValue().GetString());
|
|
guild->set_owner_avatar_url(request->request.At("owner_avatar_url")->AsXValue().GetString());
|
|
guild->set_join_unlimited(request->request.At("join_unlimited")->AsXValue());
|
|
guild->set_join_cond1(request->request.At("join_cond1")->AsXValue());
|
|
guild->set_join_cond2(request->request.At("join_cond2")->AsXValue());
|
|
}
|
|
request->resp_xobj->SetVal("errcode", 0);
|
|
request->resp_xobj->SetVal("errmsg", "");
|
|
}
|
|
|
|
void GuildMgr::__GuildRename(f8::JsonHttpRequest* request)
|
|
{
|
|
if (!load_done_) {
|
|
request->resp_xobj->SetVal("errcode", 2);
|
|
request->resp_xobj->SetVal("errmsg", "服务器内部错误");
|
|
return;
|
|
}
|
|
request->resp_xobj->SetVal("errcode", 0);
|
|
request->resp_xobj->SetVal("errmsg", "");
|
|
|
|
long long guild_id = request->request.At("guild_id")->AsXValue();
|
|
std::string guild_name = request->request.At("guild_name")->AsXValue().GetString();
|
|
std::string guild_declaration = request->request.At("guild_declaration")->AsXValue().GetString();
|
|
cs::MFGuildBasic* guild = GetGuildById(guild_id);
|
|
if (!guild) {
|
|
request->resp_xobj->SetVal("errcode", 1);
|
|
request->resp_xobj->SetVal("errmsg", "服务器内部错误");
|
|
return;
|
|
}
|
|
if (guild->guild_declaration() != guild_declaration) {
|
|
if (MetaMgr::Instance()->HasDirtyWord(guild_declaration)) {
|
|
request->resp_xobj->SetVal("errcode", 1);
|
|
request->resp_xobj->SetVal("errmsg", "公会宣言含有违禁字符");
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (guild->guild_name() == guild_name) {
|
|
guild->set_guild_declaration(guild_declaration);
|
|
return;
|
|
}
|
|
if (guild_name.empty()) {
|
|
request->resp_xobj->SetVal("errcode", 1);
|
|
request->resp_xobj->SetVal("errmsg", "公会名不能为空");
|
|
return;
|
|
}
|
|
if (GetGuildByName(guild->_gameid(), guild->_channel(), guild_name)) {
|
|
request->resp_xobj->SetVal("errcode", 1);
|
|
request->resp_xobj->SetVal("errmsg", "公会名已经存在");
|
|
return;
|
|
}
|
|
if (MetaMgr::Instance()->HasDirtyWord(guild_name)) {
|
|
request->resp_xobj->SetVal("errcode", 1);
|
|
request->resp_xobj->SetVal("errmsg", "公会名含有违禁字符");
|
|
return;
|
|
}
|
|
|
|
request->pending = true;
|
|
request->resp_xobj->SetVal("errcode", 0);
|
|
request->resp_xobj->SetVal("errmsg", "");
|
|
a8::XObject conn = DBEngine::Instance()->GetConnInfo(guild_id);
|
|
DBEngine::Instance()->ExecAsyncScript
|
|
(
|
|
conn,
|
|
"UPDATE `guild` SET guild_name='%s', guild_declaration='%s' "
|
|
"WHERE guild_id=%d;",
|
|
{
|
|
guild_name,
|
|
guild_declaration,
|
|
guild->guild_id()
|
|
},
|
|
a8::XParams()
|
|
.SetSender(request)
|
|
.SetParam1(guild),
|
|
[] (a8::XParams& param, const f8::DataSet* data_set)
|
|
{
|
|
f8::JsonHttpRequest* request = (f8::JsonHttpRequest*)param.sender.GetUserData();
|
|
cs::MFGuildBasic* guild = (cs::MFGuildBasic*)param.param1.GetUserData();
|
|
std::string guild_name = request->request.At("guild_name")->AsXValue().GetString();
|
|
std::string guild_declaration = request->request.At("guild_declaration")->AsXValue().GetString();
|
|
|
|
guild->set_guild_name(guild_name);
|
|
guild->set_guild_declaration(guild_declaration);
|
|
{
|
|
std::string response;
|
|
request->resp_xobj->ToJsonStr(response);
|
|
IMListener::Instance()->SendText(request->socket_handle, a8::HttpResponse(response));
|
|
}
|
|
|
|
delete request;
|
|
},
|
|
[] (a8::XParams& param, int error_code, const std::string& error_msg)
|
|
{
|
|
f8::JsonHttpRequest* request = (f8::JsonHttpRequest*)param.sender.GetUserData();
|
|
|
|
{
|
|
std::string response;
|
|
request->resp_xobj->SetVal("errcode", 2);
|
|
request->resp_xobj->SetVal("errmsg", "服务器内部错误");
|
|
request->resp_xobj->ToJsonStr(response);
|
|
IMListener::Instance()->SendText(request->socket_handle, a8::HttpResponse(response));
|
|
}
|
|
|
|
delete request;
|
|
},
|
|
0);
|
|
}
|
|
|
|
void GuildMgr::__GuildRank(f8::JsonHttpRequest* request)
|
|
{
|
|
if (!load_done_) {
|
|
request->resp_xobj->SetVal("errcode", 2);
|
|
request->resp_xobj->SetVal("errmsg", "");
|
|
return;
|
|
}
|
|
|
|
int gameid = request->request.At("gameid")->AsXValue();
|
|
std::vector<cs::MFGuildBasic*>* sorted_guild_list = GetGuildRank(gameid);
|
|
|
|
request->resp_xobj->SetVal("errcode", 0);
|
|
request->resp_xobj->SetVal("errmsg", "");
|
|
request->resp_xobj->SetVal("curr_page", 0);
|
|
request->resp_xobj->SetVal("page_size", 50);
|
|
request->resp_xobj->SetVal("_total_page", 1);
|
|
request->resp_xobj->SetVal("_total_count", 0);
|
|
a8::MutableXObject* guild_list = a8::MutableXObject::NewArray();
|
|
if (sorted_guild_list) {
|
|
request->resp_xobj->SetVal("_total_count", sorted_guild_list->size());
|
|
for (auto& guild : *sorted_guild_list) {
|
|
a8::MutableXObject* guild_xobj = a8::MutableXObject::NewObject();
|
|
TypeConvert::Convert(guild, guild_xobj);
|
|
guild_list->Push(*guild_xobj);
|
|
delete guild_xobj;
|
|
}
|
|
}
|
|
request->resp_xobj->SetVal("guild_list", *guild_list);
|
|
delete guild_list;
|
|
}
|
|
|
|
void GuildMgr::__GuildConfirmed(f8::JsonHttpRequest* request)
|
|
{
|
|
|
|
}
|
|
|
|
void GuildMgr::__GenTestData(f8::JsonHttpRequest* request)
|
|
{
|
|
if (!load_done_) {
|
|
request->resp_xobj->SetVal("errcode", 2);
|
|
request->resp_xobj->SetVal("errmsg", "");
|
|
return;
|
|
}
|
|
request->resp_xobj->SetVal("errcode", 0);
|
|
request->resp_xobj->SetVal("errmsg", "");
|
|
int num = request->request.At("num")->AsXValue();
|
|
int gameid = request->request.At("gameid")->AsXValue();
|
|
for (int i = 0; i < num; ++i) {
|
|
long long guild_id = App::Instance()->NewUuid();
|
|
a8::XObject conn = DBEngine::Instance()->GetConnInfo(guild_id);
|
|
DBEngine::Instance()->ExecAsyncScript
|
|
(
|
|
conn,
|
|
"INSERT INTO `guild`(gameid, guild_id, guild_name, guild_lv, guild_exp, guild_badge, "
|
|
" guild_apply_num, guild_notice, guild_declaration, guild_log, owner_id, "
|
|
" owner_name, owner_avatar_url, creator_id, creator_name, creator_avatar_url, "
|
|
" guild_data, guild_status, createtime, modifytime)"
|
|
"VALUES(%d, %d, '%s', %d, %d, %d, %d, '%s', '%s', '%s', '%s', "
|
|
" '%s', '%s', '%s', '%s', '%s', "
|
|
" '%s', %d, %d, %d)",
|
|
{
|
|
gameid,
|
|
guild_id,
|
|
a8::Format("测试公会%d", { i + 1}),
|
|
1,
|
|
1,
|
|
1,
|
|
0,
|
|
"",
|
|
"公会宣言",
|
|
"",
|
|
1,
|
|
"1",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
0,
|
|
App::Instance()->nowtime,
|
|
App::Instance()->nowtime
|
|
},
|
|
a8::XParams(),
|
|
[] (a8::XParams& param, const f8::DataSet* data_set)
|
|
{
|
|
},
|
|
[] (a8::XParams& param, int error_code, const std::string& error_msg)
|
|
{
|
|
abort();
|
|
},
|
|
guild_id);
|
|
}
|
|
}
|
|
|
|
cs::MFGuildBasic* GuildMgr::GetGuildById(long long guild_id)
|
|
{
|
|
auto itr = id_hash_.find(guild_id);
|
|
return itr != id_hash_.end() ? itr->second : nullptr;
|
|
}
|
|
|
|
cs::MFGuildBasic* GuildMgr::GetGuildByName(int gameid, int channel, const std::string& guild_name)
|
|
{
|
|
auto itr = name_hash_.find(GenGuildName(gameid, channel, guild_name));
|
|
return itr != name_hash_.end() ? itr->second : nullptr;
|
|
}
|
|
|
|
std::vector<cs::MFGuildBasic*>* GuildMgr::GetGuildRank(int gameid)
|
|
{
|
|
auto itr = sorted_game_guild_list_.find(gameid);
|
|
return itr != sorted_game_guild_list_.end() ? &itr->second : nullptr;
|
|
}
|
|
|
|
void GuildMgr::AddGuild(cs::MFGuildBasic* guild)
|
|
{
|
|
id_hash_[guild->guild_id()] = guild;
|
|
name_hash_[GenGuildName(guild->_gameid(), guild->_channel(), guild->guild_name())] = guild;
|
|
}
|
|
|
|
void GuildMgr::LoadGuild(int instance_id, long long last_idx)
|
|
{
|
|
DBEngine::Instance()->ExecAsyncQuery
|
|
(
|
|
*JsonDataMgr::Instance()->GetMysqlConf(instance_id),
|
|
"SELECT idx, gameid, guild_id, guild_name, guild_lv, guild_exp, guild_badge, guild_notice, "
|
|
" guild_declaration, owner_id, owner_name, owner_avatar_url, "
|
|
" creator_id, creator_name, creator_avatar_url, guild_status, "
|
|
" join_unlimited, join_cond1, join_cond2, createtime, modifytime, channel "
|
|
"FROM `guild` WHERE idx > %d;",
|
|
{
|
|
last_idx
|
|
},
|
|
a8::XParams()
|
|
.SetSender(instance_id)
|
|
.SetParam1(last_idx),
|
|
[] (a8::XParams& param, const f8::DataSet* data_set)
|
|
{
|
|
int instance_id = param.sender;
|
|
long long last_idx = param.param1;
|
|
if (data_set && !data_set->empty()) {
|
|
for (auto& row : *data_set) {
|
|
cs::MFGuildBasic* guild = new cs::MFGuildBasic;
|
|
guild->set_guild_id(a8::XValue(row[2]));
|
|
guild->set_guild_name(row[3]);
|
|
guild->set_guild_lv(a8::XValue(row[4]));
|
|
guild->set_guild_exp(a8::XValue(row[5]));
|
|
guild->set_guild_badge(a8::XValue(row[6]));
|
|
guild->set_guild_declaration(row[8]);
|
|
guild->set_owner_id(row[9]);
|
|
guild->set_owner_name(row[10]);
|
|
guild->set_owner_avatar_url(row[11]);
|
|
guild->set_join_unlimited(a8::XValue(row[13]));
|
|
guild->set_join_cond1(a8::XValue(row[14]));
|
|
guild->set_join_cond2(a8::XValue(row[15]));
|
|
guild->set__gameid(a8::XValue(row[1]));
|
|
guild->set__channel(a8::XValue(row[18]));
|
|
GuildMgr::Instance()->AddGuild(guild);
|
|
if (a8::XValue(row[0]).GetInt64() > last_idx) {
|
|
last_idx = a8::XValue(row[0]);
|
|
}
|
|
}
|
|
GuildMgr::Instance()->LoadGuild(instance_id, last_idx);
|
|
} else {
|
|
GuildMgr::Instance()->OnOneDBDone(instance_id);
|
|
}
|
|
},
|
|
[] (a8::XParams& param, int error_code, const std::string& error_msg)
|
|
{
|
|
abort();
|
|
},
|
|
instance_id);
|
|
}
|
|
|
|
void GuildMgr::SyncGuild(int instance_id)
|
|
{
|
|
#if 1
|
|
DBEngine::Instance()->ExecAsyncQuery
|
|
(
|
|
*JsonDataMgr::Instance()->GetMysqlConf(instance_id),
|
|
"SELECT idx, gameid, guild_id, guild_name, guild_lv, guild_exp, guild_badge, guild_notice, "
|
|
" guild_declaration, owner_id, owner_name, owner_avatar_url, "
|
|
" creator_id, creator_name, creator_avatar_url, guild_status, "
|
|
" join_unlimited, join_cond1, join_cond2, createtime, modifytime, channel, guild_member_num "
|
|
"FROM `guild` WHERE modifytime > %d;",
|
|
{
|
|
sync_db_hash_[instance_id]
|
|
},
|
|
a8::XParams()
|
|
.SetSender(instance_id),
|
|
[] (a8::XParams& param, const f8::DataSet* data_set)
|
|
{
|
|
int instance_id = param.sender;
|
|
if (data_set && !data_set->empty()) {
|
|
int last_sync_time = GuildMgr::Instance()->sync_db_hash_[instance_id];
|
|
for (auto& row : *data_set) {
|
|
cs::MFGuildBasic* guild = new cs::MFGuildBasic;
|
|
guild->set_guild_id(a8::XValue(row[2]));
|
|
guild->set_guild_name(row[3]);
|
|
guild->set_guild_lv(a8::XValue(row[4]));
|
|
guild->set_guild_exp(a8::XValue(row[5]));
|
|
guild->set_guild_badge(a8::XValue(row[6]));
|
|
guild->set_guild_declaration(row[8]);
|
|
guild->set_owner_id(row[9]);
|
|
guild->set_owner_name(row[10]);
|
|
guild->set_owner_avatar_url(row[11]);
|
|
guild->set_join_unlimited(a8::XValue(row[13]));
|
|
guild->set_join_cond1(a8::XValue(row[14]));
|
|
guild->set_join_cond2(a8::XValue(row[15]));
|
|
guild->set__gameid(a8::XValue(row[1]));
|
|
guild->set__channel(a8::XValue(row[18]));
|
|
guild->set_member_num(a8::XValue(row[19]));
|
|
if (a8::XValue(row[17]).GetInt64() > last_sync_time) {
|
|
last_sync_time = a8::XValue(row[17]);
|
|
}
|
|
GuildMgr::Instance()->UpdateGuild(guild);
|
|
delete guild;
|
|
}
|
|
if (last_sync_time > GuildMgr::Instance()->sync_db_hash_[instance_id]) {
|
|
GuildMgr::Instance()->sync_db_hash_[instance_id] = last_sync_time;
|
|
}
|
|
}
|
|
},
|
|
[] (a8::XParams& param, int error_code, const std::string& error_msg)
|
|
{
|
|
abort();
|
|
},
|
|
instance_id);
|
|
#endif
|
|
}
|
|
|
|
void GuildMgr::OnOneDBDone(int instance_id)
|
|
{
|
|
if (pending_db_hash_.find(instance_id) == pending_db_hash_.end() ||
|
|
pending_db_hash_[instance_id] == 1) {
|
|
abort();
|
|
}
|
|
pending_db_hash_[instance_id] = 1;
|
|
load_done_ = true;
|
|
for (auto& pair : pending_db_hash_) {
|
|
if (!pair.second) {
|
|
load_done_ = false;
|
|
break;
|
|
}
|
|
}
|
|
a8::UdpLog::Instance()->Debug("%d db done", {instance_id});
|
|
if (load_done_) {
|
|
a8::UdpLog::Instance()->Debug("all db done guild_num:%d", {id_hash_.size()});
|
|
GenGuildRank();
|
|
InstallSyncGuildTimer();
|
|
}
|
|
}
|
|
|
|
void GuildMgr::RefreshGuild(long long guild_id)
|
|
{
|
|
a8::XObject conn = DBEngine::Instance()->GetConnInfo(guild_id);
|
|
DBEngine::Instance()->ExecAsyncQuery
|
|
(
|
|
conn,
|
|
"SELECT idx, gameid, guild_id, guild_name, guild_lv, guild_exp, guild_badge, guild_notice, "
|
|
" guild_declaration, owner_id, owner_name, owner_avatar_url, "
|
|
" creator_id, creator_name, creator_avatar_url, guild_status, "
|
|
" join_unlimited, join_cond1, join_cond2, createtime, modifytime "
|
|
"FROM `guild` WHERE guild_id = %d;",
|
|
{
|
|
guild_id
|
|
},
|
|
a8::XParams()
|
|
.SetSender(guild_id),
|
|
[] (a8::XParams& param, const f8::DataSet* data_set)
|
|
{
|
|
if (data_set && !data_set->empty()) {
|
|
for (auto& row : *data_set) {
|
|
cs::MFGuildBasic* guild = GuildMgr::Instance()->GetGuildById(a8::XValue(row[2]));
|
|
if (guild) {
|
|
#if 0
|
|
guild->set_guild_name(row[3]);
|
|
#endif
|
|
guild->set_guild_lv(a8::XValue(row[4]));
|
|
guild->set_guild_exp(a8::XValue(row[5]));
|
|
guild->set_guild_badge(a8::XValue(row[6]));
|
|
guild->set_guild_declaration(row[8]);
|
|
guild->set_owner_id(row[9]);
|
|
guild->set_owner_name(row[10]);
|
|
guild->set_owner_avatar_url(row[11]);
|
|
guild->set_join_unlimited(a8::XValue(row[13]));
|
|
guild->set_join_cond1(a8::XValue(row[14]));
|
|
guild->set_join_cond2(a8::XValue(row[15]));
|
|
}
|
|
}
|
|
}
|
|
},
|
|
[] (a8::XParams& param, int error_code, const std::string& error_msg)
|
|
{
|
|
abort();
|
|
},
|
|
guild_id);
|
|
}
|
|
|
|
void GuildMgr::GenGuildRank()
|
|
{
|
|
auto force_rank_list =
|
|
[this] (int gameid) -> std::vector<cs::MFGuildBasic*>&
|
|
{
|
|
auto itr = sorted_game_guild_list_.find(gameid);
|
|
if (itr != sorted_game_guild_list_.end()) {
|
|
return itr->second;
|
|
}
|
|
sorted_game_guild_list_[gameid] = std::vector<cs::MFGuildBasic*>();
|
|
return sorted_game_guild_list_[gameid];
|
|
};
|
|
sorted_game_guild_list_.clear();
|
|
for (auto& pair : id_hash_) {
|
|
auto guild = pair.second;
|
|
std::vector<cs::MFGuildBasic*>& rank_list = force_rank_list(guild->_gameid());
|
|
UpdateRank(rank_list, guild);
|
|
}
|
|
}
|
|
|
|
void GuildMgr::ResortRank(std::vector<cs::MFGuildBasic*>& rank_list)
|
|
{
|
|
#if 0
|
|
std::sort(rank_list.begin(),
|
|
rank_list.end(),
|
|
[] (cs::MFGuildBasic* a, cs::MFGuildBasic* b) -> bool
|
|
{
|
|
return GuildMgr::Instance()->CmpGuild(a, b);
|
|
});
|
|
#endif
|
|
}
|
|
|
|
void GuildMgr::UpdateRank(std::vector<cs::MFGuildBasic*>& rank_list, cs::MFGuildBasic* guild)
|
|
{
|
|
if (rank_list.size() < MAX_RANK_HUMAN_NUM) {
|
|
if (std::find(rank_list.begin(), rank_list.end(), guild) == rank_list.end()) {
|
|
rank_list.push_back(guild);
|
|
ResortRank(rank_list);
|
|
}
|
|
} else {
|
|
if (CmpGuild(guild, rank_list[rank_list.size() - 1])) {
|
|
if (std::find(rank_list.begin(), rank_list.end(), guild) == rank_list.end()) {
|
|
rank_list[rank_list.size() - 1] = guild;
|
|
ResortRank(rank_list);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void GuildMgr::UpdateGuild(cs::MFGuildBasic* new_guild)
|
|
{
|
|
auto guild = GetGuildById(new_guild->guild_id());
|
|
if (guild) {
|
|
#if 0
|
|
guild->set_guild_name(new_guild->guild_name());
|
|
#endif
|
|
guild->set_guild_lv(new_guild->guild_lv());
|
|
guild->set_guild_exp(new_guild->guild_exp());
|
|
guild->set_guild_badge(new_guild->guild_badge());
|
|
guild->set_member_num((new_guild->member_num()));
|
|
guild->set_guild_declaration((new_guild->guild_declaration()));
|
|
guild->set_owner_id((new_guild->owner_id()));
|
|
guild->set_owner_name((new_guild->owner_name()));
|
|
guild->set_owner_avatar_url((new_guild->owner_avatar_url()));
|
|
guild->set_join_unlimited((new_guild->join_unlimited()));
|
|
guild->set_join_cond1((new_guild->join_cond1()));
|
|
guild->set_join_cond2((new_guild->join_cond2()));
|
|
}
|
|
}
|
|
|
|
bool GuildMgr::CmpGuild(cs::MFGuildBasic* a, cs::MFGuildBasic* b)
|
|
{
|
|
if (a->guild_lv() > b->guild_lv()) {
|
|
return true;
|
|
}
|
|
if (a->guild_exp() > b->guild_exp()) {
|
|
return true;
|
|
}
|
|
return a->guild_id() > b->guild_id();
|
|
}
|
|
|
|
void GuildMgr::InstallSyncGuildTimer()
|
|
{
|
|
auto mysql_cluster_conf = JsonDataMgr::Instance()->GetMysqlClusterConf();
|
|
for (int i = 0; i < mysql_cluster_conf->Size(); ++i) {
|
|
int instance_id = mysql_cluster_conf->At(i)->At("instance_id")->AsXValue();
|
|
a8::Timer::Instance()->AddRepeatTimerAndAttach
|
|
(1000 * 60,
|
|
a8::XParams()
|
|
.SetSender(instance_id),
|
|
[] (const a8::XParams& param)
|
|
{
|
|
GuildMgr::Instance()->SyncGuild(param.sender);
|
|
},
|
|
&timer_attacher_.timer_list_);
|
|
}
|
|
}
|
|
|
|
std::string GuildMgr::GenGuildName(int gameid, int channel, const std::string& raw_name)
|
|
{
|
|
std::string guild_name = a8::XValue(gameid).GetString() + NAME_MAGIC_SYMBOL + raw_name;
|
|
return guild_name;
|
|
}
|