Implementation of GxsId Opinion, and start of Reputation system.

- Removed old reputation system from p3idservice
 - Removed old Msg types as well (no longer needed)
 - Added real submitOpinion()
 - Modified serviceString to support Reputation System.
 - Added reputation information to both Cached Data, and Standard ID Data.
 - Added basics of new reputation system as alternative service. (not gxs).
 - Added Generic TLV types for maps.
 - Moved configuration files to their own directory .rs/config/
 - Finally, fixed up bits missed from the change to updateGroup!



git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@7131 b45a01b8-16f6-495d-af2f-9b41ad6348cc

libretroshare/src/services/p3gxschannels.cc

@@ -805,18 +805,14 @@ bool p3GxsChannels::createGroup(uint32_t &token, RsGxsChannelGroup &group)
 }
 
 
-bool p3GxsChannels::updateGroup(uint32_t &token, RsGxsGroupUpdateMeta& meta, RsGxsChannelGroup &group)
+bool p3GxsChannels::updateGroup(uint32_t &token, RsGxsChannelGroup &group)
 {
 	std::cerr << "p3GxsChannels::updateGroup()" << std::endl;
 
-	if(meta.getGroupId().empty())
-		return false;
-
 	RsGxsChannelGroupItem* grpItem = new RsGxsChannelGroupItem();
 	grpItem->fromChannelGroup(group, true);
-	grpItem->meta.mGroupId = meta.getGroupId();
 
-	RsGenExchange::updateGroup(token, meta, grpItem);
+	RsGenExchange::updateGroup(token, grpItem);
 	return true;
 }
 

libretroshare/src/services/p3gxschannels.h

@@ -92,7 +92,7 @@ virtual bool getRelatedPosts(const uint32_t &token, std::vector<RsGxsChannelPost
 virtual bool createGroup(uint32_t &token, RsGxsChannelGroup &group);
 virtual bool createPost(uint32_t &token, RsGxsChannelPost &post);
 
-virtual bool updateGroup(uint32_t &token, RsGxsGroupUpdateMeta& meta, RsGxsChannelGroup &group);
+virtual bool updateGroup(uint32_t &token, RsGxsChannelGroup &group);
 
 // no tokens... should be cached.
 virtual bool setChannelAutoDownload(const RsGxsGroupId &groupId, bool enabled);

libretroshare/src/services/p3gxsforums.cc

@@ -215,19 +215,15 @@ bool p3GxsForums::createGroup(uint32_t &token, RsGxsForumGroup &group)
 	return true;
 }
 
-bool p3GxsForums::updateGroup(uint32_t &token, RsGxsGroupUpdateMeta& meta, RsGxsForumGroup &group)
+bool p3GxsForums::updateGroup(uint32_t &token, RsGxsForumGroup &group)
 {
 	std::cerr << "p3GxsForums::updateGroup()" << std::endl;
 
-        if(meta.getGroupId().empty())
-		return false;
-
 	RsGxsForumGroupItem* grpItem = new RsGxsForumGroupItem();
 	grpItem->mGroup = group;
         grpItem->meta = group.mMeta;
-        grpItem->meta.mGroupId = meta.getGroupId();
 
-       // RsGenExchange::updateGroup(token, meta, grpItem);
+        RsGenExchange::updateGroup(token, grpItem);
 	return true;
 }
 

libretroshare/src/services/p3gxsforums.h

@@ -80,7 +80,7 @@ virtual bool createMsg(uint32_t &token, RsGxsForumMsg &msg);
  * @param group group to be updated, groupId element must be set or will be rejected
  * @return false groupId not set, true if set and accepted (still check token for completion)
  */
-virtual bool updateGroup(uint32_t &token, RsGxsGroupUpdateMeta& meta, RsGxsForumGroup &group);
+virtual bool updateGroup(uint32_t &token, RsGxsForumGroup &group);
 
 
 	private:

libretroshare/src/services/p3gxsreputation.cc

