Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2025-06-30 17:17:21 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

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
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 * * libretroshare: retroshare core library *
* * * *
* Copyright (C) 2012 Robert Fernie <retroshare@lunamutt.com> * * 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 * * This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Lesser General Public License as * * it under the terms of the GNU Lesser General Public License as *
@ -33,6 +33,8 @@
#include "serialiser/rsserializable.h" #include "serialiser/rsserializable.h"
#include "retroshare/rsturtle.h" #include "retroshare/rsturtle.h"
#include "util/rsdeprecate.h" #include "util/rsdeprecate.h"
#include "retroshare/rsgxscircles.h"
#include "util/rsmemory.h"
class RsGxsChannels; class RsGxsChannels;
@ -99,94 +101,101 @@ public:
explicit RsGxsChannels(RsGxsIface& gxs) : RsGxsIfaceHelper(gxs) {} explicit RsGxsChannels(RsGxsIface& gxs) : RsGxsIfaceHelper(gxs) {}
virtual ~RsGxsChannels() {} virtual ~RsGxsChannels() {}
#ifdef REMOVED
/** /**
* @brief Create channel. Blocking API. * @brief Create channel. Blocking API.
* @jsonapi{development} * @jsonapi{development}
* @param[inout] channel Channel data (name, description...) * @param[in] name Name of the channel
* @return false on error, true otherwise * @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; virtual bool createChannelV2(
#endif const std::string& name, const std::string& description,
const RsGxsImage& thumbnail = RsGxsImage(),
/** const RsGxsId& authorId = RsGxsId(),
* @brief Create channel. Blocking API. RsGxsCircleType circleType = RsGxsCircleType::PUBLIC,
* @jsonapi{development} const RsGxsCircleId& circleId = RsGxsCircleId(),
* @param[in] name Name of the channel RsGxsGroupId& channelId = RS_DEFAULT_STORAGE_PARAM(RsGxsGroupId),
* @param[in] description Description of the channel std::string& errorMessage = RS_DEFAULT_STORAGE_PARAM(std::string) ) = 0;
* @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;
/** /**
* @brief Add a comment on a post or on another comment * @brief Add a comment on a post or on another comment
* @jsonapi{development} * @jsonapi{development}
* @param[in] groupId Id of the channel in which the comment is to be posted * @param[in] channelId 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] parentId Id of the parent of the comment that is either a
* @param[in] comment UTF-8 string containing the comment * channel post Id or the Id of another comment.
* @param[out] commentMessageId Id of the comment that was created * @param[in] comment UTF-8 string containing the comment
* @param[out] error_string Error message supplied when the comment creation fails. * @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 * @return false on error, true otherwise
*/ */
virtual bool createComment(const RsGxsGroupId& groupId, virtual bool createCommentV2(
const RsGxsMessageId& parentMsgId, const RsGxsGroupId& channelId, const RsGxsMessageId& parentId,
const std::string& comment, const std::string& comment,
RsGxsMessageId& commentMessageId, RsGxsMessageId& commentMessageId = RS_DEFAULT_STORAGE_PARAM(RsGxsMessageId),
std::string& error_message )=0; std::string& errorMessage = RS_DEFAULT_STORAGE_PARAM(std::string) )=0;
/** /**
* @brief Create channel post. Blocking API. * @brief Create channel post. Blocking API.
* @jsonapi{development} * @jsonapi{development}
* @param[in] groupId Id of the channel where to put the post (publish rights needed!) * @param[in] channelId Id of the channel where to put the post. Beware you
* @param[in] origMsgId Id of the post you are replacing. If left blank (RsGxsMssageId()="0000.....0000", a new post will be created * need publish rights on that channel to post.
* @param[in] msgName Title of the post * @param[in] title Title of the post
* @param[in] msg Text content of the post * @param[in] mBody Text content of the post
* @param[in] files List of attached files. These are supposed to be shared otherwise (use ExtraFileHash() below) * @param[in] files Optional list of attached files. These are supposed to
* @param[in] thumbnail Image displayed in the list of posts. Can be left blank. * be already shared, @see ExtraFileHash() below otherwise.
* @param[out] messsageId Id of the message that was created * @param[in] thumbnail Optional thumbnail image for the post.
* @param[out] error_message Error text if anything bad happens * @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 * @return false on error, true otherwise
*/ */
virtual bool createPost(const RsGxsGroupId& groupId, virtual bool createPostV2(
const RsGxsMessageId& origMsgId, const RsGxsGroupId& channelId, const std::string& title,
const std::string& msgName, const std::string& mBody,
const std::string& msg, const std::list<RsGxsFile>& files = std::list<RsGxsFile>(),
const std::list<RsGxsFile>& files, const RsGxsImage& thumbnail = RsGxsImage(),
const RsGxsImage& thumbnail, const RsGxsMessageId& origPostId = RsGxsMessageId(),
RsGxsMessageId& messageId, RsGxsMessageId& postId = RS_DEFAULT_STORAGE_PARAM(RsGxsMessageId),
std::string& error_message) = 0; std::string& errorMessage = RS_DEFAULT_STORAGE_PARAM(std::string) ) = 0;
/** /**
* @brief createVote * @brief Create a vote
* @jsonapi{development} * @jsonapi{development}
* @param[in] groupId Id of the channel where to put the post (publish rights needed!) * @param[in] channelId Id of the channel where to vote
* @param[in] threadId Id of the channel post in which a comment is voted * @param[in] postId Id of the channel post of which a comment is voted
* @param[in] commentMesssageId Id of the comment that is voted * @param[in] commentId Id of the comment that is voted
* @param[in] authorId Id of the author. Needs to be your identity. * @param[in] authorId Id of the author. Needs to be of an owned identity.
* @param[in] voteType Type of vote (GXS_VOTE_NONE=0x00, GXS_VOTE_DOWN=0x01, GXS_VOTE_UP=0x02) * @param[in] vote Vote value, either RsGxsVoteType::DOWN or
* @param[out] voteMessageId Id of the vote message produced * RsGxsVoteType::UP
* @param[out] error_message Error text if anything bad happens * @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 * @return false on error, true otherwise
*/ */
virtual bool createVote( const RsGxsGroupId& groupId, virtual bool createVoteV2(
const RsGxsMessageId& threadId, const RsGxsGroupId& channelId, const RsGxsMessageId& postId,
const RsGxsMessageId& commentMessageId, const RsGxsMessageId& commentId, const RsGxsId& authorId,
const RsGxsId& authorId, RsGxsVoteType vote,
uint32_t voteType, RsGxsMessageId& voteId = RS_DEFAULT_STORAGE_PARAM(RsGxsMessageId),
RsGxsMessageId& voteMessageId, std::string& errorMessage = RS_DEFAULT_STORAGE_PARAM(std::string) ) = 0;
std::string& error_message)=0;
/** /**
* @brief Edit channel details. * @brief Edit channel details.
@ -372,6 +381,16 @@ public:
/* Following functions are deprecated as they expose internal functioning /* Following functions are deprecated as they expose internal functioning
* semantic, instead of a safe to use API */ * 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) RS_DEPRECATED_FOR(getChannelsInfo)
virtual bool getGroupData(const uint32_t &token, std::vector<RsGxsChannelGroup> &groups) = 0; virtual bool getGroupData(const uint32_t &token, std::vector<RsGxsChannelGroup> &groups) = 0;
@ -429,9 +448,29 @@ public:
* @param[in] group Channel data (name, description...) * @param[in] group Channel data (name, description...)
* @return false on error, true otherwise * @return false on error, true otherwise
*/ */
RS_DEPRECATED_FOR(createChannel) RS_DEPRECATED_FOR(createChannelV2)
virtual bool createGroup(uint32_t& token, RsGxsChannelGroup& group) = 0; 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. * @brief Request post creation.
* The action is performed asyncronously, so it could fail in a subsequent * The action is performed asyncronously, so it could fail in a subsequent
@ -442,9 +481,19 @@ public:
* @param[in] post * @param[in] post
* @return false on error, true otherwise * @return false on error, true otherwise
*/ */
RS_DEPRECATED RS_DEPRECATED_FOR(createPostV2)
virtual bool createPost(uint32_t& token, RsGxsChannelPost& post) = 0; 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. * @brief Request channel change.
* The action is performed asyncronously, so it could fail in a subsequent * 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; 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 /** Restricted to a group of friend nodes, the administrator of the circle
/// The meaning of the different circle types is: * behave as a hub for them */
static const uint32_t GXS_CIRCLE_TYPE_UNKNOWN = 0x0000 ; /// Used to detect uninizialized values. NODES_GROUP = 3,
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.
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_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_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_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_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 struct RsGxsCircleGroup : RsSerializable
{ {
@ -110,8 +121,9 @@ struct RsGxsCircleMsg : RsSerializable
struct RsGxsCircleDetails : RsSerializable struct RsGxsCircleDetails : RsSerializable
{ {
RsGxsCircleDetails() : RsGxsCircleDetails() :
mCircleType(GXS_CIRCLE_TYPE_EXTERNAL), mAmIAllowed(false) {} mCircleType(static_cast<uint32_t>(RsGxsCircleType::EXTERNAL)),
~RsGxsCircleDetails() {} mAmIAllowed(false) {}
~RsGxsCircleDetails() override {}
RsGxsCircleId mCircleId; RsGxsCircleId mCircleId;
std::string mCircleName; std::string mCircleName;
@ -264,3 +276,34 @@ public:
RS_DEPRECATED_FOR("editCircle, inviteIdsToCircle") RS_DEPRECATED_FOR("editCircle, inviteIdsToCircle")
virtual void updateGroup(uint32_t &token, RsGxsCircleGroup &group) = 0; 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/>. * * along with this program. If not, see <https://www.gnu.org/licenses/>. *
* * * *
*******************************************************************************/ *******************************************************************************/
#pragma once
#ifndef RETROSHARE_GXS_COMMON_OBJS_INTERFACE_H #include <cstdint>
#define RETROSHARE_GXS_COMMON_OBJS_INTERFACE_H
#include <inttypes.h>
#include <string> #include <string>
#include <list> #include <list>
@ -79,10 +77,12 @@ struct RsGxsImage : RsSerializable
} }
}; };
enum class RsGxsVoteType : uint32_t
#define GXS_VOTE_NONE 0x0000 {
#define GXS_VOTE_DOWN 0x0001 NONE = 0, /// Used to detect unset vote?
#define GXS_VOTE_UP 0x0002 DOWN = 1, /// Negative vote
UP = 2 /// Positive vote
};
// Status Flags to indicate Voting.... // Status Flags to indicate Voting....
@ -181,7 +181,11 @@ struct RsGxsCommentService
std::pair<RsGxsGroupId, RsGxsMessageId>& msgId ) = 0; 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 * * libretroshare: retroshare core library *
* * * *
* Copyright 2011 by Christopher Evi-Parker * * 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 * * This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Lesser General Public License as * * 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/>. * * along with this program. If not, see <https://www.gnu.org/licenses/>. *
* * * *
*******************************************************************************/ *******************************************************************************/
#pragma once
#ifndef RSGXSIFACEIMPL_H
#define RSGXSIFACEIMPL_H
#include <chrono> #include <chrono>
#include <thread> #include <thread>
@ -292,19 +290,51 @@ protected:
* Useful for blocking API implementation. * Useful for blocking API implementation.
* @param[in] token token associated to the request caller is waiting for * @param[in] token token associated to the request caller is waiting for
* @param[in] maxWait maximum waiting time in milliseconds * @param[in] maxWait maximum waiting time in milliseconds
* @param[in] checkEvery time in millisecond between status checks
*/ */
RsTokenService::GxsRequestStatus waitToken( RsTokenService::GxsRequestStatus waitToken(
uint32_t token, 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 timeout = std::chrono::steady_clock::now() + maxWait;
auto st = requestStatus(token); auto st = requestStatus(token);
while( !(st == RsTokenService::FAILED || st >= RsTokenService::COMPLETE) while( !(st == RsTokenService::FAILED || st >= RsTokenService::COMPLETE)
&& std::chrono::steady_clock::now() < timeout ) && std::chrono::steady_clock::now() < timeout )
{ {
std::this_thread::sleep_for(std::chrono::milliseconds(2)); std::this_thread::sleep_for(checkEvery);
st = requestStatus(token); 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; return st;
} }
@ -312,5 +342,3 @@ private:
RsGxsIface& mGxs; RsGxsIface& mGxs;
RsTokenService& mTokenService; RsTokenService& mTokenService;
}; };
#endif // RSGXSIFACEIMPL_H

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

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

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

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

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

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

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

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