Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2024-12-27 00:19:25 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

Fix compilation, retrocompatibility and enums

Browse Source 
Workaround miss-behaviour on old Android phones
Cleanup indentation a bit
Consistent param naming
Introduce default parameter values also for output paramethers
This commit is contained in:
Gioacchino Mazzurco 2019-04-05 01:43:23 +02:00
parent 44c1f1580f
commit ab80d9a374
No known key found for this signature in database
GPG Key ID: A1FBCA3872E87051
8 changed files with 584 additions and 365 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

191
libretroshare/src/retroshare/rsgxschannels.h
View File

@ -4,7 +4,7 @@
* libretroshare: retroshare core library *
* *
* Copyright (C) 2012 Robert Fernie <retroshare@lunamutt.com> *
* Copyright (C) 2018 Gioacchino Mazzurco <gio@eigenlab.org> *
* Copyright (C) 2018-2019 Gioacchino Mazzurco <gio@eigenlab.org> *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Lesser General Public License as *
@ -33,6 +33,8 @@
#include "serialiser/rsserializable.h"
#include "retroshare/rsturtle.h"
#include "util/rsdeprecate.h"
#include "retroshare/rsgxscircles.h"
#include "util/rsmemory.h"
class RsGxsChannels;
@ -99,94 +101,101 @@ public:
explicit RsGxsChannels(RsGxsIface& gxs) : RsGxsIfaceHelper(gxs) {}
virtual ~RsGxsChannels() {}
#ifdef REMOVED
/**
* @brief Create channel. Blocking API.
* @jsonapi{development}
* @param[inout] channel Channel data (name, description...)
* @return false on error, true otherwise
* @param[in] name Name of the channel
* @param[in] description Description of the channel
* @param[in] thumbnail Optional image to show as channel thumbnail.
* @param[in] authorId Optional id of the author. Leave empty for an
* anonymous channel.
* @param[in] circleType Optional visibility rule, default public.
* @param[in] circleId If the channel is not public specify the id of the
* circle who can see the channel. Depending on the value you pass for
* circleType this should be be an external circle if EXTERNAL is passed, a
* local friend group id if NODES_GROUP is passed, empty otherwise.
* @param[out] channelId Optional storage for the id of the created channel,
* meaningful only if creations succeeds.
* @param[out] errorMessage Optional storage for error messsage, meaningful
* only if creation fail.
* @return False on error, true otherwise.
*/
virtual bool createChannel(RsGxsChannelGroup& channel) = 0;
#endif
/**
* @brief Create channel. Blocking API.
* @jsonapi{development}
* @param[in] name Name of the channel
* @param[in] description Description of the channel
* @param[in] image Thumbnail that is shown to advertise the channel. Possibly empty.
* @param[in] author_id GxsId of the contact author. For an anonymous channel, leave this to RsGxsId()="00000....0000"
* @param[in] circle_type Type of visibility restriction, among { GXS_CIRCLE_TYPE_PUBLIC, GXS_CIRCLE_TYPE_EXTERNAL, GXS_CIRCLE_TYPE_YOUR_FRIENDS_ONLY, GXS_CIRCLE_TYPE_YOUR_EYES_ONLY }
* @param[in] circle_id Id of the circle (should be an external circle for GXS_CIRCLE_TYPE_EXTERNAL, a local friend group for GXS_CIRCLE_TYPE_YOUR_FRIENDS_ONLY, GxsCircleId()="000....000" otherwise
* @param[out] channel_group_id Group id of the created channel, if command succeeds.
* @param[out] error_message Error messsage supplied when the channel creation fails.
* @return False on error, true otherwise.
*/
virtual bool createChannel(const std::string& name,
const std::string& description,
const RsGxsImage& image,
const RsGxsId& author_id,
uint32_t circle_type,
RsGxsCircleId& circle_id,
RsGxsGroupId& channel_group_id,
std::string& error_message )=0;
virtual bool createChannelV2(
const std::string& name, const std::string& description,
const RsGxsImage& thumbnail = RsGxsImage(),
const RsGxsId& authorId = RsGxsId(),
RsGxsCircleType circleType = RsGxsCircleType::PUBLIC,
const RsGxsCircleId& circleId = RsGxsCircleId(),
RsGxsGroupId& channelId = RS_DEFAULT_STORAGE_PARAM(RsGxsGroupId),
std::string& errorMessage = RS_DEFAULT_STORAGE_PARAM(std::string) ) = 0;
/**
* @brief Add a comment on a post or on another comment
* @jsonapi{development}
* @param[in] groupId Id of the channel in which the comment is to be posted
* @param[in] parentMsgId Id of the parent of the comment that is either a channel post Id or the Id of another comment.
* @param[in] comment UTF-8 string containing the comment
* @param[out] commentMessageId Id of the comment that was created
* @param[out] error_string Error message supplied when the comment creation fails.
* @param[in] channelId Id of the channel in which the comment is to be posted
* @param[in] parentId Id of the parent of the comment that is either a
* channel post Id or the Id of another comment.
* @param[in] comment UTF-8 string containing the comment
* @param[out] commentMessageId Optional storage for the id of the comment
* that was created, meaningful only on success.
* @param[out] errorMessage Optional storage for error message, meaningful
* only on failure.
* @return false on error, true otherwise
*/
virtual bool createComment(const RsGxsGroupId& groupId,
const RsGxsMessageId& parentMsgId,
const std::string& comment,
RsGxsMessageId& commentMessageId,
std::string& error_message )=0;
virtual bool createCommentV2(
const RsGxsGroupId& channelId, const RsGxsMessageId& parentId,
const std::string& comment,
RsGxsMessageId& commentMessageId = RS_DEFAULT_STORAGE_PARAM(RsGxsMessageId),
std::string& errorMessage = RS_DEFAULT_STORAGE_PARAM(std::string) )=0;
/**
* @brief Create channel post. Blocking API.
* @jsonapi{development}
* @param[in] groupId Id of the channel where to put the post (publish rights needed!)
* @param[in] origMsgId Id of the post you are replacing. If left blank (RsGxsMssageId()="0000.....0000", a new post will be created
* @param[in] msgName Title of the post
* @param[in] msg Text content of the post
* @param[in] files List of attached files. These are supposed to be shared otherwise (use ExtraFileHash() below)
* @param[in] thumbnail Image displayed in the list of posts. Can be left blank.
* @param[out] messsageId Id of the message that was created
* @param[out] error_message Error text if anything bad happens
* @param[in] channelId Id of the channel where to put the post. Beware you
* need publish rights on that channel to post.
* @param[in] title Title of the post
* @param[in] mBody Text content of the post
* @param[in] files Optional list of attached files. These are supposed to
* be already shared, @see ExtraFileHash() below otherwise.
* @param[in] thumbnail Optional thumbnail image for the post.
* @param[in] origPostId If this is supposed to replace an already existent
* post, the id of the old post. If left blank a new post will be created.
* @param[out] postId Optional storage for the id of the created post,
* meaningful only on success.
* @param[out] errorMessage Optional storage for the error message,
* meaningful only on failure.
* @return false on error, true otherwise
*/
virtual bool createPost(const RsGxsGroupId& groupId,
const RsGxsMessageId& origMsgId,
const std::string& msgName,
const std::string& msg,
const std::list<RsGxsFile>& files,
const RsGxsImage& thumbnail,
RsGxsMessageId& messageId,
std::string& error_message) = 0;
virtual bool createPostV2(
const RsGxsGroupId& channelId, const std::string& title,
const std::string& mBody,
const std::list<RsGxsFile>& files = std::list<RsGxsFile>(),
const RsGxsImage& thumbnail = RsGxsImage(),
const RsGxsMessageId& origPostId = RsGxsMessageId(),
RsGxsMessageId& postId = RS_DEFAULT_STORAGE_PARAM(RsGxsMessageId),
std::string& errorMessage = RS_DEFAULT_STORAGE_PARAM(std::string) ) = 0;
/**
* @brief createVote
* @brief Create a vote
* @jsonapi{development}
* @param[in] groupId Id of the channel where to put the post (publish rights needed!)
* @param[in] threadId Id of the channel post in which a comment is voted
* @param[in] commentMesssageId Id of the comment that is voted
* @param[in] authorId Id of the author. Needs to be your identity.
* @param[in] voteType Type of vote (GXS_VOTE_NONE=0x00, GXS_VOTE_DOWN=0x01, GXS_VOTE_UP=0x02)
* @param[out] voteMessageId Id of the vote message produced
* @param[out] error_message Error text if anything bad happens
* @param[in] channelId Id of the channel where to vote
* @param[in] postId Id of the channel post of which a comment is voted
* @param[in] commentId Id of the comment that is voted
* @param[in] authorId Id of the author. Needs to be of an owned identity.
* @param[in] vote Vote value, either RsGxsVoteType::DOWN or
* RsGxsVoteType::UP
* @param[out] voteId Optional storage for the id of the created vote,
* meaningful only on success.
* @param[out] errorMessage Optional storage for error message, meaningful
* only on failure.
* @return false on error, true otherwise
*/
virtual bool createVote( const RsGxsGroupId& groupId,
const RsGxsMessageId& threadId,
const RsGxsMessageId& commentMessageId,
const RsGxsId& authorId,
uint32_t voteType,
RsGxsMessageId& voteMessageId,
std::string& error_message)=0;
virtual bool createVoteV2(
const RsGxsGroupId& channelId, const RsGxsMessageId& postId,
const RsGxsMessageId& commentId, const RsGxsId& authorId,
RsGxsVoteType vote,
RsGxsMessageId& voteId = RS_DEFAULT_STORAGE_PARAM(RsGxsMessageId),
std::string& errorMessage = RS_DEFAULT_STORAGE_PARAM(std::string) ) = 0;
/**
* @brief Edit channel details.
@ -372,6 +381,16 @@ public:
/* Following functions are deprecated as they expose internal functioning
* semantic, instead of a safe to use API */
/**
* @brief Create channel. Blocking API.
* @jsonapi{development}
* @deprecated { substituted by createChannelV2 }
* @param[inout] channel Channel data (name, description...)
* @return false on error, true otherwise
*/
RS_DEPRECATED_FOR(createChannelV2)
virtual bool createChannel(RsGxsChannelGroup& channel) = 0;
RS_DEPRECATED_FOR(getChannelsInfo)
virtual bool getGroupData(const uint32_t &token, std::vector<RsGxsChannelGroup> &groups) = 0;
@ -429,9 +448,29 @@ public:
* @param[in] group Channel data (name, description...)
* @return false on error, true otherwise
*/
RS_DEPRECATED_FOR(createChannel)
RS_DEPRECATED_FOR(createChannelV2)
virtual bool createGroup(uint32_t& token, RsGxsChannelGroup& group) = 0;
/**
* @brief Add a comment on a post or on another comment
* @jsonapi{development}
* @deprecated
* @param[inout] comment
* @return false on error, true otherwise
*/
RS_DEPRECATED_FOR(createCommentV2)
virtual bool createComment(RsGxsComment& comment) = 0;
/**
* @brief Create channel post. Blocking API.
* @jsonapi{development}
* @deprecated
* @param[inout] post
* @return false on error, true otherwise
*/
RS_DEPRECATED_FOR(createPostV2)
virtual bool createPost(RsGxsChannelPost& post) = 0;
/**
* @brief Request post creation.
* The action is performed asyncronously, so it could fail in a subsequent
@ -442,9 +481,19 @@ public:
* @param[in] post
* @return false on error, true otherwise
*/
RS_DEPRECATED
RS_DEPRECATED_FOR(createPostV2)
virtual bool createPost(uint32_t& token, RsGxsChannelPost& post) = 0;
/**
* @brief createVote
* @jsonapi{development}
* @deprecated
* @param[inout] vote
* @return false on error, true otherwise
*/
RS_DEPRECATED_FOR(createVoteV2)
virtual bool createVote(RsGxsVote& vote) = 0;
/**
* @brief Request channel change.
* The action is performed asyncronously, so it could fail in a subsequent

69
libretroshare/src/retroshare/rsgxscircles.h
View File

@ -42,24 +42,35 @@ class RsGxsCircles;
*/
extern RsGxsCircles* rsGxsCircles;
enum class RsGxsCircleType : uint32_t // 32 bit overkill, just for retrocompat
{
UNKNOWN = 0, /// Used to detect uninizialized values.
PUBLIC = 1, /// Public distribution
EXTERNAL = 2, /// Restricted to an external circle
// TODO: convert to enum
/// The meaning of the different circle types is:
static const uint32_t GXS_CIRCLE_TYPE_UNKNOWN = 0x0000 ; /// Used to detect uninizialized values.
static const uint32_t GXS_CIRCLE_TYPE_PUBLIC = 0x0001 ; // not restricted to a circle
static const uint32_t GXS_CIRCLE_TYPE_EXTERNAL = 0x0002 ; // restricted to an external circle, made of RsGxsId
static const uint32_t GXS_CIRCLE_TYPE_YOUR_FRIENDS_ONLY = 0x0003 ; // restricted to a subset of friend nodes of a given RS node given by a RsPgpId list
static const uint32_t GXS_CIRCLE_TYPE_LOCAL = 0x0004 ; // not distributed at all
static const uint32_t GXS_CIRCLE_TYPE_EXT_SELF = 0x0005 ; // self-restricted. Not used, except at creation time when the circle ID isn't known yet. Set to EXTERNAL afterwards.
static const uint32_t GXS_CIRCLE_TYPE_YOUR_EYES_ONLY = 0x0006 ; // distributed to nodes signed by your own PGP key only.
/** Restricted to a group of friend nodes, the administrator of the circle
* behave as a hub for them */
NODES_GROUP = 3,
LOCAL = 4, /// not distributed at all
/** Self-restricted. Used only at creation time of self-restricted circles
* when the circle id isn't known yet. Once the circle id is known the type
* is set to EXTERNAL, and the external circle id is set to the id of the
* circle itself.
*/
EXT_SELF = 5,
/// distributed to nodes signed by your own PGP key only.
YOUR_EYES_ONLY = 6
};
// TODO: convert to enum class
static const uint32_t GXS_EXTERNAL_CIRCLE_FLAGS_IN_ADMIN_LIST = 0x0001 ;// user is validated by circle admin
static const uint32_t GXS_EXTERNAL_CIRCLE_FLAGS_SUBSCRIBED = 0x0002 ;// user has subscribed the group
static const uint32_t GXS_EXTERNAL_CIRCLE_FLAGS_KEY_AVAILABLE = 0x0004 ;// key is available, so we can encrypt for this circle
static const uint32_t GXS_EXTERNAL_CIRCLE_FLAGS_ALLOWED = 0x0007 ;// user is allowed. Combines all flags above.
static const uint32_t GXS_CIRCLE_FLAGS_IS_EXTERNAL = 0x0008 ;// user is allowed
struct RsGxsCircleGroup : RsSerializable
{
@ -110,8 +121,9 @@ struct RsGxsCircleMsg : RsSerializable
struct RsGxsCircleDetails : RsSerializable
{
RsGxsCircleDetails() :
mCircleType(GXS_CIRCLE_TYPE_EXTERNAL), mAmIAllowed(false) {}
~RsGxsCircleDetails() {}
mCircleType(static_cast<uint32_t>(RsGxsCircleType::EXTERNAL)),
mAmIAllowed(false) {}
~RsGxsCircleDetails() override {}
RsGxsCircleId mCircleId;
std::string mCircleName;
@ -264,3 +276,34 @@ public:
RS_DEPRECATED_FOR("editCircle, inviteIdsToCircle")
virtual void updateGroup(uint32_t &token, RsGxsCircleGroup &group) = 0;
};
/// @deprecated Used to detect uninizialized values.
RS_DEPRECATED_FOR("RsGxsCircleType::UNKNOWN")
static const uint32_t GXS_CIRCLE_TYPE_UNKNOWN = 0x0000;
/// @deprecated not restricted to a circle
RS_DEPRECATED_FOR("RsGxsCircleType::PUBLIC")
static const uint32_t GXS_CIRCLE_TYPE_PUBLIC = 0x0001;
/// @deprecated restricted to an external circle, made of RsGxsId
RS_DEPRECATED_FOR("RsGxsCircleType::EXTERNAL")
static const uint32_t GXS_CIRCLE_TYPE_EXTERNAL = 0x0002;
/// @deprecated restricted to a subset of friend nodes of a given RS node given
/// by a RsPgpId list
RS_DEPRECATED_FOR("RsGxsCircleType::NODES_GROUP")
static const uint32_t GXS_CIRCLE_TYPE_YOUR_FRIENDS_ONLY = 0x0003;
/// @deprecated not distributed at all
RS_DEPRECATED_FOR("RsGxsCircleType::LOCAL")
static const uint32_t GXS_CIRCLE_TYPE_LOCAL = 0x0004;
/// @deprecated self-restricted. Not used, except at creation time when the
/// circle ID isn't known yet. Set to EXTERNAL afterwards.
RS_DEPRECATED_FOR("RsGxsCircleType::EXT_SELF")
static const uint32_t GXS_CIRCLE_TYPE_EXT_SELF = 0x0005;
/// @deprecated distributed to nodes signed by your own PGP key only.
RS_DEPRECATED_FOR("RsGxsCircleType::YOUR_EYES_ONLY")
static const uint32_t GXS_CIRCLE_TYPE_YOUR_EYES_ONLY = 0x0006;

24
libretroshare/src/retroshare/rsgxscommon.h
View File

@ -19,11 +19,9 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>. *
* *
*******************************************************************************/
#pragma once
#ifndef RETROSHARE_GXS_COMMON_OBJS_INTERFACE_H
#define RETROSHARE_GXS_COMMON_OBJS_INTERFACE_H
#include <inttypes.h>
#include <cstdint>
#include <string>
#include <list>
@ -79,10 +77,12 @@ struct RsGxsImage : RsSerializable
}
};
#define GXS_VOTE_NONE 0x0000
#define GXS_VOTE_DOWN 0x0001
#define GXS_VOTE_UP 0x0002
enum class RsGxsVoteType : uint32_t
{
NONE = 0, /// Used to detect unset vote?
DOWN = 1, /// Negative vote
UP = 2 /// Positive vote
};
// Status Flags to indicate Voting....
@ -181,7 +181,11 @@ struct RsGxsCommentService
std::pair<RsGxsGroupId, RsGxsMessageId>& msgId ) = 0;
};
/// @deprecated use RsGxsVoteType::NONE instead @see RsGxsVoteType
#define GXS_VOTE_NONE 0x0000
/// @deprecated use RsGxsVoteType::DOWN instead @see RsGxsVoteType
#define GXS_VOTE_DOWN 0x0001
#endif
/// @deprecated use RsGxsVoteType::UP instead @see RsGxsVoteType
#define GXS_VOTE_UP 0x0002