@@ -0,0 +1,658 @@
+/*
+ * libretroshare/src/services p3gxsreputation.cc
+ *
+ * Gxs Reputation Service  for RetroShare.
+ *
+ * Copyright 2011-2014 by Robert Fernie.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License Version 2.1 as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA.
+ *
+ * Please report all bugs and problems to "retroshare@lunamutt.com".
+ *
+ */
+
+#include "pqi/p3linkmgr.h"
+
+#include "retroshare/rspeers.h"
+
+#include "services/p3gxsreputation.h"
+#include "serialiser/rsgxsreputationitems.h"
+
+#include <sys/time.h>
+
+#include <set>
+
+/****
+ * #define DEBUG_REPUTATION		1
+ ****/
+
+
+/* DEFINE INTERFACE POINTER! */
+//RsGxsReputation *rsGxsReputation = NULL;
+
+const int kMaximumPeerAge =	180; // half a year.
+const int kMaximumSetSize = 	100;
+
+/************ IMPLEMENTATION NOTES *********************************
+ * 
+ * p3GxsReputation shares opinions / reputations with peers.
+ * This is closely linked to p3IdService, receiving info, updating
+ * reputations as needed.
+ *
+ * It is designed as separate service as the exchange of peer opinions
+ * is not well suited to Gxs Groups / Messages...
+ *
+ * Instead we can broadcast opinions to all peers.
+ *
+ * To avoid too much traffic, changes are transmitted rather than whole lists.
+ * Peer A		   Peer B
+ *  last update ----------->
+ *	<----------- modified opinions.
+ *
+ * This service will have to store a huge amount of data.
+ * need to workout how to reduce it.
+ *
+ * std::map<RsGxsId, Reputation> mReputations.
+ * std::multimap<time_t, RsGxsId> mUpdated.
+ *
+ * std::map<RsPeerId, ReputationConfig> mConfig;
+ *
+ * Updates from p3GxsReputation -> p3IdService.
+ *
+ *
+ * Updates from p3IdService -> p3GxsReputation.
+ *
+ *
+ */
+
+const int32_t REPUTATION_OFFSET		= 100000;
+const int32_t LOWER_LIMIT		= -100;
+const int32_t UPPER_LIMIT		= 100;
+
+int32_t ConvertFromSerialised(uint32_t value, bool limit)
+{
+	int32_t converted = ((int32_t) value) - REPUTATION_OFFSET ;
+	if (limit)
+	{
+		if (converted < LOWER_LIMIT)
+		{
+			converted = LOWER_LIMIT;
+		}
+		if (converted > UPPER_LIMIT)
+		{
+			converted = UPPER_LIMIT;
+		}
+	}
+	return converted;
+}
+
+uint32_t ConvertToSerialised(int32_t value, bool limit)
+{
+	if (limit)
+	{
+		if (value < LOWER_LIMIT)
+		{
+			value = LOWER_LIMIT;
+		}
+		if (value > UPPER_LIMIT)
+		{
+			value = UPPER_LIMIT;
+		}
+	}
+
+	value += REPUTATION_OFFSET;
+	if (value < 0)
+	{
+		value = 0;
+	}
+	return (uint32_t) value;
+}
+
+
+
+p3GxsReputation::p3GxsReputation(p3LinkMgr *lm)
+	:p3Service(RS_SERVICE_GXSV2_TYPE_REPUTATION), p3Config(CONFIG_TYPE_GXS_REPUTATION),
+	mReputationMtx("p3GxsReputation"), mLinkMgr(lm) 
+{
+	addSerialType(new RsGxsReputationSerialiser());
+
+	mRequestTime = 0;
+	mStoreTime = 0;
+	mReputationsUpdated = false;
+}
+
+
+int	p3GxsReputation::tick()
+{
+	processIncoming();
+	sendPackets();
+
+	return 0;
+}
+
+int	p3GxsReputation::status()
+{
+	return 1;
+}
+
+
+/***** Implementation ******/
+
+bool p3GxsReputation::processIncoming()
+{
+	/* for each packet - pass to specific handler */
+	RsItem *item = NULL;
+	while(NULL != (item = recvItem()))
+	{
+#ifdef DEBUG_REPUTATION
+		std::cerr << "p3GxsReputation::processingIncoming() Received Item:";
+		std::cerr << std::endl;
+		item->print(std::cerr);
+		std::cerr << std::endl;
+#endif
+		bool itemOk = true;
+		switch(item->PacketSubType())
+		{
+			default:
+			case RS_PKT_SUBTYPE_GXSREPUTATION_CONFIG_ITEM:
+			case RS_PKT_SUBTYPE_GXSREPUTATION_SET_ITEM:
+				std::cerr << "p3GxsReputation::processingIncoming() Unknown Item";
+				std::cerr << std::endl;
+				itemOk = false;
+				break;
+
+			case RS_PKT_SUBTYPE_GXSREPUTATION_REQUEST_ITEM:
+			{
+				RsGxsReputationRequestItem *requestItem = 
+					dynamic_cast<RsGxsReputationRequestItem *>(item);
+				if (requestItem)
+				{
+					SendReputations(requestItem);
+				}
+				else
+				{
+					itemOk = false;
+				}
+			}
+				break;
+
+			case RS_PKT_SUBTYPE_GXSREPUTATION_UPDATE_ITEM:
+			{
+				RsGxsReputationUpdateItem *updateItem = 
+					dynamic_cast<RsGxsReputationUpdateItem *>(item);
+				if (updateItem)
+				{
+					RecvReputations(updateItem);
+				}
+				else
+				{
+					itemOk = false;
+				}
+			}
+				break;
+		}
+
+		if (!itemOk)
+		{
+			std::cerr << "p3GxsReputation::processingIncoming() Error with Item";
+			std::cerr << std::endl;
+		}
+
+		/* clean up */
+		delete item;
+	}
+	return true ;
+} 
+	
+
+bool p3GxsReputation::SendReputations(RsGxsReputationRequestItem *request)
+{
+	std::cerr << "p3GxsReputation::SendReputations()";
+	std::cerr << std::endl;
+
+	RsPeerId peerId = request->PeerId();
+	time_t last_update = request->mLastUpdate;
+	time_t now = time(NULL);
+
+	RsStackMutex stack(mReputationMtx); /****** LOCKED MUTEX *******/
+
+	std::multimap<time_t, RsGxsId>::iterator tit;
+	tit = mUpdated.upper_bound(last_update); // could skip some - (fixed below).
+
+	int count = 0;
+	int totalcount = 0;
+	RsGxsReputationUpdateItem *pkt = new RsGxsReputationUpdateItem();
+	pkt->PeerId(peerId);
+	for(;tit != mUpdated.end(); tit++)
+	{
+		/* find */
+		std::map<RsGxsId, Reputation>::iterator rit;
+		rit = mReputations.find(tit->second);
+		if (rit == mReputations.end())
+		{
+			std::cerr << "p3GxsReputation::SendReputations() ERROR Missing Reputation";
+			std::cerr << std::endl;
+			// error.
+			continue;
+		}
+
+		if (rit->second.mOwnOpinionTs == 0)
+		{
+			std::cerr << "p3GxsReputation::SendReputations() ERROR OwnOpinionTS = 0";
+			std::cerr << std::endl;
+			// error.
+			continue;
+		}
+
+		pkt->mOpinions[rit->first] = ConvertToSerialised(rit->second.mOwnOpinion, true);
+		pkt->mLatestUpdate = rit->second.mOwnOpinionTs;
+		if (pkt->mLatestUpdate == (uint32_t) now)
+		{
+			// if we could possibly get another Update at this point (same second).
+			// then set Update back one second to ensure there are none missed.
+			pkt->mLatestUpdate--;
+		}
+		
+		count++;
+		totalcount++;
+
+		if (count > kMaximumSetSize)
+		{
+			std::cerr << "p3GxsReputation::SendReputations() Sending Full Packet";
+			std::cerr << std::endl;
+
+			sendItem(pkt);
+			pkt = new RsGxsReputationUpdateItem();
+			pkt->PeerId(peerId);
+			count = 0;
+		}
+	}
+
+	if (!pkt->mOpinions.empty())
+	{
+		std::cerr << "p3GxsReputation::SendReputations() Sending Final Packet";
+		std::cerr << std::endl;
+
+		sendItem(pkt);
+	}
+	else
+	{
+		delete pkt;
+	}
+
+	std::cerr << "p3GxsReputation::SendReputations() Total Count: " << totalcount;
+	std::cerr << std::endl;
+
+	return true;
+}
+
+
+bool p3GxsReputation::RecvReputations(RsGxsReputationUpdateItem *item)
+{
+	std::cerr << "p3GxsReputation::RecvReputations()";
+	std::cerr << std::endl;
+
+	RsPeerId peerid = item->PeerId();
+
+	std::map<std::string, uint32_t>::iterator it;
+	for(it = item->mOpinions.begin(); it != item->mOpinions.end(); it++)
+	{
+		RsStackMutex stack(mReputationMtx); /****** LOCKED MUTEX *******/
+
+		/* find matching Reputation */
+		std::map<RsGxsId, Reputation>::iterator rit;
+		rit = mReputations.find(it->first);
+		if (rit == mReputations.end())
+		{
+			mReputations[it->first] = Reputation(it->first);
+			rit = mReputations.find(it->first);
+		}
+
+		Reputation &reputation = rit->second;
+		reputation.mOpinions[peerid] = ConvertFromSerialised(it->second, true);
+
+		int previous = reputation.mReputation;
+		if (previous != reputation.CalculateReputation())
+		{
+			// updated from the network.
+			mUpdatedReputations.insert(it->first);
+		}
+	}
+	updateLatestUpdate(peerid, item->mLatestUpdate);
+	return true;
+}
+
+
+bool p3GxsReputation::updateLatestUpdate(RsPeerId peerid, time_t ts)
+{
+	RsStackMutex stack(mReputationMtx); /****** LOCKED MUTEX *******/
+
+	std::map<RsPeerId, ReputationConfig>::iterator it;
+	it = mConfig.find(peerid);
+	if (it != mConfig.end())
+	{
+		mConfig[peerid] = ReputationConfig(peerid);
+	}
+	it->second.mLatestUpdate = ts;
+
+	mReputationsUpdated = true;	
+	// Switched to periodic save due to scale of data.
+	//IndicateConfigChanged();		
+
+	return true;
+}
+
+/********************************************************************
+ * Opinion
+ ****/
+
+bool p3GxsReputation::updateOpinion(const RsGxsId& gxsid, int opinion)
+{
+	RsStackMutex stack(mReputationMtx); /****** LOCKED MUTEX *******/
+
+	std::map<RsGxsId, Reputation>::iterator rit;
+
+	/* find matching Reputation */
+	rit = mReputations.find(gxsid);
+	if (rit == mReputations.end())
+	{
+		mReputations[gxsid] = Reputation(gxsid);
+		rit = mReputations.find(gxsid);
+	}
+
+	// we should remove previous entries from Updates...
+	Reputation &reputation = rit->second;
+	if (reputation.mOwnOpinionTs != 0)
+	{
+		if (reputation.mOwnOpinion == opinion)
+		{
+			// if opinion is accurate, don't update.
+			return false;
+		}
+
+		std::multimap<time_t, RsGxsId>::iterator uit, euit;
+		uit = mUpdated.lower_bound(reputation.mOwnOpinionTs);
+		euit = mUpdated.upper_bound(reputation.mOwnOpinionTs);
+		for(; uit != euit; uit++)
+		{
+			if (uit->second == gxsid)
+			{
+				mUpdated.erase(uit);
+				break;
+			}
+		}
+	}
+
+	time_t now = time(NULL);
+	reputation.mOwnOpinion = opinion;
+	reputation.mOwnOpinionTs = now;
+	reputation.CalculateReputation();
+
+	mUpdated.insert(std::make_pair(now, gxsid));
+	mUpdatedReputations.insert(gxsid);
+
+	mReputationsUpdated = true;	
+	// Switched to periodic save due to scale of data.
+	//IndicateConfigChanged();		
+	return true;
+}
+
+
+/********************************************************************
+ * Configuration.
+ ****/
+
+RsSerialiser *p3GxsReputation::setupSerialiser()
+{
+        RsSerialiser *rss = new RsSerialiser ;
+	rss->addSerialType(new RsGxsReputationSerialiser());
+        return rss ;
+}
+
+bool p3GxsReputation::saveList(bool& cleanup, std::list<RsItem*> &savelist)
+{
+	cleanup = true;
+	RsStackMutex stack(mReputationMtx); /****** LOCKED MUTEX *******/
+
+	/* save */
+	std::map<RsPeerId, ReputationConfig>::iterator it;
+	for(it = mConfig.begin(); it != mConfig.end(); it++)
+	{
+		if (!rsPeers->isFriend(it->first))
+		{
+			// discard info from non-friends.
+			continue;
+		}
+
+		RsGxsReputationConfigItem *item = new RsGxsReputationConfigItem();
+		item->mPeerId = it->first;
+		item->mLatestUpdate = it->second.mLatestUpdate;
+		item->mLastQuery = it->second.mLastQuery;
+		savelist.push_back(item);
+	}
+
+	int count = 0;
+ 	std::map<RsGxsId, Reputation>::iterator rit;
+	for(rit = mReputations.begin(); rit != mReputations.end(); rit++, count++)
+	{
+		RsGxsReputationSetItem *item = new RsGxsReputationSetItem();
+		item->mGxsId = rit->first;
+		item->mOwnOpinion = ConvertToSerialised(rit->second.mOwnOpinion, false);
+		item->mOwnOpinionTs = rit->second.mOwnOpinionTs;
+		item->mReputation = ConvertToSerialised(rit->second.mReputation, false);
+
+		std::map<RsPeerId, int32_t>::iterator oit;
+		for(oit = rit->second.mOpinions.begin(); oit != rit->second.mOpinions.end(); ++oit)
+		{
+			// should be already limited.
+			item->mOpinions[oit->first] = ConvertToSerialised(oit->second, false);
+		}
+
+		savelist.push_back(item);
+		count++;
+	}
+	return true;
+}
+
+void p3GxsReputation::saveDone()
+{
+	return;
+}
+
+bool p3GxsReputation::loadList(std::list<RsItem *>& loadList)
+{
+	std::list<RsItem *>::iterator it;
+	std::set<std::string> peerSet;
+
+	for(it = loadList.begin(); it != loadList.end(); it++)
+	{
+		RsGxsReputationConfigItem *item = dynamic_cast<RsGxsReputationConfigItem *>(*it);
+		// Configurations are loaded first. (to establish peerSet).
+		if (item)
+		{
+			RsStackMutex stack(mReputationMtx); /****** LOCKED MUTEX *******/
+			ReputationConfig &config = mConfig[item->mPeerId];
+			config.mPeerId = item->mPeerId;
+			config.mLatestUpdate = item->mLatestUpdate;
+			config.mLastQuery = 0;
+			
+			peerSet.insert(item->mPeerId);
+		}
+		RsGxsReputationSetItem *set = dynamic_cast<RsGxsReputationSetItem *>(*it);
+		if (set)
+		{
+			loadReputationSet(set, peerSet);
+		}
+		delete (*it);
+	}
+
+	return true;
+}
+
+bool p3GxsReputation::loadReputationSet(RsGxsReputationSetItem *item, const std::set<std::string> &peerSet)
+{
+	RsStackMutex stack(mReputationMtx); /****** LOCKED MUTEX *******/
+
+	std::map<RsGxsId, Reputation>::iterator rit;
+
+	/* find matching Reputation */
+	rit = mReputations.find(item->mGxsId);
+	if (rit != mReputations.end())
+	{
+		std::cerr << "ERROR";
+		std::cerr << std::endl;
+	}
+
+	Reputation &reputation = mReputations[item->mGxsId];
+
+	// install opinions.
+	std::map<std::string, uint32_t>::const_iterator oit;
+	for(oit = item->mOpinions.begin(); oit != item->mOpinions.end(); oit++)
+	{
+		// expensive ... but necessary.
+		if (peerSet.end() != peerSet.find(oit->first))
+		{
+			reputation.mOpinions[oit->first] = ConvertFromSerialised(oit->second, true);
+		}
+	}
+
+	reputation.mOwnOpinion = ConvertFromSerialised(item->mOwnOpinion, false);
+	reputation.mOwnOpinionTs = item->mOwnOpinionTs;
+
+	// if dropping entries has changed the score -> must update.
+	int previous = ConvertFromSerialised(item->mReputation, false);
+	if (previous != reputation.CalculateReputation())
+	{
+		mUpdatedReputations.insert(item->mGxsId);
+	}
+
+	mUpdated.insert(std::make_pair(reputation.mOwnOpinionTs, item->mGxsId));
+	return true;
+}
+
+
+/********************************************************************
+ * Send Requests.
+ ****/
+
+const int kReputationRequestPeriod	= 	3600;
+const int kReputationStoreWait		= 	180; // 3 minutes.
+
+int	p3GxsReputation::sendPackets()
+{
+	time_t now = time(NULL);
+	time_t requestTime, storeTime;
+	{
+		RsStackMutex stack(mReputationMtx); /****** LOCKED MUTEX *******/
+		requestTime = mRequestTime;
+		storeTime = mStoreTime;
+	}
+
+	if (now - requestTime > kReputationRequestPeriod)
+	{
+		sendReputationRequests();
+
+		RsStackMutex stack(mReputationMtx); /****** LOCKED MUTEX *******/
+
+#ifdef DEBUG_REPUTATION
+		std::cerr << "p3GxsReputation::sendPackets() Regular Broadcast";
+		std::cerr << std::endl;
+#endif
+		mRequestTime = now;
+		mStoreTime = now + kReputationStoreWait;
+	}
+
+	if (now > storeTime)
+	{
+		RsStackMutex stack(mReputationMtx); /****** LOCKED MUTEX *******/
+
+#ifdef DEBUG_REPUTATION
+		std::cerr << "p3GxsReputation::sendPackets() Regular Broadcast";
+		std::cerr << std::endl;
+#endif
+		// push it into the future.
+		// store time will be reset when requests are send.
+		mStoreTime = now + kReputationRequestPeriod;
+
+		if (mReputationsUpdated)
+		{
+			IndicateConfigChanged();
+			mReputationsUpdated = false;
+		}
+	}
+
+	return true ;
+}
+
+void p3GxsReputation::sendReputationRequests()
+{
+	/* we ping our peers */
+	/* who is online? */
+	std::list<RsPeerId> idList;
+
+	mLinkMgr->getOnlineList(idList);
+
+#ifdef DEBUG_REPUTATION
+	std::cerr << "p3GxsReputation::sendReputationRequests()";
+	std::cerr << std::endl;
+#endif
+
+	/* prepare packets */
+	std::list<std::string>::iterator it;
+	for(it = idList.begin(); it != idList.end(); it++)
+	{
+#ifdef DEBUG_REPUTATION
+		std::cerr << "p3GxsReputation::sendReputationRequest() To: " << *it;
+		std::cerr << std::endl;
+#endif
+		sendReputationRequest(*it);
+	}
+}
+
+
+
+int p3GxsReputation::sendReputationRequest(RsPeerId peerid)
+{
+	std::cerr << "p3GxsReputation::sendReputationRequest(" << peerid << ")";
+	std::cerr << std::endl;
+
+	/* */
+	RsGxsReputationRequestItem *requestItem = 
+		new RsGxsReputationRequestItem();
+
+	requestItem->PeerId(peerid);
+
+	{
+		RsStackMutex stack(mReputationMtx); /****** LOCKED MUTEX *******/
+
+		/* find the last timestamp we have */
+		std::map<RsPeerId, ReputationConfig>::iterator it;
+		it = mConfig.find(peerid);
+		if (it != mConfig.end())
+		{
+			requestItem->mLastUpdate = it->second.mLatestUpdate;
+		}
+		else
+		{
+			// get whole list.
+			requestItem->mLastUpdate = 0;
+		}
+	}
+
+	sendItem(requestItem);
+	return 1;
+}
+
+

