mirror of
https://github.com/RetroShare/RetroShare.git
synced 2025-05-04 07:05:26 -04:00
540 lines
18 KiB
C++
540 lines
18 KiB
C++
/*******************************************************************************
|
|
* libresapi/api/ChannelsHandler.cpp *
|
|
* *
|
|
* LibResAPI: API for local socket server *
|
|
* *
|
|
* Copyright 2018 by Gioacchino Mazzurco <gio@eigenlab.org> *
|
|
* *
|
|
* This program is free software: you can redistribute it and/or modify *
|
|
* it under the terms of the GNU Affero General Public License as *
|
|
* published by the Free Software Foundation, either version 3 of the *
|
|
* License, or (at your option) any later version. *
|
|
* *
|
|
* This program is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU Affero General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU Affero General Public License *
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>. *
|
|
* *
|
|
*******************************************************************************/
|
|
|
|
#include "ChannelsHandler.h"
|
|
|
|
#include <retroshare/rsgxschannels.h>
|
|
#include <util/radix64.h>
|
|
#include <util/rstime.h>
|
|
#include <algorithm>
|
|
#include <time.h>
|
|
|
|
#include "Operators.h"
|
|
|
|
namespace resource_api
|
|
{
|
|
|
|
StreamBase& operator << (StreamBase& left, RsGxsFile& file)
|
|
{
|
|
left << makeKeyValueReference("name", file.mName)
|
|
<< makeKeyValueReference("hash", file.mHash);
|
|
if(left.serialise())
|
|
{
|
|
double size = file.mSize;
|
|
left << makeKeyValueReference("size", size);
|
|
}
|
|
else
|
|
{
|
|
double size = 0;
|
|
left << makeKeyValueReference("size", size);
|
|
file.mSize = size;
|
|
}
|
|
return left;
|
|
}
|
|
|
|
ChannelsHandler::ChannelsHandler(RsGxsChannels& channels): mChannels(channels)
|
|
{
|
|
addResourceHandler("list_channels", this,
|
|
&ChannelsHandler::handleListChannels);
|
|
addResourceHandler("get_channel_info", this, &ChannelsHandler::handleGetChannelInfo);
|
|
addResourceHandler("get_channel_content", this, &ChannelsHandler::handleGetChannelContent);
|
|
addResourceHandler("toggle_subscribe", this, &ChannelsHandler::handleToggleSubscription);
|
|
addResourceHandler("toggle_auto_download", this, &ChannelsHandler::handleToggleAutoDownload);
|
|
addResourceHandler("toggle_read", this, &ChannelsHandler::handleTogglePostRead);
|
|
addResourceHandler("create_channel", this, &ChannelsHandler::handleCreateChannel);
|
|
addResourceHandler("create_post", this, &ChannelsHandler::handleCreatePost);
|
|
}
|
|
|
|
void ChannelsHandler::handleListChannels(Request& /*req*/, Response& resp)
|
|
{
|
|
RsTokReqOptions opts;
|
|
opts.mReqType = GXS_REQUEST_TYPE_GROUP_META;
|
|
uint32_t token;
|
|
|
|
RsTokenService& tChannels = *mChannels.getTokenService();
|
|
|
|
tChannels.requestGroupInfo(token, RS_DEPRECATED_TOKREQ_ANSTYPE, opts);
|
|
|
|
time_t start = time(NULL);
|
|
while((tChannels.requestStatus(token) != RsTokenService::GXS_REQUEST_V2_STATUS_COMPLETE)
|
|
&&(tChannels.requestStatus(token) != RsTokenService::GXS_REQUEST_V2_STATUS_FAILED)
|
|
&&((time(NULL) < (start+10)))) rstime::rs_usleep(500*1000);
|
|
|
|
std::list<RsGroupMetaData> grps;
|
|
if( tChannels.requestStatus(token) == RsTokenService::GXS_REQUEST_V2_STATUS_COMPLETE
|
|
&& mChannels.getGroupSummary(token, grps) )
|
|
{
|
|
for( RsGroupMetaData& grp : grps )
|
|
{
|
|
KeyValueReference<RsGxsGroupId> id("channel_id", grp.mGroupId);
|
|
KeyValueReference<uint32_t> vis_msg("visible_msg_count", grp.mVisibleMsgCount);
|
|
bool own = (grp.mSubscribeFlags & GXS_SERV::GROUP_SUBSCRIBE_ADMIN);
|
|
bool subscribed = IS_GROUP_SUBSCRIBED(grp.mSubscribeFlags);
|
|
std::string lastPostTsStr = std::to_string(grp.mLastPost);
|
|
std::string publishTsStr = std::to_string(grp.mPublishTs);
|
|
resp.mDataStream.getStreamToMember()
|
|
<< id
|
|
<< makeKeyValueReference("name", grp.mGroupName)
|
|
<< makeKeyValueReference("last_post_ts", lastPostTsStr)
|
|
<< makeKeyValueReference("popularity", grp.mPop)
|
|
<< makeKeyValueReference("publish_ts", publishTsStr)
|
|
<< vis_msg
|
|
<< makeKeyValueReference("group_status", grp.mGroupStatus)
|
|
<< makeKeyValueReference("author_id", grp.mAuthorId)
|
|
<< makeKeyValueReference("parent_grp_id", grp.mParentGrpId)
|
|
<< makeKeyValueReference("own", own)
|
|
<< makeKeyValueReference("subscribed", subscribed);
|
|
}
|
|
|
|
resp.setOk();
|
|
}
|
|
else resp.setFail("Cant get data from GXS!");
|
|
}
|
|
|
|
void ChannelsHandler::handleGetChannelInfo(Request& req, Response& resp)
|
|
{
|
|
std::string chanIdStr;
|
|
req.mStream << makeKeyValueReference("channel_id", chanIdStr);
|
|
if(chanIdStr.empty())
|
|
{
|
|
resp.setFail("channel_id required!");
|
|
return;
|
|
}
|
|
|
|
RsGxsGroupId chanId(chanIdStr);
|
|
if(chanId.isNull())
|
|
{
|
|
resp.setFail("Invalid channel_id:" + chanIdStr);
|
|
return;
|
|
}
|
|
|
|
bool wantThumbnail = true;
|
|
req.mStream << makeKeyValueReference("want_thumbnail", wantThumbnail);
|
|
|
|
std::list<RsGxsGroupId> groupIds; groupIds.push_back(chanId);
|
|
RsTokReqOptions opts;
|
|
opts.mReqType = GXS_REQUEST_TYPE_GROUP_DATA;
|
|
uint32_t token;
|
|
|
|
RsTokenService& tChannels = *mChannels.getTokenService();
|
|
tChannels.requestGroupInfo( token, RS_DEPRECATED_TOKREQ_ANSTYPE,
|
|
opts, groupIds );
|
|
|
|
time_t start = time(NULL);
|
|
while((tChannels.requestStatus(token) != RsTokenService::GXS_REQUEST_V2_STATUS_COMPLETE)
|
|
&&(tChannels.requestStatus(token) != RsTokenService::GXS_REQUEST_V2_STATUS_FAILED)
|
|
&&((time(NULL) < (start+10)))) rstime::rs_usleep(500*1000);
|
|
|
|
std::vector<RsGxsChannelGroup> grps;
|
|
if( tChannels.requestStatus(token) == RsTokenService::GXS_REQUEST_V2_STATUS_COMPLETE
|
|
&& mChannels.getGroupData(token, grps) )
|
|
{
|
|
for( RsGxsChannelGroup& grp : grps )
|
|
{
|
|
KeyValueReference<RsGxsGroupId> id("channel_id", grp.mMeta.mGroupId);
|
|
KeyValueReference<uint32_t> vis_msg("visible_msg_count", grp.mMeta.mVisibleMsgCount);
|
|
bool own = (grp.mMeta.mSubscribeFlags & GXS_SERV::GROUP_SUBSCRIBE_ADMIN);
|
|
bool subscribed = IS_GROUP_SUBSCRIBED(grp.mMeta.mSubscribeFlags);
|
|
std::string lastPostTsStr = std::to_string(grp.mMeta.mLastPost);
|
|
std::string publishTsStr = std::to_string(grp.mMeta.mPublishTs);
|
|
StreamBase& rgrp(resp.mDataStream.getStreamToMember());
|
|
rgrp << id
|
|
<< makeKeyValueReference("name", grp.mMeta.mGroupName)
|
|
<< makeKeyValueReference("last_post_ts", lastPostTsStr)
|
|
<< makeKeyValueReference("popularity", grp.mMeta.mPop)
|
|
<< makeKeyValueReference("publish_ts", publishTsStr)
|
|
<< 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("auto_download", grp.mAutoDownload);
|
|
|
|
if(wantThumbnail)
|
|
{
|
|
std::string thumbnail_base64;
|
|
Radix64::encode(grp.mImage.mData, grp.mImage.mSize, thumbnail_base64);
|
|
rgrp << makeKeyValueReference("thumbnail_base64_png", thumbnail_base64);
|
|
}
|
|
}
|
|
|
|
resp.setOk();
|
|
}
|
|
else resp.setFail("Cant get data from GXS!");
|
|
}
|
|
|
|
void ChannelsHandler::handleGetChannelContent(Request& req, Response& resp)
|
|
{
|
|
std::string chanIdStr;
|
|
req.mStream << makeKeyValueReference("channel_id", chanIdStr);
|
|
if(chanIdStr.empty())
|
|
{
|
|
resp.setFail("channel_id required!");
|
|
return;
|
|
}
|
|
|
|
RsGxsGroupId chanId(chanIdStr);
|
|
if(chanId.isNull())
|
|
{
|
|
resp.setFail("Invalid channel_id:" + chanIdStr);
|
|
return;
|
|
}
|
|
|
|
std::list<RsGxsGroupId> groupIds; groupIds.push_back(chanId);
|
|
uint32_t token;
|
|
RsTokReqOptions opts;
|
|
opts.mReqType = GXS_REQUEST_TYPE_MSG_DATA;
|
|
|
|
if(! mChannels.getTokenService()->
|
|
requestMsgInfo(token, RS_TOKREQ_ANSTYPE_DATA, opts, groupIds) )
|
|
{
|
|
resp.setFail("Unknown GXS error!");
|
|
return;
|
|
}
|
|
|
|
time_t start = time(NULL);
|
|
while((mChannels.getTokenService()->requestStatus(token) != RsTokenService::GXS_REQUEST_V2_STATUS_COMPLETE)
|
|
&&(mChannels.getTokenService()->requestStatus(token) != RsTokenService::GXS_REQUEST_V2_STATUS_FAILED)
|
|
&&((time(NULL) < (start+10)))) rstime::rs_usleep(500*1000);
|
|
|
|
std::vector<RsGxsChannelPost> posts;
|
|
std::vector<RsGxsComment> comments;
|
|
if( mChannels.getTokenService()->requestStatus(token) ==
|
|
RsTokenService::GXS_REQUEST_V2_STATUS_COMPLETE &&
|
|
mChannels.getPostData(token, posts, comments) )
|
|
{
|
|
for( std::vector<RsGxsChannelPost>::iterator vit = posts.begin();
|
|
vit != posts.end(); ++vit )
|
|
{
|
|
RsGxsChannelPost& post = *vit;
|
|
RsMsgMetaData& pMeta = post.mMeta;
|
|
resp.mDataStream.getStreamToMember()
|
|
<< makeKeyValueReference("channel_id", pMeta.mGroupId)
|
|
<< makeKeyValueReference("name", pMeta.mMsgName)
|
|
<< makeKeyValueReference("post_id", pMeta.mMsgId)
|
|
<< makeKeyValueReference("parent_id", pMeta.mParentId)
|
|
<< makeKeyValueReference("author_id", pMeta.mAuthorId)
|
|
<< makeKeyValueReference("orig_msg_id", pMeta.mOrigMsgId)
|
|
<< makeKeyValueReference("thread_id", pMeta.mThreadId)
|
|
<< makeKeyValueReference("message", post.mMsg);
|
|
}
|
|
|
|
for( std::vector<RsGxsComment>::iterator vit = comments.begin();
|
|
vit != comments.end(); ++vit )
|
|
{
|
|
RsGxsComment& comment = *vit;
|
|
RsMsgMetaData& cMeta = comment.mMeta;
|
|
std::string scoreStr = std::to_string(comment.mScore);
|
|
resp.mDataStream.getStreamToMember()
|
|
<< makeKeyValueReference("channel_id", cMeta.mGroupId)
|
|
<< makeKeyValueReference("name", cMeta.mMsgName)
|
|
<< makeKeyValueReference("comment_id", cMeta.mMsgId)
|
|
<< makeKeyValueReference("parent_id", cMeta.mParentId)
|
|
<< makeKeyValueReference("author_id", cMeta.mAuthorId)
|
|
<< makeKeyValueReference("orig_msg_id", cMeta.mOrigMsgId)
|
|
<< makeKeyValueReference("thread_id", cMeta.mThreadId)
|
|
<< makeKeyValueReference("score", scoreStr)
|
|
<< makeKeyValueReference("message", comment.mComment);
|
|
}
|
|
|
|
resp.setOk();
|
|
}
|
|
else resp.setFail("Cant get data from GXS!");
|
|
}
|
|
|
|
void ChannelsHandler::handleToggleSubscription(Request& req, Response& resp)
|
|
{
|
|
std::string chanIdStr;
|
|
bool subscribe = true;
|
|
|
|
req.mStream << makeKeyValueReference("channel_id", chanIdStr)
|
|
<< makeKeyValueReference("subscribe", subscribe);
|
|
|
|
if(chanIdStr.empty())
|
|
{
|
|
resp.setFail("channel_id required!");
|
|
return;
|
|
}
|
|
|
|
RsGxsGroupId chanId(chanIdStr);
|
|
if(chanId.isNull())
|
|
{
|
|
resp.setFail("Invalid channel_id:" + chanIdStr);
|
|
return;
|
|
}
|
|
|
|
uint32_t token;
|
|
if(mChannels.subscribeToGroup(token, chanId, subscribe))
|
|
{
|
|
RsTokenService& tChannels = *mChannels.getTokenService();
|
|
|
|
time_t start = time(NULL);
|
|
while((tChannels.requestStatus(token) != RsTokenService::GXS_REQUEST_V2_STATUS_COMPLETE)
|
|
&&(tChannels.requestStatus(token) != RsTokenService::GXS_REQUEST_V2_STATUS_FAILED)
|
|
&&((time(NULL) < (start+10)))) rstime::rs_usleep(500*1000);
|
|
|
|
if(tChannels.requestStatus(token) == RsTokenService::GXS_REQUEST_V2_STATUS_COMPLETE)
|
|
resp.setOk();
|
|
else resp.setFail("Unknown GXS error!");
|
|
}
|
|
else resp.setFail("Unknown GXS error!");
|
|
}
|
|
|
|
void ChannelsHandler::handleCreateChannel(Request& req, Response& resp)
|
|
{
|
|
RsGxsChannelGroup chan;
|
|
RsGroupMetaData& cMeta = chan.mMeta;
|
|
std::string authorIdStr;
|
|
std::string thumbnail_base64;
|
|
|
|
req.mStream << makeKeyValueReference("author_id", authorIdStr)
|
|
<< makeKeyValueReference("name", cMeta.mGroupName)
|
|
<< makeKeyValueReference("description", chan.mDescription)
|
|
<< makeKeyValueReference("thumbnail_base64_png", thumbnail_base64);
|
|
|
|
if(cMeta.mGroupName.empty())
|
|
{
|
|
resp.setFail("Channel name required!");
|
|
return;
|
|
}
|
|
|
|
if(thumbnail_base64.empty()) chan.mImage.clear();
|
|
else
|
|
{
|
|
std::vector<uint8_t> png_data = Radix64::decode(thumbnail_base64);
|
|
if(!png_data.empty())
|
|
{
|
|
if(png_data.size() < 8)
|
|
{
|
|
resp.setFail("Decoded thumbnail_base64_png is smaller than 8 byte. This can't be a valid png file!");
|
|
return;
|
|
}
|
|
uint8_t png_magic_number[] = {0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a};
|
|
if(!std::equal(&png_magic_number[0],&png_magic_number[8],png_data.begin()))
|
|
{
|
|
resp.setFail("Decoded thumbnail_base64_png does not seem to be a png file. (Header is missing magic number)");
|
|
return;
|
|
}
|
|
chan.mImage.copy(png_data.data(), png_data.size());
|
|
}
|
|
}
|
|
|
|
if(!authorIdStr.empty()) cMeta.mAuthorId = RsGxsId(authorIdStr);
|
|
|
|
// ATM supports creating only public channels
|
|
cMeta.mGroupFlags = GXS_SERV::FLAG_PRIVACY_PUBLIC;
|
|
|
|
// I am not sure about those flags I have reversed them with the debugger
|
|
// that gives 520 as value of this member when a channel with default
|
|
// options is created from Qt Gui
|
|
cMeta.mSignFlags = GXS_SERV::MSG_AUTHEN_CHILD_AUTHOR_SIGN |
|
|
GXS_SERV::FLAG_AUTHOR_AUTHENTICATION_REQUIRED;
|
|
|
|
uint32_t token;
|
|
if(mChannels.createGroup(token, chan))
|
|
{
|
|
RsTokenService& tChannels = *mChannels.getTokenService();
|
|
|
|
time_t start = time(NULL);
|
|
while((tChannels.requestStatus(token) != RsTokenService::GXS_REQUEST_V2_STATUS_COMPLETE)
|
|
&&(tChannels.requestStatus(token) != RsTokenService::GXS_REQUEST_V2_STATUS_FAILED)
|
|
&&((time(NULL) < (start+10)))) rstime::rs_usleep(500*1000);
|
|
|
|
if(tChannels.requestStatus(token) == RsTokenService::GXS_REQUEST_V2_STATUS_COMPLETE)
|
|
resp.setOk();
|
|
else resp.setFail("Unknown GXS error!");
|
|
}
|
|
else resp.setFail("Unkown GXS error!");
|
|
}
|
|
|
|
void ChannelsHandler::handleToggleAutoDownload(Request& req, Response& resp)
|
|
{
|
|
|
|
std::string chanIdStr;
|
|
bool autoDownload = true;
|
|
|
|
req.mStream << makeKeyValueReference("channel_id", chanIdStr)
|
|
<< makeKeyValueReference("auto_download", autoDownload);
|
|
|
|
if(chanIdStr.empty())
|
|
{
|
|
resp.setFail("channel_id required!");
|
|
return;
|
|
}
|
|
|
|
RsGxsGroupId chanId(chanIdStr);
|
|
if(chanId.isNull())
|
|
{
|
|
resp.setFail("Invalid channel_id:" + chanIdStr);
|
|
return;
|
|
}
|
|
|
|
if(mChannels.setChannelAutoDownload(chanId, autoDownload))
|
|
resp.setOk();
|
|
else resp.setFail();
|
|
}
|
|
|
|
void ChannelsHandler::handleTogglePostRead(Request& req, Response& resp)
|
|
{
|
|
std::string chanIdStr;
|
|
std::string postIdStr;
|
|
bool read = true;
|
|
|
|
req.mStream << makeKeyValueReference("channel_id", chanIdStr)
|
|
<< makeKeyValueReference("post_id", postIdStr)
|
|
<< makeKeyValueReference("read", read);
|
|
|
|
if(chanIdStr.empty())
|
|
{
|
|
resp.setFail("channel_id required!");
|
|
return;
|
|
}
|
|
|
|
RsGxsGroupId chanId(chanIdStr);
|
|
if(chanId.isNull())
|
|
{
|
|
resp.setFail("Invalid channel_id:" + chanIdStr);
|
|
return;
|
|
}
|
|
|
|
if(postIdStr.empty())
|
|
{
|
|
resp.setFail("post_id required!");
|
|
return;
|
|
}
|
|
|
|
RsGxsMessageId postId(postIdStr);
|
|
if(postId.isNull())
|
|
{
|
|
resp.setFail("Invalid post_id:" + postIdStr);
|
|
return;
|
|
}
|
|
|
|
std::cerr << __PRETTY_FUNCTION__ << " " << chanIdStr << " " << postIdStr
|
|
<< " " << read << std::endl;
|
|
|
|
uint32_t token;
|
|
mChannels.setMessageReadStatus(token, std::make_pair(chanId,postId), read);
|
|
|
|
RsTokenService& tChannels = *mChannels.getTokenService();
|
|
|
|
time_t start = time(NULL);
|
|
while((tChannels.requestStatus(token) != RsTokenService::GXS_REQUEST_V2_STATUS_COMPLETE)
|
|
&&(tChannels.requestStatus(token) != RsTokenService::GXS_REQUEST_V2_STATUS_FAILED)
|
|
&&((time(NULL) < (start+10)))) rstime::rs_usleep(500*1000);
|
|
|
|
if(tChannels.requestStatus(token) == RsTokenService::GXS_REQUEST_V2_STATUS_COMPLETE)
|
|
resp.setOk();
|
|
else resp.setFail("Unknown GXS error!");
|
|
}
|
|
|
|
void ChannelsHandler::handleCreatePost(Request &req, Response &resp)
|
|
{
|
|
RsGxsChannelPost post;
|
|
|
|
req.mStream << makeKeyValueReference("channel_id", post.mMeta.mGroupId);
|
|
req.mStream << makeKeyValueReference("subject", post.mMeta.mMsgName);
|
|
req.mStream << makeKeyValueReference("message", post.mMsg);
|
|
|
|
StreamBase& file_array = req.mStream.getStreamToMember("files");
|
|
while(file_array.hasMore())
|
|
{
|
|
RsGxsFile file;
|
|
file_array.getStreamToMember() << file;
|
|
post.mFiles.push_back(file);
|
|
}
|
|
|
|
std::string thumbnail_base64;
|
|
req.mStream << makeKeyValueReference("thumbnail_base64_png", thumbnail_base64);
|
|
|
|
if(post.mMeta.mGroupId.isNull())
|
|
{
|
|
resp.setFail("groupd_id is null");
|
|
return;
|
|
}
|
|
if(post.mMeta.mMsgName.empty())
|
|
{
|
|
resp.setFail("subject is empty");
|
|
return;
|
|
}
|
|
if(post.mMsg.empty())
|
|
{
|
|
resp.setFail("msg text is empty");
|
|
return;
|
|
}
|
|
// empty file list is ok, but files have to be valid
|
|
for(std::list<RsGxsFile>::iterator lit = post.mFiles.begin(); lit != post.mFiles.end(); ++lit)
|
|
{
|
|
if(lit->mHash.isNull())
|
|
{
|
|
resp.setFail("at least one file hash is empty");
|
|
return;
|
|
}
|
|
if(lit->mName.empty())
|
|
{
|
|
resp.setFail("at leats one file name is empty");
|
|
return;
|
|
}
|
|
if(lit->mSize == 0)
|
|
{
|
|
resp.setFail("at least one file size is empty");
|
|
return;
|
|
}
|
|
}
|
|
|
|
std::vector<uint8_t> png_data = Radix64::decode(thumbnail_base64);
|
|
if(!png_data.empty())
|
|
{
|
|
if(png_data.size() < 8)
|
|
{
|
|
resp.setFail("Decoded thumbnail_base64_png is smaller than 8 byte. This can't be a valid png file!");
|
|
return;
|
|
}
|
|
uint8_t png_magic_number[] = {0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a};
|
|
if(!std::equal(&png_magic_number[0],&png_magic_number[8],png_data.begin()))
|
|
{
|
|
resp.setFail("Decoded thumbnail_base64_png does not seem to be a png file. (Header is missing magic number)");
|
|
return;
|
|
}
|
|
post.mThumbnail.copy(png_data.data(), png_data.size());
|
|
}
|
|
|
|
uint32_t token;
|
|
if(mChannels.createPost(token, post))
|
|
{
|
|
RsTokenService& tChannels = *mChannels.getTokenService();
|
|
|
|
time_t start = time(NULL);
|
|
while((tChannels.requestStatus(token) != RsTokenService::GXS_REQUEST_V2_STATUS_COMPLETE)
|
|
&&(tChannels.requestStatus(token) != RsTokenService::GXS_REQUEST_V2_STATUS_FAILED)
|
|
&&((time(NULL) < (start+10)))) rstime::rs_usleep(500*1000);
|
|
|
|
if(tChannels.requestStatus(token) == RsTokenService::GXS_REQUEST_V2_STATUS_COMPLETE)
|
|
resp.setOk();
|
|
else resp.setFail("Unknown GXS error!");
|
|
}
|
|
else resp.setFail("Unknown GXS error!");
|
|
}
|
|
|
|
} // namespace resource_api
|