Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-08-09 12:08:54 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Merge pull request #4507 from birarda/friends-only-location

Browse source 
make friends-only discoverability mode work as described
This commit is contained in:
Ryan Huffman 2015-03-25 13:48:08 -07:00
commit 1c0e7e26a2
6 changed files with 78 additions and 91 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
domain-server/src/DomainServer.cpp
View file

@ -814,8 +814,9 @@ void DomainServer::requestUserPublicKey(const QString& username) {
qDebug() << "Requesting public key for user" << username; qDebug() << "Requesting public key for user" << username;
AccountManager::getInstance().unauthenticatedRequest(USER_PUBLIC_KEY_PATH.arg(username), AccountManager::getInstance().sendRequest(USER_PUBLIC_KEY_PATH.arg(username),
QNetworkAccessManager::GetOperation, callbackParams); AccountManagerAuth::None,
QNetworkAccessManager::GetOperation, callbackParams);
} }
QUrl DomainServer::oauthRedirectURL() { QUrl DomainServer::oauthRedirectURL() {
@ -1116,8 +1117,10 @@ void DomainServer::sendPendingTransactionsToServer() {
transactionCallbackParams.jsonCallbackMethod = "transactionJSONCallback"; transactionCallbackParams.jsonCallbackMethod = "transactionJSONCallback";
while (i != _pendingAssignmentCredits.end()) { while (i != _pendingAssignmentCredits.end()) {
accountManager.authenticatedRequest("api/v1/transactions", QNetworkAccessManager::PostOperation, accountManager.sendRequest("api/v1/transactions",
transactionCallbackParams, i.value()->postJson().toJson()); AccountManagerAuth::Required,
QNetworkAccessManager::PostOperation,
transactionCallbackParams, i.value()->postJson().toJson());
// set this transaction to finalized so we don't add additional credits to it // set this transaction to finalized so we don't add additional credits to it
i.value()->setIsFinalized(true); i.value()->setIsFinalized(true);
@ -1240,10 +1243,11 @@ void DomainServer::sendHeartbeatToDataServer(const QString& networkAddress) {
QString domainUpdateJSON = QString("{\"domain\": %1 }").arg(QString(QJsonDocument(domainObject).toJson())); QString domainUpdateJSON = QString("{\"domain\": %1 }").arg(QString(QJsonDocument(domainObject).toJson()));
AccountManager::getInstance().authenticatedRequest(DOMAIN_UPDATE.arg(uuidStringWithoutCurlyBraces(domainID)), AccountManager::getInstance().sendRequest(DOMAIN_UPDATE.arg(uuidStringWithoutCurlyBraces(domainID)),
QNetworkAccessManager::PutOperation, AccountManagerAuth::Required,
JSONCallbackParameters(), QNetworkAccessManager::PutOperation,
domainUpdateJSON.toUtf8()); JSONCallbackParameters(),
domainUpdateJSON.toUtf8());
} }
// todo: have data-web respond with ice-server hostname to use // todo: have data-web respond with ice-server hostname to use

10
interface/src/DiscoverabilityManager.cpp
View file

@ -61,17 +61,21 @@ void DiscoverabilityManager::updateLocation() {
uuidStringWithoutCurlyBraces(domainHandler.getUUID())); uuidStringWithoutCurlyBraces(domainHandler.getUUID()));
} }
const QString FRIENDS_ONLY_KEY_IN_LOCATION = "friends_only";
locationObject.insert(FRIENDS_ONLY_KEY_IN_LOCATION, (_mode.get() == Discoverability::Friends));
rootObject.insert(LOCATION_KEY_IN_ROOT, locationObject); rootObject.insert(LOCATION_KEY_IN_ROOT, locationObject);
accountManager.authenticatedRequest(API_USER_LOCATION_PATH, QNetworkAccessManager::PutOperation, accountManager.sendRequest(API_USER_LOCATION_PATH, AccountManagerAuth::Required,
JSONCallbackParameters(), QJsonDocument(rootObject).toJson()); QNetworkAccessManager::PutOperation,
JSONCallbackParameters(), QJsonDocument(rootObject).toJson());
} }
} }
} }
void DiscoverabilityManager::removeLocation() { void DiscoverabilityManager::removeLocation() {
AccountManager& accountManager = AccountManager::getInstance(); AccountManager& accountManager = AccountManager::getInstance();
accountManager.authenticatedRequest(API_USER_LOCATION_PATH, QNetworkAccessManager::DeleteOperation); accountManager.sendRequest(API_USER_LOCATION_PATH, AccountManagerAuth::Required, QNetworkAccessManager::DeleteOperation);
} }
void DiscoverabilityManager::setDiscoverabilityMode(Discoverability::Mode discoverabilityMode) { void DiscoverabilityManager::setDiscoverabilityMode(Discoverability::Mode discoverabilityMode) {

74
libraries/networking/src/AccountManager.cpp
View file

@ -115,7 +115,7 @@ void AccountManager::updateBalance() {
callbackParameters.jsonCallbackReceiver = &_accountInfo; callbackParameters.jsonCallbackReceiver = &_accountInfo;
callbackParameters.jsonCallbackMethod = "setBalanceFromJSON"; callbackParameters.jsonCallbackMethod = "setBalanceFromJSON";
authenticatedRequest("/api/v1/wallets/mine", QNetworkAccessManager::GetOperation, callbackParameters); sendRequest("/api/v1/wallets/mine", AccountManagerAuth::Required, QNetworkAccessManager::GetOperation, callbackParameters);
} }
} }
@ -159,50 +159,30 @@ void AccountManager::setAuthURL(const QUrl& authURL) {
} }
} }
void AccountManager::authenticatedRequest(const QString& path, QNetworkAccessManager::Operation operation, void AccountManager::sendRequest(const QString& path,
const JSONCallbackParameters& callbackParams, AccountManagerAuth::Type authType,
const QByteArray& dataByteArray, QNetworkAccessManager::Operation operation,
QHttpMultiPart* dataMultiPart, const JSONCallbackParameters& callbackParams,
const QVariantMap& propertyMap) { const QByteArray& dataByteArray,
QHttpMultiPart* dataMultiPart,
const QVariantMap& propertyMap) {
QMetaObject::invokeMethod(this, "invokedRequest", if (thread() != QThread::currentThread()) {
Q_ARG(const QString&, path), QMetaObject::invokeMethod(this, "sendRequest",
Q_ARG(bool, true), Q_ARG(const QString&, path),
Q_ARG(QNetworkAccessManager::Operation, operation), Q_ARG(AccountManagerAuth::Type, AccountManagerAuth::Required),
Q_ARG(const JSONCallbackParameters&, callbackParams), Q_ARG(QNetworkAccessManager::Operation, operation),
Q_ARG(const QByteArray&, dataByteArray), Q_ARG(const JSONCallbackParameters&, callbackParams),
Q_ARG(QHttpMultiPart*, dataMultiPart), Q_ARG(const QByteArray&, dataByteArray),
Q_ARG(QVariantMap, propertyMap)); Q_ARG(QHttpMultiPart*, dataMultiPart),
} Q_ARG(QVariantMap, propertyMap));
}
void AccountManager::unauthenticatedRequest(const QString& path, QNetworkAccessManager::Operation operation,
const JSONCallbackParameters& callbackParams,
const QByteArray& dataByteArray,
QHttpMultiPart* dataMultiPart,
const QVariantMap& propertyMap) {
QMetaObject::invokeMethod(this, "invokedRequest",
Q_ARG(const QString&, path),
Q_ARG(bool, false),
Q_ARG(QNetworkAccessManager::Operation, operation),
Q_ARG(const JSONCallbackParameters&, callbackParams),
Q_ARG(const QByteArray&, dataByteArray),
Q_ARG(QHttpMultiPart*, dataMultiPart),
Q_ARG(QVariantMap, propertyMap));
}
void AccountManager::invokedRequest(const QString& path,
bool requiresAuthentication,
QNetworkAccessManager::Operation operation,
const JSONCallbackParameters& callbackParams,
const QByteArray& dataByteArray, QHttpMultiPart* dataMultiPart,
const QVariantMap& propertyMap) {
QNetworkAccessManager& networkAccessManager = NetworkAccessManager::getInstance(); QNetworkAccessManager& networkAccessManager = NetworkAccessManager::getInstance();
QNetworkRequest networkRequest; QNetworkRequest networkRequest;
networkRequest.setHeader(QNetworkRequest::UserAgentHeader, HIGH_FIDELITY_USER_AGENT); networkRequest.setHeader(QNetworkRequest::UserAgentHeader, HIGH_FIDELITY_USER_AGENT);
QUrl requestURL = _authURL; QUrl requestURL = _authURL;
if (path.startsWith("/")) { if (path.startsWith("/")) {
@ -211,13 +191,17 @@ void AccountManager::invokedRequest(const QString& path,
requestURL.setPath("/" + path); requestURL.setPath("/" + path);
} }
if (requiresAuthentication) { if (authType != AccountManagerAuth::None ) {
if (hasValidAccessToken()) { if (hasValidAccessToken()) {
networkRequest.setRawHeader(ACCESS_TOKEN_AUTHORIZATION_HEADER, networkRequest.setRawHeader(ACCESS_TOKEN_AUTHORIZATION_HEADER,
_accountInfo.getAccessToken().authorizationHeaderValue()); _accountInfo.getAccessToken().authorizationHeaderValue());
} else { } else {
qDebug() << "No valid access token present. Bailing on authenticated invoked request."; if (authType == AccountManagerAuth::Required) {
return; qDebug() << "No valid access token present. Bailing on invoked request to"
<< path << "that requires authentication";
return;
}
} }
} }
@ -540,8 +524,8 @@ void AccountManager::processGeneratedKeypair(const QByteArray& publicKey, const
requestMultiPart->append(keyPart); requestMultiPart->append(keyPart);
authenticatedRequest(PUBLIC_KEY_UPDATE_PATH, QNetworkAccessManager::PutOperation, sendRequest(PUBLIC_KEY_UPDATE_PATH, AccountManagerAuth::Required, QNetworkAccessManager::PutOperation,
JSONCallbackParameters(), QByteArray(), requestMultiPart); JSONCallbackParameters(), QByteArray(), requestMultiPart);
// get rid of the keypair generator now that we don't need it anymore // get rid of the keypair generator now that we don't need it anymore
sender()->deleteLater(); sender()->deleteLater();

38
libraries/networking/src/AccountManager.h
View file

@ -37,6 +37,16 @@ public:
QString updateSlot; QString updateSlot;
}; };
namespace AccountManagerAuth {
enum Type {
None,
Required,
Optional
};
}
Q_DECLARE_METATYPE(AccountManagerAuth::Type);
const QByteArray ACCESS_TOKEN_AUTHORIZATION_HEADER = "Authorization"; const QByteArray ACCESS_TOKEN_AUTHORIZATION_HEADER = "Authorization";
class AccountManager : public QObject { class AccountManager : public QObject {
@ -44,19 +54,13 @@ class AccountManager : public QObject {
public: public:
static AccountManager& getInstance(bool forceReset = false); static AccountManager& getInstance(bool forceReset = false);
void authenticatedRequest(const QString& path, Q_INVOKABLE void sendRequest(const QString& path,
QNetworkAccessManager::Operation operation = QNetworkAccessManager::GetOperation, AccountManagerAuth::Type authType,
const JSONCallbackParameters& callbackParams = JSONCallbackParameters(), QNetworkAccessManager::Operation operation = QNetworkAccessManager::GetOperation,
const QByteArray& dataByteArray = QByteArray(), const JSONCallbackParameters& callbackParams = JSONCallbackParameters(),
QHttpMultiPart* dataMultiPart = NULL, const QByteArray& dataByteArray = QByteArray(),
const QVariantMap& propertyMap = QVariantMap()); QHttpMultiPart* dataMultiPart = NULL,
const QVariantMap& propertyMap = QVariantMap());
void unauthenticatedRequest(const QString& path,
QNetworkAccessManager::Operation operation = QNetworkAccessManager::GetOperation,
const JSONCallbackParameters& callbackParams = JSONCallbackParameters(),
const QByteArray& dataByteArray = QByteArray(),
QHttpMultiPart* dataMultiPart = NULL,
const QVariantMap& propertyMap = QVariantMap()) ;
const QUrl& getAuthURL() const { return _authURL; } const QUrl& getAuthURL() const { return _authURL; }
void setAuthURL(const QUrl& authURL); void setAuthURL(const QUrl& authURL);
@ -107,14 +111,6 @@ private:
void passSuccessToCallback(QNetworkReply* reply); void passSuccessToCallback(QNetworkReply* reply);
void passErrorToCallback(QNetworkReply* reply); void passErrorToCallback(QNetworkReply* reply);
Q_INVOKABLE void invokedRequest(const QString& path,
bool requiresAuthentication,
QNetworkAccessManager::Operation operation,
const JSONCallbackParameters& callbackParams,
const QByteArray& dataByteArray,
QHttpMultiPart* dataMultiPart,
const QVariantMap& propertyMap);
QUrl _authURL; QUrl _authURL;
QMap<QNetworkReply*, JSONCallbackParameters> _pendingCallbackMap; QMap<QNetworkReply*, JSONCallbackParameters> _pendingCallbackMap;

18
libraries/networking/src/AddressManager.cpp
View file

@ -294,12 +294,11 @@ void AddressManager::attemptPlaceNameLookup(const QString& lookupString, const Q
requestParams.insert(OVERRIDE_PATH_KEY, overridePath); requestParams.insert(OVERRIDE_PATH_KEY, overridePath);
} }
AccountManager::getInstance().unauthenticatedRequest(GET_PLACE.arg(placeName), AccountManager::getInstance().sendRequest(GET_PLACE.arg(placeName),
QNetworkAccessManager::GetOperation, AccountManagerAuth::None,
apiCallbackParameters(), QNetworkAccessManager::GetOperation,
QByteArray(), apiCallbackParameters(),
NULL, QByteArray(), NULL, requestParams);
requestParams);
} }
bool AddressManager::handleNetworkAddress(const QString& lookupString) { bool AddressManager::handleNetworkAddress(const QString& lookupString) {
@ -439,9 +438,10 @@ void AddressManager::setDomainInfo(const QString& hostname, quint16 port) {
void AddressManager::goToUser(const QString& username) { void AddressManager::goToUser(const QString& username) {
QString formattedUsername = QUrl::toPercentEncoding(username); QString formattedUsername = QUrl::toPercentEncoding(username);
// this is a username - pull the captured name and lookup that user's location // this is a username - pull the captured name and lookup that user's location
AccountManager::getInstance().unauthenticatedRequest(GET_USER_LOCATION.arg(formattedUsername), AccountManager::getInstance().sendRequest(GET_USER_LOCATION.arg(formattedUsername),
QNetworkAccessManager::GetOperation, AccountManagerAuth::Optional,
apiCallbackParameters()); QNetworkAccessManager::GetOperation,
apiCallbackParameters());
} }
void AddressManager::copyAddress() { void AddressManager::copyAddress() {

9
libraries/networking/src/UserActivityLogger.cpp
View file

@ -62,11 +62,10 @@ void UserActivityLogger::logAction(QString action, QJsonObject details, JSONCall
params.errorCallbackMethod = "requestError"; params.errorCallbackMethod = "requestError";
} }
accountManager.authenticatedRequest(USER_ACTIVITY_URL, accountManager.sendRequest(USER_ACTIVITY_URL,
QNetworkAccessManager::PostOperation, AccountManagerAuth::Required,
params, QNetworkAccessManager::PostOperation,
NULL, params, NULL, multipart);
multipart);
} }
void UserActivityLogger::requestFinished(QNetworkReply& requestReply) { void UserActivityLogger::requestFinished(QNetworkReply& requestReply) {