502 lines
16 KiB
C++
502 lines
16 KiB
C++
#include "precompile.h"
|
|
|
|
#include <a8/openssl.h>
|
|
#include <a8/timer.h>
|
|
#include <a8/mutable_xobject.h>
|
|
|
|
#include "dbengine.h"
|
|
|
|
#include "dbhelper.h"
|
|
#include "player.h"
|
|
#include "playermgr.h"
|
|
#include "app.h"
|
|
#include "synchelper.h"
|
|
#include "guild.h"
|
|
|
|
#include "cs_proto.pb.h"
|
|
#include "ss_proto.pb.h"
|
|
|
|
#include "framework/cpp/httpclientpool.h"
|
|
|
|
void DBHelper::Init()
|
|
{
|
|
}
|
|
|
|
void DBHelper::UnInit()
|
|
{
|
|
}
|
|
|
|
void DBHelper::SetFriendApplyStatus(
|
|
unsigned int crc32_code,
|
|
const std::string& sender_id,
|
|
const std::string& target_id,
|
|
int status)
|
|
{
|
|
a8::XObject conn_info = DBEngine::Instance()->GetConnInfo(crc32_code);
|
|
DBEngine::Instance()->ExecAsyncScript
|
|
(
|
|
conn_info,
|
|
"UPDATE `friend_apply` SET status=%d WHERE target_id='%s' AND sender_id='%s';",
|
|
{
|
|
status,
|
|
target_id,
|
|
sender_id
|
|
},
|
|
a8::XParams(),
|
|
nullptr,
|
|
nullptr,
|
|
crc32_code
|
|
);
|
|
}
|
|
|
|
void DBHelper::SetFriendApplyStatus(
|
|
unsigned int crc32_code,
|
|
long long idx,
|
|
const std::string& sender_id,
|
|
const std::string& target_id,
|
|
int status)
|
|
{
|
|
a8::XObject conn_info = DBEngine::Instance()->GetConnInfo(crc32_code);
|
|
DBEngine::Instance()->ExecAsyncScript
|
|
(
|
|
conn_info,
|
|
"UPDATE `friend_apply` SET status=%d WHERE idx=%d AND target_id='%s' AND sender_id='%s';",
|
|
{
|
|
status,
|
|
idx,
|
|
target_id,
|
|
sender_id
|
|
},
|
|
a8::XParams(),
|
|
nullptr,
|
|
nullptr,
|
|
crc32_code
|
|
);
|
|
}
|
|
|
|
void DBHelper::SetGuildApplyStatus(
|
|
const std::string& sender_id,
|
|
long long guild_id,
|
|
int status)
|
|
{
|
|
a8::XObject conn_info = DBEngine::Instance()->GetConnInfo(guild_id);
|
|
DBEngine::Instance()->ExecAsyncScript
|
|
(
|
|
conn_info,
|
|
"UPDATE `guild_apply` SET status=%d WHERE guild_id=%d AND sender_id='%s';",
|
|
{
|
|
status,
|
|
guild_id,
|
|
sender_id
|
|
},
|
|
a8::XParams(),
|
|
nullptr,
|
|
nullptr,
|
|
guild_id
|
|
);
|
|
}
|
|
|
|
void DBHelper::SetGuildApplyStatus(
|
|
long long idx,
|
|
const std::string& sender_id,
|
|
long long guild_id,
|
|
int status)
|
|
{
|
|
a8::XObject conn_info = DBEngine::Instance()->GetConnInfo(guild_id);
|
|
DBEngine::Instance()->ExecAsyncScript
|
|
(
|
|
conn_info,
|
|
"UPDATE `guild_apply` SET status=%d WHERE idx=%d AND guild_id=%d AND sender_id='%s';",
|
|
{
|
|
status,
|
|
idx,
|
|
guild_id,
|
|
sender_id
|
|
},
|
|
a8::XParams(),
|
|
nullptr,
|
|
nullptr,
|
|
guild_id
|
|
);
|
|
}
|
|
|
|
void DBHelper::ConfirmGuild(Player* hum, long long guild_id)
|
|
{
|
|
auto on_ok =
|
|
[] (a8::XParams& param, const f8::DataSet* data_set)
|
|
{
|
|
Player* hum = PlayerMgr::Instance()->GetPlayerByAccountId(param.sender.GetString());
|
|
if (hum) {
|
|
hum->UpdateGuildData(param.param1, kGuildOwner);
|
|
hum->SaveToDB
|
|
(a8::XParams()
|
|
.SetSender(hum->AccountId()),
|
|
[] (a8::XParams& param, const f8::DataSet* data_set)
|
|
{
|
|
Player* hum = PlayerMgr::Instance()->GetPlayerByAccountId(param.sender.GetString());
|
|
if (hum) {
|
|
cs::SMGuildCreate respmsg;
|
|
hum->SendMsg(respmsg);
|
|
}
|
|
},
|
|
[] (a8::XParams& param, int error_code, const std::string& error_msg)
|
|
{
|
|
|
|
}
|
|
);
|
|
|
|
std::string ip;
|
|
int port = 0;
|
|
JsonDataMgr::Instance()->GetRankServerConf(ip, port);
|
|
a8::MutableXObject* params = a8::MutableXObject::NewObject();
|
|
params->SetVal("guild_id", param.param1.GetInt64());
|
|
f8::HttpClientPool::Instance()->HttpGet
|
|
(
|
|
a8::XParams(),
|
|
[] (a8::XParams& param, a8::XObject& data)
|
|
{
|
|
},
|
|
[] (a8::XParams& param, const std::string& response)
|
|
{
|
|
},
|
|
a8::Format("http://%s:%d/webapp/index.php?c=Guild&a=confirmed", {ip, port}).c_str(),
|
|
*params,
|
|
param.param1.GetInt64()
|
|
);
|
|
delete params;
|
|
}
|
|
};
|
|
auto on_error =
|
|
[] (a8::XParams& param, int error_code, const std::string& error_msg)
|
|
{
|
|
|
|
};
|
|
|
|
std::string guild_data;
|
|
{
|
|
|
|
}
|
|
a8::XObject conn_info = DBEngine::Instance()->GetConnInfo(guild_id);
|
|
DBEngine::Instance()->ExecAsyncScript
|
|
(
|
|
conn_info,
|
|
"UPDATE `guild` SET status=%d, guild_data='%s', modifytime=%d WHERE guild_id=%d;",
|
|
{
|
|
kGuildCreated,
|
|
"",
|
|
App::Instance()->nowtime,
|
|
guild_id
|
|
},
|
|
a8::XParams()
|
|
.SetSender(hum->AccountId())
|
|
.SetParam1(guild_id),
|
|
on_ok,
|
|
on_error,
|
|
guild_id
|
|
);
|
|
}
|
|
|
|
void DBHelper::AddFriendApply(Player* hum, const std::string& target_id)
|
|
{
|
|
auto on_ok =
|
|
[] (a8::XParams& param, const f8::DataSet* data_set)
|
|
{
|
|
Player* hum = PlayerMgr::Instance()->GetPlayerByAccountId(param.sender.GetString());
|
|
if (hum) {
|
|
SyncHelper::Instance()->SyncApplyFriend(hum, param.param1.GetString());
|
|
}
|
|
};
|
|
auto on_error =
|
|
[] (a8::XParams& param, int error_code, const std::string& error_msg)
|
|
{
|
|
|
|
};
|
|
|
|
long long friend_crc32_code = a8::openssl::Crc32(
|
|
(unsigned char*)target_id.data(),
|
|
target_id.size()
|
|
);
|
|
a8::XObject conn_info = DBEngine::Instance()->GetConnInfo(friend_crc32_code);
|
|
DBEngine::Instance()->ExecAsyncScript
|
|
(
|
|
conn_info,
|
|
"INSERT INTO `friend_apply`(applyid, target_id, sender_id, sender_nickname, "
|
|
" sender_avatar_url, sender_sex, sender_data_version1, "
|
|
" createtime, sender_user_value1, sender_user_value2, sender_user_value3, status)"
|
|
"VALUES(%d, '%s', '%s', '%s', '%s', %d, %d, %d, %d, %d, %d, 0);",
|
|
{
|
|
App::Instance()->NewUUID(),
|
|
target_id,
|
|
hum->myself.base_data.account_id,
|
|
hum->myself.base_data.nickname,
|
|
hum->myself.base_data.avatar_url,
|
|
hum->myself.base_data.sex,
|
|
hum->myself.base_data.base_data_version,
|
|
App::Instance()->nowtime,
|
|
hum->myself.base_data.user_value1,
|
|
hum->myself.base_data.user_value2,
|
|
hum->myself.base_data.user_value3,
|
|
},
|
|
a8::XParams()
|
|
.SetSender(hum->AccountId())
|
|
.SetParam1(target_id),
|
|
on_ok,
|
|
on_error,
|
|
friend_crc32_code
|
|
);
|
|
}
|
|
|
|
void DBHelper::AddGuildApply(Guild* guild, const cs::MFUserInfo& user_info)
|
|
{
|
|
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->GuildId());
|
|
DBEngine::Instance()->ExecAsyncScript
|
|
(
|
|
conn_info,
|
|
"INSERT INTO `guild_apply`(applyid, guild_id, sender_id, sender_nickname, "
|
|
" sender_avatar_url, sender_sex, sender_data_version1, "
|
|
" createtime, sender_user_value1, sender_user_value2, sender_user_value3, status)"
|
|
"VALUES(%d, '%s', '%s', '%s', '%s', %d, %d, %d, %d, %d, %d, 0);",
|
|
{
|
|
App::Instance()->NewUUID(),
|
|
guild->GuildId(),
|
|
user_info.base_data().account_id(),
|
|
user_info.base_data().nickname(),
|
|
user_info.base_data().avatar_url(),
|
|
user_info.base_data().sex(),
|
|
user_info.base_data().base_data_version(),
|
|
App::Instance()->nowtime,
|
|
user_info.base_data().user_value1(),
|
|
user_info.base_data().user_value2(),
|
|
user_info.base_data().user_value3()
|
|
},
|
|
a8::XParams()
|
|
.SetSender(guild->GuildId()),
|
|
on_ok,
|
|
on_error,
|
|
guild->GuildId()
|
|
);
|
|
}
|
|
|
|
void DBHelper::AddEvent(const std::string& sender_id,
|
|
const std::string& target_id,
|
|
const std::string& event_name,
|
|
const std::string& event_data,
|
|
const std::string& param1,
|
|
const std::string& param2,
|
|
const std::string& param3
|
|
)
|
|
{
|
|
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)
|
|
{
|
|
|
|
};
|
|
|
|
long long crc32_code = a8::openssl::Crc32(
|
|
(unsigned char*)target_id.data(),
|
|
target_id.size()
|
|
);
|
|
a8::XObject conn_info = DBEngine::Instance()->GetConnInfo(crc32_code);
|
|
DBEngine::Instance()->ExecAsyncScript
|
|
(
|
|
conn_info,
|
|
"INSERT INTO `event`(sender_id, target_id, event_name, "
|
|
" param1, param2, param3, event_data, status, createtime)"
|
|
"VALUES('%s', '%s', '%s', '', '', '', '%s', 0, %d);",
|
|
{
|
|
sender_id,
|
|
target_id,
|
|
event_name,
|
|
event_data,
|
|
App::Instance()->nowtime
|
|
},
|
|
a8::XParams(),
|
|
on_ok,
|
|
on_error,
|
|
crc32_code
|
|
);
|
|
}
|
|
|
|
void DBHelper::SetEventStatus(long long idx,
|
|
const std::string& target_id,
|
|
int status)
|
|
{
|
|
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)
|
|
{
|
|
|
|
};
|
|
|
|
long long crc32_code = a8::openssl::Crc32(
|
|
(unsigned char*)target_id.data(),
|
|
target_id.size()
|
|
);
|
|
a8::XObject conn_info = DBEngine::Instance()->GetConnInfo(crc32_code);
|
|
DBEngine::Instance()->ExecAsyncScript
|
|
(
|
|
conn_info,
|
|
"UPDATE `event` SET status=%d WHERE idx=%d;",
|
|
{
|
|
status,
|
|
idx
|
|
},
|
|
a8::XParams(),
|
|
on_ok,
|
|
on_error,
|
|
crc32_code
|
|
);
|
|
}
|
|
|
|
void DBHelper::ShuaOfflineUsers(Player* hum)
|
|
{
|
|
++shua_users_offline_times;
|
|
std::set<std::string>& exclude_account_ids = hum->GetExcludeAccountIds();
|
|
if (cache_users_hash.size() < 500 && !exclude_account_ids.empty()) {
|
|
std::string fmtstr = "SELECT '' AS account_id";
|
|
std::vector<a8::XValue> sql_params;
|
|
for (auto& account_id : exclude_account_ids) {
|
|
fmtstr += " UNION SELECT '%s'";
|
|
sql_params.push_back(a8::XValue(account_id));
|
|
}
|
|
if (f8::IsOnlineEnv()) {
|
|
sql_params.push_back(10000 + (rand() % 5000));
|
|
} else {
|
|
sql_params.push_back(10000 + (rand() % 50));
|
|
}
|
|
auto on_ok =
|
|
[] (a8::XParams& param, const f8::DataSet* data_set)
|
|
{
|
|
if (data_set) {
|
|
for (auto& row : *data_set) {
|
|
DBHelper::Instance()->AddCache
|
|
(
|
|
row[1], //account_id
|
|
row[2], //nickname
|
|
row[3], //avatar_url
|
|
a8::XValue(row[4]), //sex
|
|
a8::XValue(row[5]), //data_version1
|
|
a8::XValue(row[6]), //user_value1
|
|
a8::XValue(row[7]), //user_value2
|
|
a8::XValue(row[8]), //user_value3
|
|
a8::XValue(row[9]) //last_logintime
|
|
);
|
|
}
|
|
}
|
|
};
|
|
auto on_error =
|
|
[] (a8::XParams& param, int error_code, const std::string& error_msg)
|
|
{
|
|
|
|
};
|
|
|
|
a8::XObject conn_info = DBEngine::Instance()->GetConnInfo(hum->myself.crc32_code);
|
|
DBEngine::Instance()->ExecAsyncQuery
|
|
(
|
|
conn_info,
|
|
(
|
|
"SELECT A.idx, A.account_id, A.nickname, A.avatar_url, A.sex, A.data_version1, A.user_value1, "
|
|
" A.user_value2, A.user_value3, A.last_logintime "
|
|
"FROM `user` A "
|
|
" LEFT JOIN (" + fmtstr + ") AS B ON B.account_id = A.account_id "
|
|
"WHERE A.idx > %d AND "
|
|
" B.account_id IS NULL LIMIT 1, 10;"
|
|
).c_str(),
|
|
sql_params,
|
|
a8::XParams()
|
|
.SetSender(hum->AccountId()),
|
|
on_ok,
|
|
on_error,
|
|
hum->myself.crc32_code
|
|
);
|
|
}
|
|
}
|
|
|
|
void DBHelper::AddCache(
|
|
const std::string& account_id,
|
|
const std::string& nickname,
|
|
const std::string& avatar_url,
|
|
int sex,
|
|
long long data_version1,
|
|
long long user_value1,
|
|
long long user_value2,
|
|
long long user_value3,
|
|
int last_logintime
|
|
)
|
|
{
|
|
if (cache_users_hash.find(account_id) == cache_users_hash.end()) {
|
|
cs::MFUserInfo* user_info = new cs::MFUserInfo();
|
|
user_info->mutable_base_data()->set_account_id(account_id);
|
|
user_info->mutable_base_data()->set_nickname(nickname);
|
|
user_info->mutable_base_data()->set_avatar_url(avatar_url);
|
|
user_info->mutable_base_data()->set_sex(sex);
|
|
user_info->mutable_base_data()->set_base_data_version(data_version1);
|
|
user_info->mutable_base_data()->set_user_value1(user_value1);
|
|
user_info->mutable_base_data()->set_user_value2(user_value2);
|
|
user_info->mutable_base_data()->set_user_value3(user_value3);
|
|
user_info->mutable_base_data()->set_last_login_time(last_logintime);
|
|
user_info->mutable_base_data()->set__online(0);
|
|
cache_users_hash[account_id] = user_info;
|
|
cache_users_list.push_back(user_info);
|
|
a8::Timer::Instance()->AddDeadLineTimer
|
|
(
|
|
1000 * 60 * 5 + rand() % 1000,
|
|
a8::XParams()
|
|
.SetSender(account_id),
|
|
[] (const a8::XParams& param)
|
|
{
|
|
DBHelper::Instance()->RemoveCache(param.sender);
|
|
}
|
|
);
|
|
}
|
|
}
|
|
|
|
void DBHelper::RemoveCache(const std::string& account_id)
|
|
{
|
|
if (cache_users_hash.size() < 300) {
|
|
a8::Timer::Instance()->AddDeadLineTimer
|
|
(
|
|
1000 * 60 * 5 + rand() % 1000,
|
|
a8::XParams()
|
|
.SetSender(account_id),
|
|
[] (const a8::XParams& param)
|
|
{
|
|
DBHelper::Instance()->RemoveCache(param.sender);
|
|
}
|
|
);
|
|
return;
|
|
}
|
|
auto itr = cache_users_hash.find(account_id);
|
|
if (itr != cache_users_hash.end()) {
|
|
auto itr2 = std::find(cache_users_list.begin(),
|
|
cache_users_list.end(),
|
|
itr->second);
|
|
if (itr2 != cache_users_list.end()) {
|
|
cache_users_list.erase(itr2);
|
|
} else {
|
|
abort();
|
|
}
|
|
delete itr->second;
|
|
cache_users_hash.erase(itr);
|
|
}
|
|
}
|