//* For RTConnTcp
void RTConnectionTcp::OnLogin(const char* pUserid, const char* pPass)
{
{
//check & auth
//std::string uid;
//m_rtHiredis.CmdGet(pPass, uid);
//if (uid.length()>0 && uid.compare(pUserid) == 0) {
//login ok send response
//} else {
//login failed
//}
}
std::string sid;
{
//store userid & pass
RTConnectionManager::ConnectionInfo* pci = new RTConnectionManager::ConnectionInfo();
if (pci) {
RTConnectionManager::Instance()->GenericSessionId(sid);
m_connectorId = RTConnectionManager::Instance()->ConnectorId();
pci->connId = sid;
pci->connAddr = RTConnectionManager::Instance()->ConnectorIp();
pci->connPort = RTConnectionManager::Instance()->ConnectorPort();
pci->userId = pUserid;
pci->pConn = this;
pci->connType = CONNECTIONTYPE::_ctcp;
pci->flag = 1;
std::string uid(pUserid);
LI("OnLogin Uid:%s\n", uid.c_str());
RTConnectionManager::Instance()->AddUser(CONNECTIONTYPE::_ctcp, uid, pci);
m_userId = pUserid;
} else {
LE("new ConnectionInfo error!!!\n");
std::string resp;
GenericResponse(SIGNALTYPE::reqlogin, MSGTYPE::meeting, 0, RTCommCode::_errconninfo, GetRTCommStatus(RTCommCode::_errconninfo), resp);
SendResponse(0, resp.c_str());
return;
}
}
{
// send response
std::string resp;
GenericResponse(SIGNALTYPE::reqlogin, MSGTYPE::meeting, 0, RTCommCode::_ok, GetRTCommStatus(RTCommCode::_ok), resp);
SendResponse(0, resp.c_str());
return;
}
}
void RTConnectionTcp::OnSndMsg(MSGTYPE mType, long long mseq, const char* pUserid, const char* pData, int dLen)
{
if (!pData) {
LE("%s invalid params\n", __FUNCTION__);
std::string resp;
GenericResponse(SIGNALTYPE::reqsndmsg, mType, mseq, RTCommCode::_invparams, GetRTCommStatus(RTCommCode::_invparams), resp);
SendResponse(0, resp.c_str());
return;
}
//no matter mType is meet or callcenter or p2p or others
//the following code should be same
//find an TrasnferSession By mtype
//transfer msg by TransferSession
TRANSFERMSG t_trmsg;
TRANSMSG t_msg;
t_msg._flag = 0;
t_msg._touser = "";
t_msg._connector = RTConnectionManager::Instance()->ConnectorId();
t_msg._content = pData;
t_trmsg._action = TRANSFERACTION::req;
t_trmsg._fmodule = TRANSFERMODULE::mconnector;
t_trmsg._type = TRANSFERTYPE::trans;
t_trmsg._trans_seq = GenericTransSeq();
t_trmsg._trans_seq_ack = 0;
t_trmsg._valid = 1;
t_trmsg._content = t_msg.ToJson();
const std::string s = t_trmsg.ToJson();
RTConnectionManager::ModuleInfo* pmi = RTConnectionManager::Instance()->findModuleInfo(pUserid, (TRANSFERMODULE)mType);
if (pmi && pmi->pModule) {
pmi->pModule->SendTransferData(s.c_str(), (int)s.length());
} else {
LE("pmi->pModule is NULL\n");
std::string resp;
GenericResponse(SIGNALTYPE::reqsndmsg, mType, mseq, RTCommCode::_errmoduinfo, GetRTCommStatus(RTCommCode::_errmoduinfo), resp);
SendResponse(0, resp.c_str());
return;
}
{
std::string resp;
GenericResponse(SIGNALTYPE::reqsndmsg, mType, mseq, RTCommCode::_ok, GetRTCommStatus(RTCommCode::_ok), resp);
SendResponse(0, resp.c_str());
return;
}
}
void RTConnectionTcp::OnGetMsg(MSGTYPE mType, long long mseq, const char* pUserid)
{
std::string resp;
GenericResponse(SIGNALTYPE::reqgetmsg, mType, mseq, RTCommCode::_ok, GetRTCommStatus(RTCommCode::_ok), resp);
SendResponse(0, resp.c_str());
return;
}
void RTConnectionTcp::OnLogout(const char* pUserid)
{
std::string uid(pUserid);
RTConnectionManager::Instance()->DelUser(CONNECTIONTYPE::_ctcp, uid);
m_userId = "";
std::string resp;
GenericResponse(SIGNALTYPE::reqlogout, MSGTYPE::meeting, 1, RTCommCode::_ok, GetRTCommStatus(RTCommCode::_ok), resp);
SendResponse(0, resp.c_str());
return;
}
void LRTGroupSession::OnLogin(pms::EServerCmd cmd, pms::EModuleType module, const std::string& msg)
{
LI("%s was called\n", __FUNCTION__);
pms::Login login;
if (!login.ParseFromString(msg)) {
LE("login.ParseFromString error\n");
}
m_userid = login.usr_from();
m_token = login.usr_token();
LI("Onlogin user:%s login\n", m_userid.c_str());
std::string sid;
{
//store userid & pass
LRTConnManager::ConnectionInfo* pci = new LRTConnManager::ConnectionInfo();
if (pci) {
GenericSessionId(sid);
pci->_connId = sid;
pci->_userId = m_userid;
pci->_token = m_token;
pci->_pConn = this;
pci->_connType = pms::EConnType::TTCP;
pci->_flag = 1;
LRTConnManager::Instance().AddUser(pms::EConnType::TTCP, m_userid, pci);
//LRTConnManager::Instance().ConnectionConnNotify(m_userId, m_token);
// send response
std::string resp;
GenericResponse(pms::EServerCmd::CLOGIN, module, 0, resp);
SendResponse(0, resp.c_str());
m_login = true;
return;
} else {
LE("new ConnectionInfo error userid:%s\n", m_userid.c_str());
std::string resp;
GenericResponse(pms::EServerCmd::CLOGIN, module, 101, resp);
SendResponse(0, resp.c_str());
m_login = false;
return;
}
}
}
void RTConnectionTcp::OnKeepAlive(const char *pUserid)
{
LI("RTConnectionTcp::OnKeepAlive pUserid:%s\n", pUserid);
RTTcp::UpdateTimer();
{
std::string resp;
GenericResponse(SIGNALTYPE::reqkeepalive, MSGTYPE::meeting, 2, RTCommCode::_ok, GetRTCommStatus(RTCommCode::_ok), resp);
SendResponse(0, resp.c_str());
return;
}
}
void LRTGroupSession::OnLogout(pms::EServerCmd cmd, pms::EModuleType module, const std::string& msg)
{
LI("%s was called\n", __FUNCTION__);
pms::Logout logout;
if (!logout.ParseFromString(msg)) {
LE("login.ParseFromString error\n");
}
assert(logout.usr_from().compare(m_userid)==0);
LI("OnLogout user:%s logout\n", m_userid.c_str());
assert(logout.usr_from().compare(m_userid)==0);
std::string token;
LRTConnManager::Instance().DelUser(pms::EConnType::TTCP, m_userid, token);
//LRTConnManager::Instance().ConnectionLostNotify(m_userid, m_token);
m_userid = "";
m_token = "";
std::string resp;
GenericResponse(pms::EServerCmd::CLOGOUT, module, 0, resp);
SendResponse(0, resp.c_str());
m_login = false;
return;
}
