/**
* 获取正式群列表
*
* @param pPdu 收到的packet包指针
* @param conn_uuid 该包过来的socket 描述符
*/
void getNormalGroupList(CImPdu* pPdu, uint32_t conn_uuid)
{
IM::Group::IMNormalGroupListReq msg;
IM::Group::IMNormalGroupListRsp msgResp;
if(msg.ParseFromArray(pPdu->GetBodyData(), pPdu->GetBodyLength()))
{
CImPdu* pPduRes = new CImPdu;
uint32_t nUserId = msg.user_id();
list<IM::BaseDefine::GroupVersionInfo> lsGroup;
CGroupModel::getInstance()->getUserGroup(nUserId, lsGroup, IM::BaseDefine::GROUP_TYPE_NORMAL);
msgResp.set_user_id(nUserId);
for(auto it=lsGroup.begin(); it!=lsGroup.end(); ++it)
{
IM::BaseDefine::GroupVersionInfo* pGroupVersion = msgResp.add_group_version_list();
pGroupVersion->set_group_id(it->group_id());
pGroupVersion->set_version(it->version());
}
log("getNormalGroupList. userId=%u, count=%d", nUserId, msgResp.group_version_list_size());
msgResp.set_attach_data(msg.attach_data());
pPduRes->SetPBMsg(&msgResp);
pPduRes->SetSeqNum(pPdu->GetSeqNum());
pPduRes->SetServiceId(IM::BaseDefine::SID_GROUP);
pPduRes->SetCommandId(IM::BaseDefine::CID_GROUP_NORMAL_LIST_RESPONSE);
CProxyConn::AddResponsePdu(conn_uuid, pPduRes);
}
else
{
log("parse pb failed");
}
}
std::string LLUrlEntryGroup::getLabel(const std::string &url, const LLUrlLabelCallback &cb)
{
if (!gCacheName)
{
// probably at login screen, give something short for layout
return LLTrans::getString("LoadingData");
}
std::string group_id_string = getIDStringFromUrl(url);
if (group_id_string.empty())
{
// something went wrong, give raw url
return unescapeUrl(url);
}
LLUUID group_id(group_id_string);
std::string group_name;
if (group_id.isNull())
{
return LLTrans::getString("GroupNameNone");
}
else if (gCacheName->getGroupName(group_id, group_name))
{
return group_name;
}
else
{
gCacheName->getGroup(group_id,
boost::bind(&LLUrlEntryGroup::onGroupNameReceived,
this, _1, _2, _3));
addObserver(group_id_string, url, cb);
return LLTrans::getString("LoadingData");
}
}
/// 连接回调
void tcp_connector::async_connect_handler( boost::system::error_code const& ec
, socket_ptr pSock, FactoryFunc fact_func, ConnectHandler const& handler
, options_ptr opts, tcp::resolver::iterator resolver_it )
{
tcp_session_ptr ptr;
boost::system::error_code remote_ec, local_ec;
if (!ec && pSock->remote_endpoint(remote_ec) != pSock->local_endpoint(local_ec)
&& !remote_ec && !local_ec)
ptr = fact_func(pSock, session_initialized(session_id(), group_id(), opts));
else if (tcp::resolver::iterator() != resolver_it)
{
boost::system::error_code close_ec;
pSock->close(close_ec);
if (close_ec)
pSock.reset(new socket(m_ios));
tcp::endpoint endpoint = *resolver_it++;
pSock->async_connect(endpoint
, boost::bind(&tcp_connector::async_connect_handler, this, placeholders::error
, pSock, fact_func, handler, opts, resolver_it ));
return ;
}
handler(ptr, ec);
}
/* virtual */ void
av::gua::NetTransform::_setStateFragment(const std::string& fragment, Msg& stateMsg)
{
// created a new fpFragmentGroup node and register with the correct well-known id.
// it consists of the endpoint-id of the server and a constant number.
EIDGrpMap::iterator found = mGroupMap.find(fragment);
if (found == mGroupMap.end())
{
NetID group_id(fragment, NetID::sNetGroupRootNode);
registerWellKnown(this, group_id);
mGroupMap.insert(fragment);
}
// send an update message for the well-known shared container node of this fragment
SharedContainerMap::iterator container_iter = mSharedContainerMap.find(fragment);
if (container_iter == mSharedContainerMap.end())
{
Link<SharedContainerHolder> container_holder = new SharedContainerHolder;
NetID container_holder_id(fragment, NetID::sNetGroupContainerHolder);
registerWellKnown(container_holder.getPtr(), container_holder_id);
mSharedContainerMap[fragment] = container_holder;
sharedContainersChanged();
}
// consume the state message
consumeMessage(stateMsg);
// consume the shared container message
consumeMessage(stateMsg);
}
tcp_session_ptr tcp_connector::connect( FactoryFunc fact_func, int port,
std::string const& hostname, boost::system::error_code & ec, options_ptr opts)
{
address addr = address::from_string(hostname, ec);
if (ec)
{
// hostname不是IP地址, 尝试当作域名解析
ec.clear();
tcp::resolver::query query(hostname, lexical_cast_def<std::string>(port));
tcp::resolver rsl(m_ios);
tcp::resolver::iterator resolver_it = rsl.resolve(query, ec);
if (ec)
return tcp_session_ptr();
ec = error::host_not_found;
socket_ptr pSock(new socket(m_ios));
while (ec && tcp::resolver::iterator() != resolver_it)
{
tcp::endpoint endpoint = *resolver_it++;
std::cout << endpoint << std::endl;
boost::system::error_code close_ec;
pSock->close(close_ec);
if (close_ec)
pSock.reset(new socket(m_ios));
pSock->connect(endpoint, ec);
}
boost::system::error_code remote_ec, local_ec;
if (!ec && pSock->remote_endpoint(remote_ec) != pSock->local_endpoint(local_ec)
&& !remote_ec && !local_ec)
return fact_func(pSock, session_initialized(session_id(), group_id(), opts));
else
return tcp_session_ptr();
}
// hostname是IP地址
tcp::endpoint endpoint(addr, port);
socket_ptr pSock(new socket(m_ios));
pSock->connect(endpoint, ec);
boost::system::error_code remote_ec, local_ec;
if (!ec && pSock->remote_endpoint(remote_ec) != pSock->local_endpoint(local_ec)
&& !remote_ec && !local_ec)
return fact_func(pSock, session_initialized(session_id(), group_id(), opts));
else
return tcp_session_ptr();
}
int
main( int argc, char ** argv )
{
set_token();
sstring * output_dir = construct_string(2048);
sstring * output_file = construct_string(2048);
long long * ids;
int retvalue = 0;
grp.name_scrn = construct_string(2048);
extern CURL * curl;
curl = curl_easy_init();
int grp_check_value = group_id( argc, argv );
if ( grp_check_value == 0 )
{
retvalue = 0;
goto main_end_mark;
}
else if ( grp_check_value < 0 )
{
retvalue = -1;
goto main_end_mark;
}
ids = malloc( sizeof(long long) * grp.sub_count );
if ( group_memb(ids) < 0 )
{
retvalue = -2;
goto main_end_mark;
}
stringset( output_dir, "c_%s", grp.name_scrn->c );
if ( mkdir( output_dir->c, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH ) != 0 )
if ( errno != EEXIST )
{
fprintf( stderr, "mkdir() error (%d).\n", errno );
retvalue = -3;
goto main_end_mark;
}
long long i = grp.sub_count - 1;
for ( ; i != 0 ; --i )
{
printf( "\n[%7lld/%7lld] ", i + 1, grp.sub_count );
stringset( output_file, "%s/u_%lld", output_dir->c, ids[i] );
user_subs( ids[i], output_file );
}
main_end_mark:
free_string(output_dir);
free_string(output_file);
curl_easy_cleanup(curl);
return retvalue;
}
/**
* 获取群信息
*
* @param pPdu 收到的packet包指针
* @param conn_uuid 该包过来的socket 描述符
*/
void getGroupInfo(CImPdu* pPdu, uint32_t conn_uuid)
{
IM::Group::IMGroupInfoListReq msg;
IM::Group::IMGroupInfoListRsp msgResp;
if(msg.ParseFromArray(pPdu->GetBodyData(), pPdu->GetBodyLength()))
{
CImPdu* pPduRes = new CImPdu;
uint32_t nUserId = msg.user_id();
uint32_t nGroupCnt = msg.group_version_list_size();
map<uint32_t, IM::BaseDefine::GroupVersionInfo> mapGroupId;
for(uint32_t i=0; i<nGroupCnt; ++i)
{
IM::BaseDefine::GroupVersionInfo groupInfo = msg.group_version_list(i);
if(CGroupModel::getInstance()->isValidateGroupId(groupInfo.group_id()))
{
mapGroupId[groupInfo.group_id()] = groupInfo;
}
}
list<IM::BaseDefine::GroupInfo> lsGroupInfo;
CGroupModel::getInstance()->getGroupInfo(mapGroupId, lsGroupInfo);
msgResp.set_user_id(nUserId);
for(auto it=lsGroupInfo.begin(); it!=lsGroupInfo.end(); ++it)
{
IM::BaseDefine::GroupInfo* pGroupInfo = msgResp.add_group_info_list();
// *pGroupInfo = *it;
pGroupInfo->set_group_id(it->group_id());
pGroupInfo->set_version(it->version());
pGroupInfo->set_group_name(it->group_name());
pGroupInfo->set_group_avatar(it->group_avatar());
pGroupInfo->set_group_creator_id(it->group_creator_id());
pGroupInfo->set_group_type(it->group_type());
pGroupInfo->set_shield_status(it->shield_status());
uint32_t nGroupMemberCnt = it->group_member_list_size();
for (uint32_t i=0; i<nGroupMemberCnt; ++i)
{
uint32_t userId = it->group_member_list(i);
pGroupInfo->add_group_member_list(userId);
}
}
log("userId=%u, requestCount=%u", nUserId, nGroupCnt);
msgResp.set_attach_data(msg.attach_data());
pPduRes->SetPBMsg(&msgResp);
pPduRes->SetSeqNum(pPdu->GetSeqNum());
pPduRes->SetServiceId(IM::BaseDefine::SID_GROUP);
pPduRes->SetCommandId(IM::BaseDefine::CID_GROUP_INFO_RESPONSE);
CProxyConn::AddResponsePdu(conn_uuid, pPduRes);
}
else
{
log("parse pb failed");
}
}
void test_group( int *passed, int *failed )
{
group *g = group_create( 2, 1, test_name );
if ( g != NULL )
{
group_set_parent( g, 7 );
if ( group_parent(g)==7&&group_id(g)==2&&group_datasize(g,"utf-8")==10 )
(*passed)++;
else
{
fprintf(stderr, "group: id=%d parent=%d datasize=%d\n",
group_id(g),group_parent(g),group_datasize(g,"utf-8"));
(*failed)++;
}
group_dispose( g );
}
else
{
fprintf(stderr,"group: failed to allocate object\n");
(*failed)++;
}
}
/**
* 获取一个群的推送设置
*
* @param pPdu 收到的packet包指针
* @param conn_uuid 该包过来的socket 描述符
*/
void getGroupPush(CImPdu* pPdu, uint32_t conn_uuid)
{
IM::Server::IMGroupGetShieldReq msg;
IM::Server::IMGroupGetShieldRsp msgResp;
if(msg.ParseFromArray(pPdu->GetBodyData(), pPdu->GetBodyLength()))
{
uint32_t nGroupId = msg.group_id();
uint32_t nUserCnt = msg.user_id_size();
if(CGroupModel::getInstance()->isValidateGroupId(nGroupId))
{
CImPdu* pPduRes = new CImPdu;
list<uint32_t> lsUser;
for(uint32_t i=0; i<nUserCnt; ++i)
{
lsUser.push_back(msg.user_id(i));
}
list<IM::BaseDefine::ShieldStatus> lsPush;
CGroupModel::getInstance()->getPush(nGroupId, lsUser, lsPush);
msgResp.set_group_id(nGroupId);
for (auto it=lsPush.begin(); it!=lsPush.end(); ++it) {
IM::BaseDefine::ShieldStatus* pStatus = msgResp.add_shield_status_list();
// *pStatus = *it;
pStatus->set_user_id(it->user_id());
pStatus->set_group_id(it->group_id());
pStatus->set_shield_status(it->shield_status());
}
log("groupId=%u, count=%u", nGroupId, nUserCnt);
msgResp.set_attach_data(msg.attach_data());
pPduRes->SetPBMsg(&msgResp);
pPduRes->SetSeqNum(pPdu->GetSeqNum());
pPduRes->SetServiceId(IM::BaseDefine::SID_OTHER);
pPduRes->SetCommandId(IM::BaseDefine::CID_OTHER_GET_SHIELD_RSP);
CProxyConn::AddResponsePdu(conn_uuid, pPduRes);
}
else
{
log("Invalid groupId. nGroupId=%u", nGroupId);
}
}
else
{
log("parse pb failed");
}
}
/* virtual */ void
av::gua::NetTransform::_getStateFragment(const std::string& fragment, Msg& stateMsg)
{
// send an update message for the well-known group node of this fragment
EIDGrpMap::iterator i = mGroupMap.find(fragment);
if (i != mGroupMap.end())
{
NetID group_id(fragment, NetID::sNetGroupRootNode);
registerWellKnown(this, group_id);
mGroupMap.insert(fragment);
}
stateMsg.setType(Msg::absolute);
makeUpdateMessage(stateMsg, this);
Link<SharedContainerHolder> container_holder;
// send an update message for the well-known shared container node of this fragment
SharedContainerMap::iterator container_iter = mSharedContainerMap.find(fragment);
if (container_iter != mSharedContainerMap.end())
{
container_holder = (*container_iter).second;
}
else
{
// a new node is needed
container_holder = new SharedContainerHolder;
container_holder->Name.setValue(fragment);
NetID container_holder_id(fragment, NetID::sNetGroupContainerHolder);
registerWellKnown(container_holder.getPtr(), container_holder_id);
mSharedContainerMap[fragment] = container_holder;
container_holder->registerNetTransform(this);
sharedContainersChanged();
}
stateMsg.setType(Msg::absolute);
makeUpdateMessage(stateMsg, container_holder.getPtr());
}
void MethodSendGrpChatMsg::onCall(const sg::rpc::Uri& target)
{
common::UserPointID sender_ptid(getFrom());
common::GroupID group_id(target);
uint32_t msg_time = ::time(NULL);
common::msg_id_t msg_id =
GroupMessagingService::instance()->getGroupsManager().createGroup(
target)->sendChatMessage(sender_ptid,
msg_time,
getRequestData().content_type(),
getRequestData().content());
rpc::SendGrpChatMsgResponse resp;
resp.set_msg_id(msg_id);
resp.set_msg_time(msg_time);
reply(target, resp);
}
/* virtual */ void
av::gua::NetTransform::_join(const std::string& fragment)
{
NetID group_id(fragment, NetID::sNetGroupRootNode);
registerWellKnown(this, group_id);
mGroupMap.insert(fragment);
// register SharedContainerHolder
Link<SharedContainerHolder> container_holder = new SharedContainerHolder;
NetID container_holder_id(fragment, NetID::sNetGroupContainerHolder);
registerWellKnown(container_holder.getPtr(), container_holder_id);
mSharedContainerMap[fragment] = container_holder;
sharedContainersChanged();
#ifdef AVANGO_DEBUG
AVANGO_LOG(logger, logging::TRACE, boost::str(boost::format("_join: added group node %1% for: %2%]") % group_id % fragment));
#endif
}
void LLInventoryItem::unpackBinaryBucket(U8* bin_bucket, S32 bin_bucket_size)
{
// Early exit on an empty binary bucket.
if (bin_bucket_size <= 1) return;
// Convert the bin_bucket into a string.
char* item_buffer = new char[bin_bucket_size+1];
if ((item_buffer != NULL) && (bin_bucket != NULL))
{
memcpy(item_buffer, bin_bucket, bin_bucket_size); /* Flawfinder: ignore */
}
else
{
llerrs << "unpackBinaryBucket failed. item_buffer or bin_bucket is Null." << llendl;
delete[] item_buffer;
return;
}
item_buffer[bin_bucket_size] = '\0';
std::string str(item_buffer);
lldebugs << "item buffer: " << item_buffer << llendl;
delete[] item_buffer;
// Tokenize the string.
typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
boost::char_separator<char> sep("|", "", boost::keep_empty_tokens);
tokenizer tokens(str, sep);
tokenizer::iterator iter = tokens.begin();
// Extract all values.
LLUUID item_id;
item_id.generate();
setUUID(item_id);
LLAssetType::EType type;
type = (LLAssetType::EType)(atoi((*(iter++)).c_str()));
setType( type );
LLInventoryType::EType inv_type;
inv_type = (LLInventoryType::EType)(atoi((*(iter++)).c_str()));
setInventoryType( inv_type );
std::string name((*(iter++)).c_str());
rename( name );
LLUUID creator_id((*(iter++)).c_str());
LLUUID owner_id((*(iter++)).c_str());
LLUUID last_owner_id((*(iter++)).c_str());
LLUUID group_id((*(iter++)).c_str());
PermissionMask mask_base = strtoul((*(iter++)).c_str(), NULL, 16);
PermissionMask mask_owner = strtoul((*(iter++)).c_str(), NULL, 16);
PermissionMask mask_group = strtoul((*(iter++)).c_str(), NULL, 16);
PermissionMask mask_every = strtoul((*(iter++)).c_str(), NULL, 16);
PermissionMask mask_next = strtoul((*(iter++)).c_str(), NULL, 16);
LLPermissions perm;
perm.init(creator_id, owner_id, last_owner_id, group_id);
perm.initMasks(mask_base, mask_owner, mask_group, mask_every, mask_next);
setPermissions(perm);
//lldebugs << "perm: " << perm << llendl;
LLUUID asset_id((*(iter++)).c_str());
setAssetUUID(asset_id);
std::string desc((*(iter++)).c_str());
setDescription(desc);
LLSaleInfo::EForSale sale_type;
sale_type = (LLSaleInfo::EForSale)(atoi((*(iter++)).c_str()));
S32 price = atoi((*(iter++)).c_str());
LLSaleInfo sale_info(sale_type, price);
setSaleInfo(sale_info);
U32 flags = strtoul((*(iter++)).c_str(), NULL, 16);
setFlags(flags);
time_t now = time(NULL);
setCreationDate(now);
}
void LLInventoryItem::unpackBinaryBucket(U8* bin_bucket, S32 bin_bucket_size)
{
// Early exit on an empty binary bucket.
if (bin_bucket_size <= 1) return;
if (NULL == bin_bucket)
{
LL_ERRS() << "unpackBinaryBucket failed. bin_bucket is NULL." << LL_ENDL;
return;
}
// Convert the bin_bucket into a string.
std::vector<char> item_buffer(bin_bucket_size+1);
memcpy(&item_buffer[0], bin_bucket, bin_bucket_size); /* Flawfinder: ignore */
item_buffer[bin_bucket_size] = '\0';
std::string str(&item_buffer[0]);
LL_DEBUGS() << "item buffer: " << str << LL_ENDL;
// Tokenize the string.
typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
boost::char_separator<char> sep("|", "", boost::keep_empty_tokens);
tokenizer tokens(str, sep);
tokenizer::iterator iter = tokens.begin();
// Extract all values.
LLUUID item_id;
item_id.generate();
setUUID(item_id);
LLAssetType::EType type;
type = static_cast<LLAssetType::EType>(std::stoi((*(iter++))));
setType( type );
LLInventoryType::EType inv_type;
inv_type = static_cast<LLInventoryType::EType>(std::stoi((*(iter++))));
setInventoryType( inv_type );
std::string name((*(iter++)).c_str());
rename( name );
LLUUID creator_id((*(iter++)).c_str());
LLUUID owner_id((*(iter++)).c_str());
LLUUID last_owner_id((*(iter++)).c_str());
LLUUID group_id((*(iter++)).c_str());
PermissionMask mask_base = strtoul((*(iter++)).c_str(), NULL, 16);
PermissionMask mask_owner = strtoul((*(iter++)).c_str(), NULL, 16);
PermissionMask mask_group = strtoul((*(iter++)).c_str(), NULL, 16);
PermissionMask mask_every = strtoul((*(iter++)).c_str(), NULL, 16);
PermissionMask mask_next = strtoul((*(iter++)).c_str(), NULL, 16);
LLPermissions perm;
perm.init(creator_id, owner_id, last_owner_id, group_id);
perm.initMasks(mask_base, mask_owner, mask_group, mask_every, mask_next);
setPermissions(perm);
//LL_DEBUGS() << "perm: " << perm << LL_ENDL;
LLUUID asset_id((*(iter++)).c_str());
setAssetUUID(asset_id);
std::string desc((*(iter++)).c_str());
setDescription(desc);
LLSaleInfo::EForSale sale_type;
sale_type = static_cast<LLSaleInfo::EForSale>(std::stoi((*(iter++))));
S32 price = std::stoi(*(iter++));
LLSaleInfo sale_info(sale_type, price);
setSaleInfo(sale_info);
U32 flags = strtoul((*(iter++)).c_str(), NULL, 16);
setFlags(flags);
time_t now = time(NULL);
setCreationDate(now);
}
void CassDriver::Retrieve(
std::tr1::function<void(bool success, Wrapper* data)> cob,
const std::string& receiver_id, Wrapper* data_wrapper) {
CassStatement* statement = cass_prepared_bind(select_prepared_);
cass_statement_bind_string(statement, 0,
cass_string_init(receiver_id.c_str()));
cass_statement_set_paging_size(statement, FLAGS_page_size);
CassFuture* future = cass_session_execute(session_, statement);
auto retrieve_cb = [](CassFuture* future, void* data) {
CassError rc = cass_future_error_code(future);
Wrapper* wrapper = (Wrapper*)data;
if (rc == CASS_OK) {
const CassResult* result = cass_future_get_result(future);
if (cass_result_row_count(result)) {
CassIterator* iterator = cass_iterator_from_result(result);
CassString cass_receiver, cass_time, cass_msg_id,
cass_group_id, cass_msg, cass_sender;
while (cass_iterator_next(iterator)) {
const CassRow* row = cass_iterator_get_row(iterator);
cass_value_get_string(cass_row_get_column(row, 0), &cass_receiver);
cass_value_get_string(cass_row_get_column(row, 1), &cass_time);
cass_value_get_string(cass_row_get_column(row, 2), &cass_msg_id);
cass_value_get_string(cass_row_get_column(row, 3), &cass_group_id);
cass_value_get_string(cass_row_get_column(row, 4), &cass_msg);
cass_value_get_string(cass_row_get_column(row, 5), &cass_sender);
std::string receiver(cass_receiver.data, cass_receiver.length);
std::string time(cass_time.data, cass_time.length);
std::string msg_id(cass_msg_id.data, cass_msg_id.length);
std::string group_id(cass_group_id.data, cass_group_id.length);
std::string msg(cass_msg.data, cass_msg.length);
std::string sender(cass_sender.data, cass_sender.length);
boost::shared_ptr<Message> message(new Message());
message->__set_receiver_id(receiver);
message->__set_timestamp(time);
message->__set_msg_id(msg_id);
message->__set_group_id(group_id);
message->__set_msg(msg);
message->__set_sender_id(sender);
wrapper->pmsgs->push_back(message);
}
cass_bool_t has_more_pages = cass_result_has_more_pages(result);
if (has_more_pages) {
cass_statement_set_paging_state(wrapper->statement, result);
(wrapper->func)();
} else {
cass_statement_free(wrapper->statement);
CassStatement* statement =
cass_prepared_bind(wrapper->this_obj->delete_prepared_);
cass_statement_bind_string(statement, 0, cass_receiver);
CassFuture* delete_future =
cass_session_execute(wrapper->this_obj->session_, statement);
cass_future_free(delete_future);
cass_statement_free(statement);
(wrapper->cob)(true, wrapper);
}
cass_iterator_free(iterator);
} else {
cass_statement_free(wrapper->statement);
(wrapper->cob)(true, wrapper);
}
cass_result_free(result);
} else {
cass_statement_free(wrapper->statement);
wrapper->this_obj->PrintError(future);
(wrapper->cob)(false, wrapper);
}
};
data_wrapper->this_obj = this;
data_wrapper->cob = cob;
data_wrapper->statement = statement;
data_wrapper->func = [=]() {
CassFuture* future = cass_session_execute(session_, statement);
cass_future_set_callback(future, retrieve_cb, data_wrapper);
cass_future_free(future);
};
cass_future_set_callback(future, retrieve_cb, data_wrapper);
cass_future_free(future);
}
void ForumHandler::handleWildcard(Request &req, Response &resp)
{
bool ok = true;
if(!req.mPath.empty())
{
std::string str = req.mPath.top();
req.mPath.pop();
if(str != "")
{
//assume we have a groupID
RsGxsGroupId grpId(str);
std::list<RsGxsGroupId> groupIds;
groupIds.push_back(grpId);
uint32_t token;
RsTokReqOptions opts;
opts.mReqType = GXS_REQUEST_TYPE_MSG_DATA;
mRsGxsForums->getTokenService()->requestMsgInfo(token, RS_TOKREQ_ANSTYPE_DATA, opts, groupIds);
time_t start = time(NULL);
while((mRsGxsForums->getTokenService()->requestStatus(token) != RsTokenService::GXS_REQUEST_V2_STATUS_COMPLETE)
&&(mRsGxsForums->getTokenService()->requestStatus(token) != RsTokenService::GXS_REQUEST_V2_STATUS_FAILED)
&&((time(NULL) < (start+10)))
)
{
#ifdef WINDOWS_SYS
Sleep(500);
#else
usleep(500*1000) ;
#endif
}
if(mRsGxsForums->getTokenService()->requestStatus(token) == RsTokenService::GXS_REQUEST_V2_STATUS_COMPLETE)
{
std::vector<RsGxsForumMsg> grps;
ok &= mRsGxsForums->getMsgData(token, grps);
for(std::vector<RsGxsForumMsg>::iterator vit = grps.begin(); vit != grps.end(); vit++)
{
RsGxsForumMsg& grp = *vit;
KeyValueReference<RsGxsGroupId> group_id("group_id", grp.mMeta.mGroupId);
resp.mDataStream.getStreamToMember()
<< group_id
<< makeKeyValueReference("name", grp.mMeta.mMsgName)
<< makeKeyValueReference("id", grp.mMeta.mMsgId)
<< makeKeyValueReference("parent_id", grp.mMeta.mParentId)
<< makeKeyValueReference("author_id", grp.mMeta.mAuthorId)
<< makeKeyValueReference("orig_msg_id", grp.mMeta.mOrigMsgId)
<< makeKeyValueReference("thread_id", grp.mMeta.mThreadId)
<< makeKeyValueReference("message", grp.mMsg);
}
}
else
{
ok = false;
}
}
}
else
{
// no more path element
RsTokReqOptions opts;
opts.mReqType = GXS_REQUEST_TYPE_GROUP_DATA;
uint32_t token;
mRsGxsForums->getTokenService()->requestGroupInfo(token, RS_TOKREQ_ANSTYPE_DATA, opts);
time_t start = time(NULL);
while((mRsGxsForums->getTokenService()->requestStatus(token) != RsTokenService::GXS_REQUEST_V2_STATUS_COMPLETE)
&&(mRsGxsForums->getTokenService()->requestStatus(token) != RsTokenService::GXS_REQUEST_V2_STATUS_FAILED)
&&((time(NULL) < (start+10)))
)
{
#ifdef WINDOWS_SYS
Sleep(500);
#else
usleep(500*1000) ;
#endif
}
if(mRsGxsForums->getTokenService()->requestStatus(token) == RsTokenService::GXS_REQUEST_V2_STATUS_COMPLETE)
{
std::vector<RsGxsForumGroup> grps;
ok &= mRsGxsForums->getGroupData(token, grps);
for(std::vector<RsGxsForumGroup>::iterator vit = grps.begin(); vit != grps.end(); vit++)
{
RsGxsForumGroup& grp = *vit;
KeyValueReference<RsGxsGroupId> id("id", grp.mMeta.mGroupId);
KeyValueReference<uint32_t> vis_msg("visible_msg_count", grp.mMeta.mVisibleMsgCount);
//KeyValueReference<RsPgpId> pgp_id("pgp_id",grp.mPgpId );
// not very happy about this, i think the flags should stay hidden in rsidentities
bool own = (grp.mMeta.mSubscribeFlags & GXS_SERV::GROUP_SUBSCRIBE_ADMIN);
bool pgp_linked = (grp.mMeta.mGroupFlags & RSGXSID_GROUPFLAG_REALID);
bool subscribed = IS_GROUP_SUBSCRIBED(grp.mMeta.mSubscribeFlags);
resp.mDataStream.getStreamToMember()
<< id
//<< pgp_id
<< makeKeyValueReference("name", grp.mMeta.mGroupName)
//<< makeKeyValueReference("last_post", grp.mMeta.mLastPost)
<< makeKeyValueReference("pop", grp.mMeta.mPop)
//<< makeKeyValueReference("publish_ts", grp.mMeta.mPublishTs)
<< vis_msg
<< makeKeyValueReference("group_status", grp.mMeta.mGroupStatus)
<< makeKeyValueReference("author_id", grp.mMeta.mAuthorId)
<< makeKeyValueReference("parent_grp_id", grp.mMeta.mParentGrpId)
<< makeKeyValueReference("description", grp.mDescription)
<< makeKeyValueReference("own", own)
<< makeKeyValueReference("subscribed", subscribed)
<< makeKeyValueReference("pgp_linked", pgp_linked);
}
}
else
{
ok = false;
}
}
if(ok)
{
resp.setOk();
}
else
{
resp.setFail();
}
}