libretroshare/src/services/p3gxsreputation.h

@@ -0,0 +1,155 @@
+/*
+ * libretroshare/src/services/p3gxsreputation.h
+ *
+ * Exchange list of Peers Reputations.
+ *
+ * Copyright 2014 by Robert Fernie.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License Version 2.1 as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA.
+ *
+ * Please report all bugs and problems to "retroshare@lunamutt.com".
+ *
+ */
+
+
+#ifndef SERVICE_RSGXSREPUTATION_HEADER
+#define SERVICE_RSGXSREPUTATION_HEADER
+
+#include <string>
+#include <list>
+#include <map>
+#include <set>
+
+#include "serialiser/rsgxsreputationitems.h"
+
+#include "retroshare/rsidentity.h"
+#include "services/p3service.h"
+
+typedef std::string RsPeerId;
+
+class p3LinkMgr;
+
+class ReputationConfig
+{
+public:
+	ReputationConfig()
+	:mPeerId(), mLatestUpdate(0) { return; }
+
+	ReputationConfig(const RsPeerId& peerId)
+	:mPeerId(peerId), mLatestUpdate(0) { return; }
+
+	RsPeerId mPeerId;
+	time_t mLatestUpdate;
+	time_t mLastQuery;
+};
+
+class Reputation
+{
+public:
+	Reputation()
+	:mOwnOpinion(0) { return; }
+
+	Reputation(const RsGxsId& about)
+	:mGxsId(about), mOwnOpinion(0) { return; }
+
+int32_t CalculateReputation();
+
+	RsGxsId mGxsId;
+	std::map<RsPeerId, int32_t> mOpinions;
+	int32_t mOwnOpinion;
+	time_t  mOwnOpinionTs;
+
+	int32_t mReputation;
+};
+
+
+//!The p3GxsReputation service.
+ /**
+  *
+  * 
+  */
+
+class p3GxsReputation: public p3Service, public p3Config /* , public pqiMonitor */
+{
+	public:
+		p3GxsReputation(p3LinkMgr *lm);
+
+		/***** Interface for p3idservice *****/
+
+		virtual bool updateOpinion(const RsGxsId& gxsid, int opinion);
+
+		/***** overloaded from p3Service *****/
+		/*!
+		 * This retrieves all chat msg items and also (important!)
+		 * processes chat-status items that are in service item queue. chat msg item requests are also processed and not returned
+		 * (important! also) notifications sent to notify base  on receipt avatar, immediate status and custom status
+		 * : notifyCustomState, notifyChatStatus, notifyPeerHasNewAvatar
+		 * @see NotifyBase
+
+		 */
+		virtual int   tick();
+		virtual int   status();
+
+
+		/*!
+		 * Interface stuff.
+		 */
+
+		/*************** pqiMonitor callback ***********************/
+		//virtual void statusChange(const std::list<pqipeer> &plist);
+
+
+		/************* from p3Config *******************/
+		virtual RsSerialiser *setupSerialiser() ;
+		virtual bool saveList(bool& cleanup, std::list<RsItem*>&) ;
+		virtual void saveDone();
+		virtual bool loadList(std::list<RsItem*>& load) ;
+
+	private:
+
+		bool 	processIncoming();
+
+		bool SendReputations(RsGxsReputationRequestItem *request);
+		bool RecvReputations(RsGxsReputationUpdateItem *item);
+		bool updateLatestUpdate(RsPeerId peerid, time_t ts);
+
+		bool loadReputationSet(RsGxsReputationSetItem *item, 
+				const std::set<std::string> &peerSet);
+
+		int     sendPackets();
+		void sendReputationRequests();
+		int sendReputationRequest(RsPeerId peerid);
+
+
+	private:
+		RsMutex mReputationMtx;
+
+		time_t mRequestTime;
+		time_t mStoreTime;
+		bool   mReputationsUpdated;
+
+		p3LinkMgr *mLinkMgr;
+
+		// Data for Reputation.
+		std::map<RsPeerId, ReputationConfig> mConfig;
+		std::map<RsGxsId, Reputation> mReputations;
+		std::multimap<time_t, RsGxsId> mUpdated;
+
+		// set of Reputations to send to p3IdService.
+		std::set<RsGxsId> mUpdatedReputations;
+};
+
+#endif //SERVICE_RSGXSREPUTATION_HEADER
+

