Implement JSON API for circles

libretroshare/src/retroshare/rsgxscircles.h

@@ -3,7 +3,8 @@
  *                                                                             *
  * libretroshare: retroshare core library                                      *
  *                                                                             *
- * Copyright 2012-2012 by Robert Fernie <retroshare@lunamutt.com>              *
+ * Copyright (C) 2012  Robert Fernie <retroshare@lunamutt.com>                 *
+ * Copyright (C) 2018  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              *
@@ -19,34 +20,31 @@
  * along with this program. If not, see <https://www.gnu.org/licenses/>.       *
  *                                                                             *
  *******************************************************************************/
-#ifndef RETROSHARE_GXSCIRCLES_INTERFACE_H
+#pragma once
-#define RETROSHARE_GXSCIRCLES_INTERFACE_H
 
-#include <inttypes.h>
+#include <cstdint>
 #include <string>
 #include <list>
 #include <set>
 
 #include "retroshare/rstypes.h"
-
-//typedef std::string RsGxsCircleId;
-//typedef RsPgpId RsPgpId;
-//typedef std::string RsCircleInternalId;
-
 #include "retroshare/rstokenservice.h"
 #include "retroshare/rsgxsifacehelper.h"
-
 #include "retroshare/rsidentity.h"
+#include "serialiser/rsserializable.h"
 
 
-/* The Main Interface Class - for information about your Peers */
 class RsGxsCircles;
+
+/**
+ * Pointer to global instance of RsGxsCircles service implementation
+ * @jsonapi{development}
+ */
 extern RsGxsCircles* rsGxsCircles;
 
-typedef RsPgpId RsPgpId;
 
+// TODO: convert to enum
 /// The meaning of the different circle types is:
-/// TODO: convert to enum
 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
@@ -62,47 +60,58 @@ static const uint32_t GXS_EXTERNAL_CIRCLE_FLAGS_ALLOWED       = 0x0007 ;// user
 
 static const uint32_t GXS_CIRCLE_FLAGS_IS_EXTERNAL   = 0x0008 ;// user is allowed
 
-/* Permissions is part of GroupMetaData  */
 
-class GxsPermissions
+struct RsGxsCircleGroup : RsSerializable
 {
-public:
+	virtual ~RsGxsCircleGroup() {}
-	uint32_t mCircleType; // PUBLIC, EXTERNAL or YOUREYESONLY.      
-	RsGxsCircleId mCircleId; // If EXTERNAL, otherwise Blank.
 
-	// BELOW IS NOT SERIALISED - BUT MUST BE STORED LOCALLY BY GXS. (If YOUREYESONLY)
+	RsGroupMetaData mMeta;
-	RsPeerId mOriginator;
-	RsGxsCircleId mInternalCircle; // if Originator == ownId, otherwise blank.
-};
-
-class RsGxsCircleGroup
-{
-	public:
-	RsGroupMetaData mMeta; // includes GxsPermissions, for control of group distribution.
 
 	std::set<RsPgpId> mLocalFriends;
 	std::set<RsGxsId> mInvitedMembers;
 	std::set<RsGxsCircleId> mSubCircles;
+#ifdef V07_NON_BACKWARD_COMPATIBLE_CHANGE_UNNAMED
+#	error "Add description, and multiple owners/administrators to circles"
+	// or better in general to GXS groups
+#endif
 
-	// Not Serialised.
+	/// @see RsSerializable
-	// Internally inside rsCircles, this will be turned into:
+	void serial_process( RsGenericSerializer::SerializeJob j,
-	// std::list<RsPeerId> mAllowedFriends;
+	                     RsGenericSerializer::SerializeContext& ctx) override
+	{
+		RS_SERIAL_PROCESS(mMeta);
+		RS_SERIAL_PROCESS(mLocalFriends);
+		RS_SERIAL_PROCESS(mInvitedMembers);
+		RS_SERIAL_PROCESS(mSubCircles);
+	}
 };
 
-class RsGxsCircleMsg
+struct RsGxsCircleMsg : RsSerializable
 {
-	public:
+	virtual ~RsGxsCircleMsg() {}
+
 	RsMsgMetaData mMeta;
 
-	// Signature by user signifying that they want to be part of the group.
+#ifndef V07_NON_BACKWARD_COMPATIBLE_CHANGE_UNNAMED
-	// maybe Phase 3.
+	/* This is horrible and should be changed into yet to be defined something
+	 * reasonable in next non retrocompatible version */
 	std::string stuff;
+#endif
+
+	/// @see RsSerializable
+	void serial_process( RsGenericSerializer::SerializeJob j,
+	                     RsGenericSerializer::SerializeContext& ctx) override
+	{
+		RS_SERIAL_PROCESS(mMeta);
+		RS_SERIAL_PROCESS(stuff);
+	}
 };
 