44
libretroshare/src/retroshare/rsgxsifacehelper.h
View File

@ -4,7 +4,7 @@
* libretroshare: retroshare core library *
* *
* Copyright 2011 by Christopher Evi-Parker *
* Copyright (C) 2018 Gioacchino Mazzurco <gio@eigenlab.org> *
* Copyright (C) 2018-2019 Gioacchino Mazzurco <gio@eigenlab.org> *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Lesser General Public License as *
@ -20,9 +20,7 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>. *
* *
*******************************************************************************/
#ifndef RSGXSIFACEIMPL_H
#define RSGXSIFACEIMPL_H
#pragma once
#include <chrono>
#include <thread>
@ -292,19 +290,51 @@ protected:
* Useful for blocking API implementation.
* @param[in] token token associated to the request caller is waiting for
* @param[in] maxWait maximum waiting time in milliseconds
* @param[in] checkEvery time in millisecond between status checks
*/
RsTokenService::GxsRequestStatus waitToken(
uint32_t token,
std::chrono::milliseconds maxWait = std::chrono::milliseconds(500) )
std::chrono::milliseconds maxWait = std::chrono::milliseconds(500),
std::chrono::milliseconds checkEvery = std::chrono::milliseconds(2))
{
#if defined(__ANDROID__) && (__ANDROID_API__ < 24)
auto wkStartime = std::chrono::steady_clock::now();
int maxWorkAroundCnt = 10;
LLwaitTokenBeginLabel:
#endif
auto timeout = std::chrono::steady_clock::now() + maxWait;
auto st = requestStatus(token);
while( !(st == RsTokenService::FAILED || st >= RsTokenService::COMPLETE)
&& std::chrono::steady_clock::now() < timeout )
{
std::this_thread::sleep_for(std::chrono::milliseconds(2));
std::this_thread::sleep_for(checkEvery);
st = requestStatus(token);
}
#if defined(__ANDROID__) && (__ANDROID_API__ < 24)
/* Work around for very slow/old android devices, we don't expect this
* to be necessary on newer devices. If it take unreasonably long
* something worser is already happening elsewere amd we return anyway.
*/
if( st > RsTokenService::FAILED && st < RsTokenService::COMPLETE
&& maxWorkAroundCnt-- > 0 )
{
maxWait *= 10;
checkEvery *= 3;
std::cerr << __PRETTY_FUNCTION__ << " Slow Android device "
<< " workaround st: " << st
<< " maxWorkAroundCnt: " << maxWorkAroundCnt
<< " maxWait: " << maxWait.count()
<< " checkEvery: " << checkEvery.count() << std::endl;
goto LLwaitTokenBeginLabel;
}
std::cerr << __PRETTY_FUNCTION__ << " lasted: "
<< std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::steady_clock::now() - wkStartime ).count()
<< "ms" << std::endl;
#endif
return st;
}
@ -312,5 +342,3 @@ private:
RsGxsIface& mGxs;
RsTokenService& mTokenService;
};
#endif // RSGXSIFACEIMPL_H