libretroshare/src/services/p3idservice.h

@@ -49,6 +49,39 @@
  *
  */
 
+#if 0
+class GxsReputation
+{
+	public:
+	GxsReputation();
+
+	bool updateIdScore(bool pgpLinked, bool pgpKnown);
+	bool update();    // checks ranges and calculates overall score.
+	int mOverallScore;
+	int mIdScore;      // PGP, Known, etc.
+	int mOwnOpinion;
+	int mPeerOpinion;
+};
+
+#endif
+
+class OpinionRequest
+{
+	public:
+	OpinionRequest(uint32_t token, RsGxsId id, bool absOpinion, int32_t score)
+	:mToken(token), mId(id), mAbsOpinion(absOpinion), mScore(score)
+	{ return; }
+	OpinionRequest()
+	:mToken(0), mId(), mAbsOpinion(false), mScore(0)
+	{ return; }
+
+	uint32_t mToken;
+	RsGxsId    mId;
+	bool     mAbsOpinion;
+	int32_t	 mScore;
+};
+
+
 // INTERNAL DATA TYPES. 
 // Describes data stored in GroupServiceString.
 
@@ -97,16 +130,16 @@ virtual	std::string save() const;
 };
 
 
-class SSGxsIdScore: public SSBit 
+class SSGxsIdReputation: public SSBit 
 {
 	public:
-	SSGxsIdScore()
-	:score(0) { return; }
+	SSGxsIdReputation()
+	:rep() { return; }
 
 virtual	bool load(const std::string &input);
 virtual	std::string save() const;
 
-	int score;
+	GxsReputation rep;
 };
 
 class SSGxsIdCumulator: public SSBit