-class RsGxsCircleDetails
+struct RsGxsCircleDetails : RsSerializable
 {
-        public:
+	RsGxsCircleDetails() :
-    		RsGxsCircleDetails() : mCircleType(GXS_CIRCLE_TYPE_EXTERNAL), mAmIAllowed(false) {}
+	    mCircleType(GXS_CIRCLE_TYPE_EXTERNAL), mAmIAllowed(false) {}
+	~RsGxsCircleDetails() {}
 
 	RsGxsCircleId mCircleId;
 	std::string mCircleName;
@@ -110,12 +119,30 @@ class RsGxsCircleDetails
 	uint32_t mCircleType;
 	RsGxsCircleId mRestrictedCircleId;
 
-        bool mAmIAllowed ;			// true when one of load GXS ids belong to the circle allowed list (admin list & subscribed list).
+	/** true when one of load GXS ids belong to the circle allowed list (admin
+	 * list & subscribed list). */
+	bool mAmIAllowed;
 
-        std::set<RsGxsId> mAllowedGxsIds;	// This crosses admin list and subscribed list
+	/// This crosses admin list and subscribed list
+	std::set<RsGxsId> mAllowedGxsIds;
 	std::set<RsPgpId> mAllowedNodes;
 
-        std::map<RsGxsId,uint32_t> mSubscriptionFlags ;	// subscription flags for all ids
+	/// subscription flags for all ids
+	std::map<RsGxsId,uint32_t> mSubscriptionFlags;
+
+	/// @see RsSerializable
+	void serial_process( RsGenericSerializer::SerializeJob j,
+	                     RsGenericSerializer::SerializeContext& ctx) override
+	{
+		RS_SERIAL_PROCESS(mCircleId);
+		RS_SERIAL_PROCESS(mCircleName);
+		RS_SERIAL_PROCESS(mCircleType);
+		RS_SERIAL_PROCESS(mRestrictedCircleId);
+		RS_SERIAL_PROCESS(mAmIAllowed);
+		RS_SERIAL_PROCESS(mAllowedGxsIds);
+		RS_SERIAL_PROCESS(mAllowedNodes);
+		RS_SERIAL_PROCESS(mSubscriptionFlags);
+	}
 };
 
 class RsGxsCircles: public RsGxsIfaceHelper
@@ -125,27 +152,115 @@ public:
 	RsGxsCircles(RsGxsIface& gxs) : RsGxsIfaceHelper(gxs) {}
 	virtual ~RsGxsCircles() {}
 
-	/* External Interface (Cached stuff) */
+	/**
-	virtual bool getCircleDetails(const RsGxsCircleId &id, RsGxsCircleDetails &details) = 0;
+	 * @brief Create new circle
-	virtual bool getCircleExternalIdList(std::list<RsGxsCircleId> &circleIds) = 0;
+	 * @jsonapi{development}
-	virtual bool getCirclePersonalIdList(std::list<RsGxsCircleId> &circleIds) = 0;
+	 * @param[inout] cData input name and flags of the circle, storage for
+	 *	generated circle data id etc.
+	 * @return false if something failed, true otherwhise
+	 */
+	virtual bool createCircle(RsGxsCircleGroup& cData) = 0;
 
-	/* membership management for external circles */
+	/**
+	 * @brief Edit own existing circle
+	 * @jsonapi{development}
+	 * @param[inout] cData Circle data with modifications, storage for data
+	 *	updatedad during the operation.
+	 * @return false if something failed, true otherwhise
+	 */
+	virtual bool editCircle(RsGxsCircleGroup& cData) = 0;
 
-	virtual bool requestCircleMembership(const RsGxsId& own_gxsid,const RsGxsCircleId& circle_id)=0 ;
+	/**
-	virtual bool cancelCircleMembership(const RsGxsId& own_gxsid,const RsGxsCircleId& circle_id)=0 ;
+	 * @brief Get circle details. Memory cached
+	 * @jsonapi{development}
+	 * @param[in] id Id of the circle
+	 * @param[out] details Storage for the circle details
+	 * @return false if something failed, true otherwhise
+	 */
+	virtual bool getCircleDetails(
+	        const RsGxsCircleId& id, RsGxsCircleDetails& details ) = 0;
 