13
libretroshare/src/retroshare/rstokenservice.h
View File

@ -121,15 +121,14 @@ public:
enum GxsRequestStatus : uint8_t
{
FAILED,
PENDING,
PARTIAL,
COMPLETE,
DONE, /// Once all data has been retrived
CANCELLED
FAILED = 0,
PENDING = 1,
PARTIAL = 2,
COMPLETE = 3,
DONE = 4, /// Once all data has been retrived
CANCELLED = 5
};
RsTokenService() {}
virtual ~RsTokenService() {}

485
libretroshare/src/services/p3gxschannels.cc
View File

@ -4,7 +4,7 @@
* libretroshare: retroshare core library *
* *
* Copyright (C) 2012 Robert Fernie <retroshare@lunamutt.com> *
* Copyright (C) 2018 Gioacchino Mazzurco <gio@eigenlab.org> *
* Copyright (C) 2018-2019 Gioacchino Mazzurco <gio@eigenlab.org> *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Lesser General Public License as *
@ -38,6 +38,7 @@
#include <cstdio>
#include <chrono>
#include <string>
// For Dummy Msgs.
#include "util/rsrandom.h"
@ -1056,108 +1057,115 @@ bool p3GxsChannels::getChannelContent( const RsGxsGroupId& channelId,
return getPostData(token, posts, comments);
}
bool p3GxsChannels::createChannel(const std::string& name,
const std::string& description,
const RsGxsImage& image,
const RsGxsId& author_id,
uint32_t circle_type,
RsGxsCircleId& circle_id,
RsGxsGroupId& channel_group_id,
std::string& error_message)
bool p3GxsChannels::createChannelV2(
const std::string& name, const std::string& description,
const RsGxsImage& thumbnail, const RsGxsId& authorId,
RsGxsCircleType circleType, const RsGxsCircleId& circleId,
RsGxsGroupId& channelId, std::string& errorMessage )
{
// do some checks
// do some checks
if( circle_type != GXS_CIRCLE_TYPE_PUBLIC
&& circle_type != GXS_CIRCLE_TYPE_EXTERNAL
&& circle_type != GXS_CIRCLE_TYPE_YOUR_FRIENDS_ONLY
&& circle_type != GXS_CIRCLE_TYPE_LOCAL
&& circle_type != GXS_CIRCLE_TYPE_YOUR_EYES_ONLY )
{
error_message = std::string("circle_type has a non allowed value") ;
return false ;
}
if( circleType != RsGxsCircleType::PUBLIC
&& circleType != RsGxsCircleType::EXTERNAL
&& circleType != RsGxsCircleType::NODES_GROUP
&& circleType != RsGxsCircleType::LOCAL
&& circleType != RsGxsCircleType::YOUR_EYES_ONLY)
{
errorMessage = "circleType has invalid value";
return false;
}
switch(circle_type)
{
case GXS_CIRCLE_TYPE_EXTERNAL:
if(circle_id.isNull())
{
error_message = std::string("circle_type is GXS_CIRCLE_TYPE_EXTERNAL but circle_id is null");
return false ;
}
break;
case GXS_CIRCLE_TYPE_YOUR_FRIENDS_ONLY:
{
RsGroupInfo ginfo;
if(!rsPeers->getGroupInfo(RsNodeGroupId(circle_id),ginfo))
{
error_message = std::string("circle_type is GXS_CIRCLE_TYPE_YOUR_FRIENDS_ONLY but circle_id is not set or does not correspond to a actual group of friends");
return false;
}
switch(circleType)
{
case RsGxsCircleType::EXTERNAL:
if(circleId.isNull())
{
errorMessage = "circleType is EXTERNAL but circleId is null";
return false;
}
break;
default:
if(!circle_id.isNull())
{
error_message = std::string("circle_type requires a null circle id, but a non null circle id (" + circle_id.toStdString() + ") was supplied");
return false;
}
}
case RsGxsCircleType::NODES_GROUP:
{
RsGroupInfo ginfo;
// Create a consistent channel group meta from the information supplied
if(!rsPeers->getGroupInfo(RsNodeGroupId(circleId), ginfo))
{
errorMessage = "circleType is NODES_GROUP but circleId does not "
"correspond to an actual group of friends";
return false;
}
break;
}
default:
if(!circleId.isNull())
{
errorMessage = "circleType requires a null circleId, but a non "
"null circleId (";
errorMessage += circleId.toStdString();
errorMessage += ") was supplied";
return false;
}
break;
}
RsGxsChannelGroup channel ;
// Create a consistent channel group meta from the information supplied
RsGxsChannelGroup channel;
channel.mMeta.mGroupName = name ;
channel.mMeta.mAuthorId = author_id ;
channel.mMeta.mCircleType = circle_type ;
channel.mMeta.mGroupName = name;
channel.mMeta.mAuthorId = authorId;
channel.mMeta.mCircleType = static_cast<uint32_t>(circleType);
channel.mMeta.mSignFlags = GXS_SERV::FLAG_GROUP_SIGN_PUBLISH_NONEREQ
| GXS_SERV::FLAG_AUTHOR_AUTHENTICATION_REQUIRED;
channel.mMeta.mSignFlags = GXS_SERV::FLAG_GROUP_SIGN_PUBLISH_NONEREQ
| GXS_SERV::FLAG_AUTHOR_AUTHENTICATION_REQUIRED;
channel.mMeta.mGroupFlags = GXS_SERV::FLAG_PRIVACY_PUBLIC;
channel.mMeta.mGroupFlags = GXS_SERV::FLAG_PRIVACY_PUBLIC;
channel.mMeta.mCircleId.clear();
channel.mMeta.mInternalCircle.clear();
if(circle_type == GXS_CIRCLE_TYPE_YOUR_FRIENDS_ONLY)
channel.mMeta.mInternalCircle = circle_id;
else if(circle_type == GXS_CIRCLE_TYPE_EXTERNAL)
channel.mMeta.mCircleId = circle_id;
switch(circleType)
{
case RsGxsCircleType::NODES_GROUP:
channel.mMeta.mInternalCircle = circleId; break;
case RsGxsCircleType::EXTERNAL:
channel.mMeta.mCircleId = circleId; break;
default: break;
}
// Create the channel
channel.mDescription = description ;
channel.mImage = image ;
// Create the channel
channel.mDescription = description;
channel.mImage = thumbnail;
uint32_t token;
if(!createGroup(token, channel))
{
std::cerr << __PRETTY_FUNCTION__ << "Error! Failed creating group."
errorMessage = "Failed creating GXS group.";
std::cerr << __PRETTY_FUNCTION__ << " Error! " << errorMessage
<< std::endl;
return false;
}
// wait for the group creation to complete.
if(waitToken(token) != RsTokenService::COMPLETE)
// wait for the group creation to complete.
RsTokenService::GxsRequestStatus wSt = waitToken(token);
if(wSt != RsTokenService::COMPLETE)
{
std::cerr << __PRETTY_FUNCTION__ << "Error! GXS operation failed."
errorMessage = "GXS operation waitToken failed with: "
+ std::to_string(wSt);
std::cerr << __PRETTY_FUNCTION__ << " Error! " << errorMessage
<< std::endl;
return false;
}
if(!RsGenExchange::getPublishedGroupMeta(token, channel.mMeta))
{
std::cerr << __PRETTY_FUNCTION__ << "Error! Failure getting updated "
<< " group data." << std::endl;
errorMessage = "Failure getting updated group data.";
std::cerr << __PRETTY_FUNCTION__ << " Error! " << errorMessage
<< std::endl;
return false;
}
channel_group_id = channel.mMeta.mGroupId;
channelId = channel.mMeta.mGroupId;
#ifdef RS_DEEP_SEARCH
DeepSearch::indexChannelGroup(channel);
@ -1166,27 +1174,26 @@ bool p3GxsChannels::createChannel(const std::string& name,
return true;
}
#ifdef REMOVED
bool p3GxsChannels::createChannel(RsGxsChannelGroup& channel)
{
uint32_t token;
if(!createGroup(token, channel))
{
std::cerr << __PRETTY_FUNCTION__ << "Error! Failed creating group."
std::cerr << __PRETTY_FUNCTION__ << " Error! Failed creating group."
<< std::endl;
return false;
}
if(waitToken(token) != RsTokenService::COMPLETE)
{
std::cerr << __PRETTY_FUNCTION__ << "Error! GXS operation failed."
std::cerr << __PRETTY_FUNCTION__ << " Error! GXS operation failed."
<< std::endl;
return false;
}
if(!RsGenExchange::getPublishedGroupMeta(token, channel.mMeta))
{
std::cerr << __PRETTY_FUNCTION__ << "Error! Failure getting updated "
std::cerr << __PRETTY_FUNCTION__ << " Error! Failure getting updated "
<< " group data." << std::endl;
return false;
}
@ -1197,91 +1204,126 @@ bool p3GxsChannels::createChannel(RsGxsChannelGroup& channel)
return true;
}
#endif
bool p3GxsChannels::createVote( const RsGxsGroupId& groupId,
const RsGxsMessageId & threadId,
const RsGxsMessageId& commentMessageId,
const RsGxsId& authorId,
uint32_t voteType,
RsGxsMessageId& voteMessageId,
std::string& error_message)
bool p3GxsChannels::createVoteV2(
const RsGxsGroupId& channelId, const RsGxsMessageId& postId,
const RsGxsMessageId& commentId, const RsGxsId& authorId,
RsGxsVoteType tVote, RsGxsMessageId& voteId, std::string& errorMessage )
{
// Do some checks
std::vector<RsGxsChannelGroup> channelsInfo;
if(!getChannelsInfo(std::list<RsGxsGroupId>({groupId}),channelsInfo)) // does the channel actually exist?
{
error_message = std::string("Channel with Id " + groupId.toStdString() + " does not exist.");
return false;
}
if(commentMessageId.isNull()) // has a correct comment msg id been supplied?
{
error_message = std::string("You cannot vote on null comment " + commentMessageId.toStdString() + " of channel with Id " + groupId.toStdString() + ": please supply a non null comment Id!");
if(!getChannelsInfo(std::list<RsGxsGroupId>({channelId}),channelsInfo))
{
errorMessage = "Channel with Id " + channelId.toStdString()
+ " does not exist.";
return false;
}
}
std::set<RsGxsMessageId> s({commentMessageId});
if(commentId.isNull())
{
errorMessage = "You cannot vote on null comment "
+ commentId.toStdString();
return false;
}
std::set<RsGxsMessageId> s({commentId});
std::vector<RsGxsChannelPost> posts;
std::vector<RsGxsComment> comments;
if(!getChannelContent( groupId,s,posts,comments )) // does the comment to vote actually exist?
if(!getChannelContent(channelId, s, posts, comments))
{
error_message = std::string("You cannot vote on comment " + commentMessageId.toStdString() + " of channel with Id " + groupId.toStdString() + ": this comment does not locally exist!");
errorMessage = "You cannot vote on comment "
+ commentId.toStdString() + " of channel with Id "
+ channelId.toStdString()
+ ": this comment does not exists locally!";
return false;
}
if(posts.front().mMeta.mParentId.isNull()) // is the ID a comment ID or a post ID? It should be comment => should have a parent ID
// is the ID a comment ID or a post ID?
// It should be comment => should have a parent ID
if(posts.front().mMeta.mParentId.isNull())
{
error_message = std::string("You cannot vote on channel message " + commentMessageId.toStdString() + " of channel with Id " + groupId.toStdString() + ": this ID refers to a post, not a comment!");
errorMessage = "You cannot vote on channel message "
+ commentId.toStdString() + " of channel with Id "
+ channelId.toStdString()
+ ": given id refers to a post, not a comment!";
return false;
}
if(voteType != GXS_VOTE_NONE && voteType != GXS_VOTE_UP && voteType != GXS_VOTE_DOWN) // is voteType consistent?
{
error_message = std::string("Your vote to channel with Id " + groupId.toStdString() + " has wrong vote type. Only GXS_VOTE_NONE, GXS_VOTE_UP, GXS_VOTE_DOWN accepted.");
if( tVote != RsGxsVoteType::NONE
&& tVote != RsGxsVoteType::UP
&& tVote != RsGxsVoteType::DOWN )
{
errorMessage = "Your vote to channel with Id "
+ channelId.toStdString() + " has wrong vote type. "
+ " Only RsGxsVoteType::NONE, RsGxsVoteType::UP, "
+ "RsGxsVoteType::DOWN are accepted.";
return false;
}
}
if(!rsIdentity->isOwnId(authorId)) // is the voter ID actually ours?
{
error_message = std::string("You cannot vote to channel with Id " + groupId.toStdString() + " with identity " + authorId.toStdString() + " because it is not yours.");
if(!rsIdentity->isOwnId(authorId))
{
errorMessage = "You cannot vote to channel with Id "
+ channelId.toStdString() + " with identity "
+ authorId.toStdString() + " because it is not yours.";
return false;
}
// Create the vote
}
// Create the vote
RsGxsVote vote;
vote.mMeta.mGroupId = groupId;
vote.mMeta.mThreadId = threadId;
vote.mMeta.mParentId = commentMessageId;
vote.mMeta.mGroupId = channelId;
vote.mMeta.mThreadId = postId;
vote.mMeta.mParentId = commentId;
vote.mMeta.mAuthorId = authorId;
vote.mVoteType = voteType;
vote.mVoteType = static_cast<uint32_t>(tVote);
uint32_t token;
if(!createNewVote(token, vote))
{
error_message = std::string("Error! Failed creating vote.");
errorMessage = "Error! Failed creating vote.";
return false;
}
if(waitToken(token) != RsTokenService::COMPLETE)
{
error_message = std::string("Error! GXS operation failed.");
errorMessage = "GXS operation failed.";
return false;
}
if(!RsGenExchange::getPublishedMsgMeta(token, vote.mMeta))
{
error_message = std::string("Error! Failure getting generated vote data.");
errorMessage = "Failure getting generated vote data.";
return false;
}
voteId = vote.mMeta.mMsgId;
return true;
}
/// @deprecated use createVoteV2 instead
bool p3GxsChannels::createVote(RsGxsVote& vote)
{
uint32_t token;
if(!createNewVote(token, vote))
{
std::cerr << __PRETTY_FUNCTION__ << " Error! Failed creating vote."
<< std::endl;
return false;
}
if(waitToken(token) != RsTokenService::COMPLETE)
{
std::cerr << __PRETTY_FUNCTION__ << " Error! GXS operation failed."
<< std::endl;
return false;
}
if(!RsGenExchange::getPublishedMsgMeta(token, vote.mMeta))
{
std::cerr << __PRETTY_FUNCTION__ << " Error! Failure getting generated "
<< " vote data." << std::endl;
return false;
}
voteMessageId = vote.mMeta.mMsgId;
return true;
}
@ -1290,21 +1332,21 @@ bool p3GxsChannels::editChannel(RsGxsChannelGroup& channel)
uint32_t token;
if(!updateGroup(token, channel))
{
std::cerr << __PRETTY_FUNCTION__ << "Error! Failed updating group."
std::cerr << __PRETTY_FUNCTION__ << " Error! Failed updating group."
<< std::endl;
return false;
}
if(waitToken(token) != RsTokenService::COMPLETE)
{
std::cerr << __PRETTY_FUNCTION__ << "Error! GXS operation failed."
std::cerr << __PRETTY_FUNCTION__ << " Error! GXS operation failed."
<< std::endl;
return false;
}
if(!RsGenExchange::getPublishedGroupMeta(token, channel.mMeta))
{
std::cerr << __PRETTY_FUNCTION__ << "Error! Failure getting updated "
std::cerr << __PRETTY_FUNCTION__ << " Error! Failure getting updated "
<< " group data." << std::endl;
return false;
}
@ -1316,60 +1358,64 @@ bool p3GxsChannels::editChannel(RsGxsChannelGroup& channel)
return true;
}
bool p3GxsChannels::createPost(const RsGxsGroupId& groupId,
const RsGxsMessageId &origMsgId,
const std::string& msgName,
const std::string& msg,
const std::list<RsGxsFile>& files,
const RsGxsImage& thumbnail,
RsGxsMessageId &message_id,
std::string& error_message)
bool p3GxsChannels::createPostV2(
const RsGxsGroupId& channelId, const std::string& title,
const std::string& body, const std::list<RsGxsFile>& files,
const RsGxsImage& thumbnail, const RsGxsMessageId& origPostId,
RsGxsMessageId& postId, std::string& errorMessage )
{
// Do some checks
std::vector<RsGxsChannelGroup> channelsInfo;
if(!getChannelsInfo(std::list<RsGxsGroupId>({groupId}),channelsInfo))
{
error_message = std::string("Channel with Id " + groupId.toStdString() + " does not exist.");
return false;
}
const RsGxsChannelGroup& cg(*channelsInfo.begin());
if(!(cg.mMeta.mSubscribeFlags & GXS_SERV::GROUP_SUBSCRIBE_PUBLISH))
{
error_message = std::string("You cannot post to channel with Id " + groupId.toStdString() + ": missing publish rights!");
return false;
}
if(!origMsgId.isNull())
if(!getChannelsInfo(std::list<RsGxsGroupId>({channelId}),channelsInfo))
{
std::set<RsGxsMessageId> s({origMsgId});
errorMessage = "Channel with Id " + channelId.toStdString() +
" does not exist.";
return false;
}
const RsGxsChannelGroup& cg(*channelsInfo.begin());
if(!(cg.mMeta.mSubscribeFlags & GXS_SERV::GROUP_SUBSCRIBE_PUBLISH))
{
errorMessage = "You cannot post to channel with Id " +
channelId.toStdString() + ": missing publish rights!";
return false;
}
if(!origPostId.isNull())
{
std::set<RsGxsMessageId> s({origPostId});
std::vector<RsGxsChannelPost> posts;
std::vector<RsGxsComment> comments;
if(!getChannelContent( groupId,s,posts,comments ))
{
error_message = std::string("You cannot edit post " + origMsgId.toStdString() + " of channel with Id " + groupId.toStdString() + ": this post does not locally exist!");
if(!getChannelContent(channelId,s,posts,comments))
{
errorMessage = "You cannot edit post " + origPostId.toStdString()
+ " of channel with Id " + channelId.toStdString()
+ ": this post does not exist locally!";
return false;
}
}
}
// Create the post
RsGxsChannelPost post;
post.mMeta.mGroupId = groupId;
post.mMeta.mOrigMsgId = origMsgId;
post.mMeta.mMsgName = msgName;
post.mMeta.mGroupId = channelId;
post.mMeta.mOrigMsgId = origPostId;
post.mMeta.mMsgName = title;
post.mMsg = msg;
post.mFiles = files;
post.mThumbnail = thumbnail;
post.mMsg = body;
post.mFiles = files;
post.mThumbnail = thumbnail;
uint32_t token;
if( !createPost(token, post) || waitToken(token) != RsTokenService::COMPLETE )
return false;
if(!createPost(token, post) || waitToken(token) != RsTokenService::COMPLETE)
{
errorMessage = "GXS operation failed";
return false;
}
if(RsGenExchange::getPublishedMsgMeta(token,post.mMeta))
{
@ -1377,74 +1423,101 @@ bool p3GxsChannels::createPost(const RsGxsGroupId& groupId,
DeepSearch::indexChannelPost(post);
#endif // RS_DEEP_SEARCH
message_id = post.mMeta.mMsgId;
postId = post.mMeta.mMsgId;
return true;
}
error_message = std::string("cannot publish message. Check that you have publish rights on this channel?");
errorMessage = "Failed to retrive created post metadata";
return false;
}
bool p3GxsChannels::createComment(const RsGxsGroupId& groupId,
const RsGxsMessageId& parentMsgId,
const std::string& comment,
RsGxsMessageId& commentMessageId,
std::string& error_message)
bool p3GxsChannels::createCommentV2(
const RsGxsGroupId& channelId, const RsGxsMessageId& parentId,
const std::string& comment, RsGxsMessageId& commentMessageId,
std::string& errorMessage )
{
// Do some checks
std::vector<RsGxsChannelGroup> channelsInfo;
if(!getChannelsInfo(std::list<RsGxsGroupId>({groupId}),channelsInfo))
{
error_message = std::string("Channel with Id " + groupId.toStdString() + " does not exist.");
return false;
}
if(parentMsgId.isNull())
{
error_message = std::string("You cannot comment post " + parentMsgId.toStdString() + " of channel with Id " + groupId.toStdString() + ": please supply a non null post Id!");
return false;
}
std::set<RsGxsMessageId> s({parentMsgId});
std::vector<RsGxsChannelPost> posts;
std::vector<RsGxsComment> comments;
if(!getChannelContent( groupId,s,posts,comments ))
if(!getChannelsInfo(std::list<RsGxsGroupId>({channelId}),channelsInfo))
{
error_message = std::string("You cannot comment post " + parentMsgId.toStdString() + " of channel with Id " + groupId.toStdString() + ": this post does not locally exist!");
errorMessage = "Channel with Id " + channelId.toStdString()
+ " does not exist.";
return false;
}
// Now create the comment
if(parentId.isNull())
{
errorMessage = "You cannot comment post " + parentId.toStdString()
+ " of channel with Id " + channelId.toStdString()
+ ": please supply a non null post Id!";
return false;
}
std::set<RsGxsMessageId> s({parentId});
std::vector<RsGxsChannelPost> posts;
std::vector<RsGxsComment> comments;
if(!getChannelContent(channelId,s,posts,comments))
{
errorMessage = "You cannot comment post " + parentId.toStdString()
+ " of channel with Id " + channelId.toStdString()
+ ": this post does not exists locally!";
return false;
}
// Now create the comment
RsGxsComment cmt;
cmt.mComment = comment;
cmt.mMeta.mGroupId = groupId;
cmt.mMeta.mParentId = parentMsgId;
cmt.mComment = comment;
cmt.mMeta.mGroupId = channelId;
cmt.mMeta.mParentId = parentId;
uint32_t token;
if(!createNewComment(token, cmt))
{
error_message = std::string("Error! Failed creating comment.");
errorMessage = "Failed creating comment.";
return false;
}
if(waitToken(token) != RsTokenService::COMPLETE)
{
error_message = std::string("Error! GXS operation failed.");
errorMessage = "GXS operation failed.";
return false;
}
if(!RsGenExchange::getPublishedMsgMeta(token, cmt.mMeta))
{
error_message = std::string("Error! Failure getting generated comment data.");
errorMessage = "Failure getting generated comment data.";
return false;
}
commentMessageId = cmt.mMeta.mMsgId;
return true;
}
bool p3GxsChannels::createComment(RsGxsComment& comment) // deprecated
{
uint32_t token;
if(!createNewComment(token, comment))
{
std::cerr << __PRETTY_FUNCTION__ << " Error! Failed creating comment."
<< std::endl;
return false;
}
if(waitToken(token) != RsTokenService::COMPLETE)
{
std::cerr << __PRETTY_FUNCTION__ << " Error! GXS operation failed."
<< std::endl;
return false;
}
if(!RsGenExchange::getPublishedMsgMeta(token, comment.mMeta))
{
std::cerr << __PRETTY_FUNCTION__ << " Error! Failure getting generated "
<< " comment data." << std::endl;
return false;
}
commentMessageId = cmt.mMeta.mMsgId;
return true;
}
@ -1687,13 +1760,31 @@ bool p3GxsChannels::updateGroup(uint32_t &token, RsGxsChannelGroup &group)
return true;
}
/// @deprecated use createPostV2 instead
bool p3GxsChannels::createPost(RsGxsChannelPost& post)
{
uint32_t token;
if( !createPost(token, post)
|| waitToken(token) != RsTokenService::COMPLETE ) return false;
if(RsGenExchange::getPublishedMsgMeta(token,post.mMeta))
{
#ifdef RS_DEEP_SEARCH
DeepSearch::indexChannelPost(post);
#endif // RS_DEEP_SEARCH
return true;
}
return false;
}
bool p3GxsChannels::createPost(uint32_t &token, RsGxsChannelPost &msg)
{
#ifdef GXSCHANNELS_DEBUG
std::cerr << "p3GxsChannels::createChannelPost() GroupId: " << msg.mMeta.mGroupId;
std::cerr << std::endl;
std::cerr << __PRETTY_FUNCTION__ << " GroupId: " << msg.mMeta.mGroupId
<< std::endl;
#endif
RsGxsChannelPostItem* msgItem = new RsGxsChannelPostItem();
@ -2235,7 +2326,7 @@ bool p3GxsChannels::turtleChannelRequest(
{
if(channelId.isNull())
{
std::cerr << __PRETTY_FUNCTION__ << "Error! channelId can't be null!"
std::cerr << __PRETTY_FUNCTION__ << " Error! channelId can't be null!"
<< std::endl;
return false;
}

120
libretroshare/src/services/p3gxschannels.h
View File

@ -4,7 +4,7 @@
* libretroshare: retroshare core library *
* *
* Copyright (C) 2012 Robert Fernie <retroshare@lunamutt.com> *
* Copyright (C) 2018 Gioacchino Mazzurco <gio@eigenlab.org> *
* Copyright (C) 2018-2019 Gioacchino Mazzurco <gio@eigenlab.org> *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Lesser General Public License as *
@ -20,14 +20,14 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>. *
* *
*******************************************************************************/
#ifndef P3_GXSCHANNELS_SERVICE_HEADER
#define P3_GXSCHANNELS_SERVICE_HEADER
#pragma once
#include "retroshare/rsgxschannels.h"
#include "services/p3gxscommon.h"
#include "gxs/rsgenexchange.h"
#include "gxs/gxstokenqueue.h"
#include "util/rsmemory.h"
#include "util/rstickevent.h"
@ -35,6 +35,7 @@
#include <string>
class SSGxsChannelGroup
{
public:
@ -191,66 +192,63 @@ virtual bool ExtraFileRemove(const RsFileHash &hash);
std::vector<RsGxsComment>& comments );
/// Implementation of @see RsGxsChannels::getContentSummaries
virtual bool getContentSummaries( const RsGxsGroupId& channelId,
std::vector<RsMsgMetaData>& summaries );
virtual bool getContentSummaries(
const RsGxsGroupId& channelId,
std::vector<RsMsgMetaData>& summaries ) override;
#ifdef REMOVED
/// Implementation of @see RsGxsChannels::createChannel
virtual bool createChannel(RsGxsChannelGroup& channel);
#endif
/// Implementation of @see RsGxsChannels::createChannelV2
virtual bool createChannelV2(
const std::string& name, const std::string& description,
const RsGxsImage& thumbnail = RsGxsImage(),
const RsGxsId& authorId = RsGxsId(),
RsGxsCircleType circleType = RsGxsCircleType::PUBLIC,
const RsGxsCircleId& circleId = RsGxsCircleId(),
RsGxsGroupId& channelId = RS_DEFAULT_STORAGE_PARAM(RsGxsGroupId),
std::string& errorMessage = RS_DEFAULT_STORAGE_PARAM(std::string)
) override;
/// Implementation of @see RsGxsChannels::createChannel
virtual bool createChannel(const std::string& name,
const std::string& description,
const RsGxsImage& image,
const RsGxsId& author_id,
uint32_t circle_type,
RsGxsCircleId& circle_id,
RsGxsGroupId& channel_group_id,
std::string& error_message);
#ifdef REMOVED
/// Implementation of @see RsGxsChannels::createComment
virtual bool createComment(RsGxsComment& comment);
#endif
/// @deprecated Implementation of @see RsGxsChannels::createComment
RS_DEPRECATED_FOR(createCommentV2)
virtual bool createComment(RsGxsComment& comment) override;
/// Implementation of @see RsGxsChannels::createComment
virtual bool createComment(const RsGxsGroupId& groupId,
const RsGxsMessageId& parentMsgId,
const std::string& comment,
RsGxsMessageId& commentMessageId,
std::string& error_message);
virtual bool createCommentV2(
const RsGxsGroupId& channelId, const RsGxsMessageId& parentId,
const std::string& comment,
RsGxsMessageId& commentMessageId = RS_DEFAULT_STORAGE_PARAM(RsGxsMessageId),
std::string& errorMessage = RS_DEFAULT_STORAGE_PARAM(std::string)
) override;
/// Implementation of @see RsGxsChannels::editChannel
virtual bool editChannel(RsGxsChannelGroup& channel);
virtual bool editChannel(RsGxsChannelGroup& channel) override;
#ifdef REMOVED
/// Implementation of @see RsGxsChannels::createPost
virtual bool createPost(RsGxsChannelPost& post);
#endif
/// Implementation of @see RsGxsChannels::createPost
virtual bool createPost(const RsGxsGroupId& groupId,
const RsGxsMessageId& origMsgId,
const std::string& msgName,
const std::string& msg,
const std::list<RsGxsFile>& files,
const RsGxsImage& thumbnail,
RsGxsMessageId &message_id,
std::string& error_message) ;
/// @deprecated Implementation of @see RsGxsChannels::createPost
RS_DEPRECATED_FOR(createPostV2)
virtual bool createPost(RsGxsChannelPost& post) override;
#ifdef REMOVED
/// Implementation of @see RsGxsChannels::createVote
virtual bool createVote(RsGxsVote& vote);
#endif
/// Implementation of @see RsGxsChannels::createPostV2
bool createPostV2(
const RsGxsGroupId& channelId, const std::string& title,
const std::string& body,
const std::list<RsGxsFile>& files = std::list<RsGxsFile>(),
const RsGxsImage& thumbnail = RsGxsImage(),
const RsGxsMessageId& origPostId = RsGxsMessageId(),
RsGxsMessageId& postId = RS_DEFAULT_STORAGE_PARAM(RsGxsMessageId),
std::string& errorMessage = RS_DEFAULT_STORAGE_PARAM(std::string)
) override;
/// Implementation of @see RsGxsChannels::createVote
virtual bool createVote(const RsGxsGroupId& groupId,
const RsGxsMessageId& threadId,
const RsGxsMessageId& commentMessageId,
const RsGxsId& authorId,
uint32_t voteType,
RsGxsMessageId& voteMessageId,
std::string& error_message);
/// @deprecated Implementation of @see RsGxsChannels::createVote
RS_DEPRECATED_FOR(createVoteV2)
virtual bool createVote(RsGxsVote& vote) override;
/// Implementation of @see RsGxsChannels::createVoteV2
virtual bool createVoteV2(
const RsGxsGroupId& channelId, const RsGxsMessageId& postId,
const RsGxsMessageId& commentId, const RsGxsId& authorId,
RsGxsVoteType vote,
RsGxsMessageId& voteId = RS_DEFAULT_STORAGE_PARAM(RsGxsMessageId),
std::string& errorMessage = RS_DEFAULT_STORAGE_PARAM(std::string)
) override;
/// Implementation of @see RsGxsChannels::subscribeToChannel
virtual bool subscribeToChannel( const RsGxsGroupId &groupId,
@ -262,6 +260,10 @@ virtual bool ExtraFileRemove(const RsFileHash &hash);
virtual bool shareChannelKeys(
const RsGxsGroupId& channelId, const std::set<RsPeerId>& peers );
/// Implementation of @see RsGxsChannels::createChannel
RS_DEPRECATED_FOR(createChannelV2)
virtual bool createChannel(RsGxsChannelGroup& channel) override;
protected:
// Overloaded from GxsTokenQueue for Request callbacks.
virtual void handleResponse(uint32_t token, uint32_t req_type);
@ -306,9 +308,11 @@ bool generateGroup(uint32_t &token, std::string groupName);
class ChannelDummyRef
{
public:
ChannelDummyRef() { return; }
ChannelDummyRef(const RsGxsGroupId &grpId, const RsGxsMessageId &threadId, const RsGxsMessageId &msgId)
:mGroupId(grpId), mThreadId(threadId), mMsgId(msgId) { return; }
ChannelDummyRef() {}
ChannelDummyRef(
const RsGxsGroupId &grpId, const RsGxsMessageId &threadId,
const RsGxsMessageId &msgId ) :
mGroupId(grpId), mThreadId(threadId), mMsgId(msgId) {}
RsGxsGroupId mGroupId;
RsGxsMessageId mThreadId;
@ -352,5 +356,3 @@ bool generateGroup(uint32_t &token, std::string groupName);
/// Cleanup mSearchCallbacksMap and mDistantChannelsCallbacksMap
void cleanTimedOutCallbacks();
};
#endif

3
libretroshare/src/util/rsmemory.h
View File

@ -23,8 +23,11 @@
#include <stdlib.h>
#include <iostream>
#include <memory>
#include <util/stacktrace.h>
#define RS_DEFAULT_STORAGE_PARAM(Type) *std::unique_ptr<Type>(new Type)
void *rs_malloc(size_t size) ;
// This is a scope guard to release the memory block when going of of the current scope.