@@ -141,7 +174,9 @@ virtual	std::string save() const;
 	SSGxsIdRecognTags recogntags;	
 
 	// reputation score.	
-	SSGxsIdScore    score;
+	SSGxsIdReputation  score;
+
+	// These are depreciated (will load, but not save)
 	SSGxsIdCumulator opinion;
 	SSGxsIdCumulator reputation;
 
@@ -173,16 +208,6 @@ void	updateServiceString(std::string serviceString);
 };
 
 
-#if 0
-class LruData
-{
-	public:
-	RsGxsId key;
-};
-#endif
-
-	
-
 // Not sure exactly what should be inherited here?
 // Chris - please correct as necessary.
 
@@ -208,12 +233,12 @@ static	uint32_t idAuthenPolicy();
 
 	// These are exposed via RsIdentity.
 virtual bool getGroupData(const uint32_t &token, std::vector<RsGxsIdGroup> &groups);
-virtual bool getMsgData(const uint32_t &token, std::vector<RsGxsIdOpinion> &opinions);
+//virtual bool getMsgData(const uint32_t &token, std::vector<RsGxsIdOpinion> &opinions);
 
 	// These are local - and not exposed via RsIdentity.
 virtual bool createGroup(uint32_t& token, RsGxsIdGroup &group);
 virtual bool updateGroup(uint32_t& token, RsGxsIdGroup &group);