-	/* standard load */
+	/**
-	virtual bool getGroupData(const uint32_t &token, std::vector<RsGxsCircleGroup> &groups) = 0;
+	 * @brief Get list of known external circles ids. Memory cached
-	virtual bool getMsgData(const uint32_t &token, std::vector<RsGxsCircleMsg> &msgs) = 0;
+	 * @jsonapi{development}
+	 * @param[in] circleIds Storage for circles id list
+	 * @return false if something failed, true otherwhise
+	 */
+	virtual bool getCircleExternalIdList(
+	        std::list<RsGxsCircleId>& circleIds ) = 0;
 
-	/* make new group */
+	/**
+	 * @brief Get circles summaries list.
+	 * @jsonapi{development}
+	 * @param[out] circles list where to store the circles summaries
+	 * @return false if something failed, true otherwhise
+	 */
+	virtual bool getCirclesSummaries(std::list<RsGroupMetaData>& circles) = 0;
+
+	/**
+	 * @brief Get circles information
+	 * @jsonapi{development}
+	 * @param[in] circlesIds ids of the circles of which to get the informations
+	 * @param[out] circlesInfo storage for the circles informations
+	 * @return false if something failed, true otherwhise
+	 */
+	virtual bool getCirclesInfo(
+	        const std::list<RsGxsGroupId>& circlesIds,
+	        std::vector<RsGxsCircleGroup>& circlesInfo ) = 0;
+
+	/**
+	 * @brief Get circle requests
+	 * @jsonapi{development}
+	 * @param[in] circleId id of the circle of which the requests are requested
+	 * @param[out] requests storage for the circle requests
+	 * @return false if something failed, true otherwhise
+	 */
+	virtual bool getCircleRequests( const RsGxsGroupId& circleId,
+	                                std::vector<RsGxsCircleMsg>& requests ) = 0;
+
+	/**
+	 * @brief Invite identities to circle
+	 * @jsonapi{development}
+	 * @param[in] identities ids of the identities to invite
+	 * @param[in] circleId Id of the circle you own and want to invite ids in
+	 * @return false if something failed, true otherwhise
+	 */
+	virtual bool inviteIdsToCircle( const std::set<RsGxsId>& identities,
+	                                const RsGxsCircleId& circleId ) = 0;
+
+	/**
+	 * @brief Request circle membership, or accept circle invitation
+	 * @jsonapi{development}
+	 * @param[in] ownGxsId Id of own identity to introduce to the circle
+	 * @param[in] circleId Id of the circle to which ask for inclusion
+	 * @return false if something failed, true otherwhise
+	 */
+	virtual bool requestCircleMembership(
+	        const RsGxsId& ownGxsId, const RsGxsCircleId& circleId ) = 0;
+
+	/**
+	 * @brief Leave given circle
+	 * @jsonapi{development}
+	 * @param[in] ownGxsId Own id to remove from the circle
+	 * @param[in] circleId Id of the circle to leave
+	 * @return false if something failed, true otherwhise
+	 */
+	virtual bool cancelCircleMembership(
+	        const RsGxsId& ownGxsId, const RsGxsCircleId& circleId ) = 0;
+
+	RS_DEPRECATED_FOR("getCirclesSummaries getCirclesInfo")
+	virtual bool getGroupData(
+	        const uint32_t& token, std::vector<RsGxsCircleGroup>& groups ) = 0;
+
+	RS_DEPRECATED_FOR(getCirclesRequests)
+	virtual bool getMsgData(
+	        const uint32_t& token, std::vector<RsGxsCircleMsg>& msgs ) = 0;
+
+	/// make new group
+	RS_DEPRECATED_FOR(createCircle)
 	virtual void createGroup(uint32_t& token, RsGxsCircleGroup &group) = 0;
 
-	/* update an existing group */
+	/// update an existing group
+	RS_DEPRECATED_FOR("editCircle, inviteIdsToCircle")
 	virtual void updateGroup(uint32_t &token, RsGxsCircleGroup &group) = 0;
 };
-
-
-
-#endif

libretroshare/src/retroshare/rsgxsifacetypes.h