-virtual bool createMsg(uint32_t& token, RsGxsIdOpinion &opinion);
+//virtual bool createMsg(uint32_t& token, RsGxsIdOpinion &opinion);
 
 	/**************** RsIdentity External Interface.
 	 * Notes:
@@ -232,7 +257,8 @@ virtual bool  getOwnIds(std::list<RsGxsId> &ownIds);
 
 
         // 
-virtual bool submitOpinion(uint32_t& token, RsIdOpinion &opinion);
+virtual bool submitOpinion(uint32_t& token, const RsGxsId &id, 
+				bool absOpinion, int score);
 virtual bool createIdentity(uint32_t& token, RsIdentityParameters &params);
 
 virtual bool updateIdentity(uint32_t& token, RsGxsIdGroup &group);
@@ -369,6 +395,18 @@ virtual void handle_event(uint32_t event_type, const std::string &elabel);
 
 	void loadRecognKeys();
 
+
+/************************************************************************
+ * opinion processing.
+ *
+ */
+
+	bool opinion_handlerequest(uint32_t token);
+
+	/* MUTEX PROTECTED DATA */
+	std::map<uint32_t, OpinionRequest> mPendingOpinion;
+
+
 	/************************************************************************
 	 * for getting identities that are not present
 	 *
@@ -398,6 +436,7 @@ virtual void generateDummyData();
 
 std::string genRandomId(int len = 20);
 
+#if 0
 	bool reputation_start();
 	bool reputation_continue();
 
@@ -410,9 +449,11 @@ std::string genRandomId(int len = 20);
 	bool background_processFullCalc();
 	
 	bool background_cleanup();
+#endif
 
 	RsMutex mIdMtx;
 
+#if 0
 	/***** below here is locked *****/
 	bool mLastBgCheck;
 	bool mBgProcessing;