@@ -90,7 +90,9 @@ struct RsGroupMetaData : RsSerializable
     rstime_t      mLastPost; 		// Timestamp for last message. Not used yet.
 
     uint32_t    mGroupStatus;
-    std::string mServiceString; // Service Specific Free-Form extra storage.
+
+	/// Service Specific Free-Form local (non-synced) extra storage.
+	std::string mServiceString;
     RsPeerId mOriginator;
     RsGxsCircleId mInternalCircle;
 

libretroshare/src/services/p3gxscircles.cc

@@ -153,7 +153,118 @@ RsServiceInfo p3GxsCircles::getServiceInfo()
                 GXS_CIRCLES_MIN_MINOR_VERSION);
 }
 
+bool p3GxsCircles::createCircle(RsGxsCircleGroup& cData)
+{
+	uint32_t token;
+	createGroup(token, cData);
 
+	if(waitToken(token) != RsTokenService::COMPLETE)
+	{
+		std::cerr << __PRETTY_FUNCTION__ << "Error! GXS operation failed."
+		          << std::endl;
+		return false;
+	}
+
+	if(!RsGenExchange::getPublishedGroupMeta(token, cData.mMeta))
+	{
+		std::cerr << __PRETTY_FUNCTION__ << "Error! Failure getting created"
+		          << " group data." << std::endl;
+		return false;
+	}
+
+	return true;
+}
+
+bool p3GxsCircles::editCircle(RsGxsCircleGroup& cData)
+{
+	uint32_t token;
+	updateGroup(token, cData);
+
+	if(waitToken(token) != RsTokenService::COMPLETE)
+	{
+		std::cerr << __PRETTY_FUNCTION__ << "Error! GXS operation failed."
+		          << std::endl;
+		return false;
+	}
+
+	if(!RsGenExchange::getPublishedGroupMeta(token, cData.mMeta))
+	{
+		std::cerr << __PRETTY_FUNCTION__ << "Error! Failure getting updated"
+		          << " group data." << std::endl;
+		return false;
+	}
+
+	return true;
+}
+
+bool p3GxsCircles::getCirclesSummaries(std::list<RsGroupMetaData>& circles)
+{
+	uint32_t token;
+	RsTokReqOptions opts;
+	opts.mReqType = GXS_REQUEST_TYPE_GROUP_META;
+	if( !requestGroupInfo(token, opts)
+	        || waitToken(token) != RsTokenService::COMPLETE ) return false;
+	return getGroupSummary(token, circles);
+}
+
+bool p3GxsCircles::getCirclesInfo( const std::list<RsGxsGroupId>& circlesIds,
+                                   std::vector<RsGxsCircleGroup>& circlesInfo )
+{
+	uint32_t token;
+	RsTokReqOptions opts;
+	opts.mReqType = GXS_REQUEST_TYPE_GROUP_DATA;
+	if( !requestGroupInfo(token, opts, circlesIds)
+	        || waitToken(token) != RsTokenService::COMPLETE ) return false;
+	return getGroupData(token, circlesInfo);
+}
+
+bool p3GxsCircles::getCircleRequests( const RsGxsGroupId& circleId,
+                                      std::vector<RsGxsCircleMsg>& requests )
+{
+	uint32_t token;
+	std::list<RsGxsGroupId> grpIds { circleId };
+	RsTokReqOptions opts;
+	opts.mReqType = GXS_REQUEST_TYPE_MSG_DATA;
+
+	if( !requestMsgInfo(token, opts, grpIds) ||
+	        waitToken(token) != RsTokenService::COMPLETE ) return false;
+
+	return getMsgData(token, requests);
+}
+
+bool p3GxsCircles::inviteIdsToCircle( const std::set<RsGxsId>& identities,
+                                      const RsGxsCircleId& circleId )
+{
+	const std::list<RsGxsGroupId> circlesIds{ RsGxsGroupId(circleId) };
+	std::vector<RsGxsCircleGroup> circlesInfo;
+
+	if(!getCirclesInfo(circlesIds, circlesInfo))
+	{
+		std::cerr << __PRETTY_FUNCTION__ << "Error! Failure getting group data."
+		          << std::endl;
+		return false;
+	}
+
+	if(circlesInfo.empty())
+	{
+		std::cerr << __PRETTY_FUNCTION__ << "Error! Circle: "
+		          << circleId.toStdString() << " not found!" << std::endl;
+		return false;
+	}
+
+	RsGxsCircleGroup& circleGrp = circlesInfo[0];
+
+	if(!(circleGrp.mMeta.mSubscribeFlags & GXS_SERV::GROUP_SUBSCRIBE_ADMIN))
+	{
+		std::cerr << __PRETTY_FUNCTION__ << "Error! Attempt to edit non-own "
+		          << "circle: " << circleId.toStdString() << std::endl;
+		return false;
+	}
+
+	circleGrp.mInvitedMembers.insert(identities.begin(), identities.end());
+
+	return editCircle(circleGrp);
+}
 
 uint32_t p3GxsCircles::circleAuthenPolicy()
 {
@@ -320,32 +431,6 @@ bool p3GxsCircles:: getCircleDetails(const RsGxsCircleId &id, RsGxsCircleDetails
     return false;
 }
 
-
-bool p3GxsCircles:: getCirclePersonalIdList(std::list<RsGxsCircleId> &circleIds)
-{
-#ifdef DEBUG_CIRCLES
-	std::cerr << "p3GxsCircles::getCircleIdList()";
-	std::cerr << std::endl;
-#endif // DEBUG_CIRCLES
-
-	RsStackMutex stack(mCircleMtx); /********** STACK LOCKED MTX ******/
-	if (circleIds.empty())
-	{
-		circleIds = mCirclePersonalIdList;
-	}
-	else
-	{
-		std::list<RsGxsCircleId>::const_iterator it;
-		for(it = mCirclePersonalIdList.begin(); it != mCirclePersonalIdList.begin(); ++it)
-		{
-			circleIds.push_back(*it);
-		}
-	}
-
-	return true;
-}
-
-
 bool p3GxsCircles:: getCircleExternalIdList(std::list<RsGxsCircleId> &circleIds)
 {
 #ifdef DEBUG_CIRCLES

libretroshare/src/services/p3gxscircles.h

@@ -179,9 +179,30 @@ virtual RsServiceInfo getServiceInfo();
 
 	/*********** External Interface ***************/
 
+	/// @see RsGxsCircles
+	bool createCircle(RsGxsCircleGroup& cData) override;
+
+	/// @see RsGxsCircles
+	bool editCircle(RsGxsCircleGroup& cData) override;
+
+	/// @see RsGxsCircles
+	bool getCirclesSummaries(std::list<RsGroupMetaData>& circles) override;
+
+	/// @see RsGxsCircles
+	bool getCirclesInfo(
+	        const std::list<RsGxsGroupId>& circlesIds,
+	        std::vector<RsGxsCircleGroup>& circlesInfo ) override;
+
+	/// @see RsGxsCircles
+	bool getCircleRequests( const RsGxsGroupId& circleId,
+	                        std::vector<RsGxsCircleMsg>& requests ) override;
+
+	/// @see RsGxsCircles
+	bool inviteIdsToCircle( const std::set<RsGxsId>& identities,
+	                        const RsGxsCircleId& circleId ) override;
+
 	virtual bool getCircleDetails(const RsGxsCircleId &id, RsGxsCircleDetails &details);
 	virtual bool getCircleExternalIdList(std::list<RsGxsCircleId> &circleIds);
-	virtual bool getCirclePersonalIdList(std::list<RsGxsCircleId> &circleIds);
 
 	virtual bool isLoaded(const RsGxsCircleId &circleId);
 	virtual bool loadCircle(const RsGxsCircleId &circleId);
@@ -257,6 +278,8 @@ virtual RsServiceInfo getServiceInfo();
     // put a circle id into the external or personal circle id list
     // this function locks the mutex
     // if the id is already in the list, it will not be added again
+	// G10h4ck: this is terrible, an std::set instead of a list should be used
+	//	to guarantee uniqueness
     void addCircleIdToList(const RsGxsCircleId& circleId, uint32_t circleType);
 
 	RsMutex mCircleMtx; /* Locked Below Here */

retroshare.pri

@@ -241,6 +241,7 @@ rs_v07_changes {
     DEFINES += V07_NON_BACKWARD_COMPATIBLE_CHANGE_001
     DEFINES += V07_NON_BACKWARD_COMPATIBLE_CHANGE_002
     DEFINES += V07_NON_BACKWARD_COMPATIBLE_CHANGE_003
+    DEFINES += V07_NON_BACKWARD_COMPATIBLE_CHANGE_UNNAMED
 }
 
 ################################################################################