@@ -422,6 +463,7 @@ std::string genRandomId(int len = 20);
 	
 	std::map<std::string, RsGroupMetaData> mBgGroupMap;
 	std::list<std::string> mBgFullCalcGroups;
+#endif
 
 /************************************************************************
  * Other Data that is protected by the Mutex.

libretroshare/src/services/p3posted.cc

@@ -219,19 +219,15 @@ bool p3Posted::createGroup(uint32_t &token, RsPostedGroup &group)
 }
 
 
-bool p3Posted::updateGroup(uint32_t &token, RsGxsGroupUpdateMeta& meta, RsPostedGroup &group)
+bool p3Posted::updateGroup(uint32_t &token, RsPostedGroup &group)
 {
 	std::cerr << "p3Posted::updateGroup()" << std::endl;
 
-	if(meta.getGroupId().empty())
-		return false;
-
 	RsGxsPostedGroupItem* grpItem = new RsGxsPostedGroupItem();
 	grpItem->mGroup = group;
 	grpItem->meta = group.mMeta;
-	grpItem->meta.mGroupId = meta.getGroupId();
 
-	RsGenExchange::updateGroup(token, meta, grpItem);
+	RsGenExchange::updateGroup(token, grpItem);
 	return true;
 }
 

libretroshare/src/services/p3posted.h

@@ -68,7 +68,7 @@ virtual bool getRelatedPosts(const uint32_t &token, std::vector<RsPostedPost> &p
 virtual bool createGroup(uint32_t &token, RsPostedGroup &group);
 virtual bool createPost(uint32_t &token, RsPostedPost &post);
 
-virtual bool updateGroup(uint32_t &token, RsGxsGroupUpdateMeta& meta, RsPostedGroup &group);
+virtual bool updateGroup(uint32_t &token, RsPostedGroup &group);
 
         //////////////////////////////////////////////////////////////////////////////
 	// WRAPPERS due to the separate Interface.

libretroshare/src/services/p3wiki.cc

@@ -299,19 +299,15 @@ bool p3Wiki::submitComment(uint32_t &token, RsWikiComment &comment)
 	return true;
 }
 
-bool p3Wiki::updateCollection(uint32_t &token, RsGxsGroupUpdateMeta& meta, RsWikiCollection &group)
+bool p3Wiki::updateCollection(uint32_t &token, RsWikiCollection &group)
 {
         std::cerr << "p3Wiki::updateCollection()" << std::endl;
 
-        if(meta.getGroupId().empty())
-                return false;
-
         RsGxsWikiCollectionItem* grpItem = new RsGxsWikiCollectionItem();
         grpItem->collection = group;
         grpItem->meta = group.mMeta;
-        grpItem->meta.mGroupId = meta.getGroupId();
 
-        RsGenExchange::updateGroup(token, meta, grpItem);
+        RsGenExchange::updateGroup(token, grpItem);
         return true;
 }
 

libretroshare/src/services/p3wiki.h

@@ -69,7 +69,7 @@ virtual bool submitCollection(uint32_t &token, RsWikiCollection &collection);
 virtual bool submitSnapshot(uint32_t &token, RsWikiSnapshot &snapshot);
 virtual bool submitComment(uint32_t &token, RsWikiComment &comment);
 
-virtual bool updateCollection(uint32_t &token, RsGxsGroupUpdateMeta& meta, RsWikiCollection &collection);
+virtual bool updateCollection(uint32_t &token, RsWikiCollection &collection);
 
 	private: