vcs.maemo.org Git - situare/blob - src/situareservice/situareservice.cpp

   1 /*
   2    Situare - A location system for Facebook
   3    Copyright (C) 2010  Ixonos Plc. Authors:
   4
   5       Henri Lampela - henri.lampela@ixonos.com
   6       Sami Rämö - sami.ramo@ixonos.com
   7
   8    Situare is free software; you can redistribute it and/or
   9    modify it under the terms of the GNU General Public License
  10    version 2 as published by the Free Software Foundation.
  11
  12    Situare is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with Situare; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
  20    USA.
  21 */
  22
  23 #include <qjson/parser.h>
  24
  25 #include <QDebug>
  26 #include <QtNetwork/QNetworkReply>
  27 #include <QPixmap>
  28 #include <QStringList>
  29 #include <QtAlgorithms>
  30 #include <QtGlobal>
  31
  32 #include "database.h"
  33 #include "../error.h"
  34 #include "network/networkaccessmanager.h"
  35 #include "situarecommon.h"
  36 #include "ui/avatarimage.h"
  37
  38 #include "situareservice.h"
  39
  40 SituareService::SituareService(NetworkAccessManager *networkManager, ImageFetcher *imageFetcher,
  41                                QObject *parent)
  42         : QObject(parent),
  43         m_user(0)
  44 {
  45     qDebug() << __PRETTY_FUNCTION__;
  46
  47     m_networkManager = networkManager;
  48     connect(m_networkManager, SIGNAL(finished(QNetworkReply*)),
  49             this, SLOT(requestFinished(QNetworkReply*)), Qt::QueuedConnection);
  50
  51     m_imageFetcher = imageFetcher;
  52     connect(this, SIGNAL(fetchImage(QString, QUrl)),
  53             m_imageFetcher, SLOT(fetchImage(QString, QUrl)));
  54     connect(m_imageFetcher, SIGNAL(imageReceived(QString,QPixmap)),
  55             this, SLOT(imageReceived(QString,QPixmap)));
  56     connect(m_imageFetcher, SIGNAL(error(int, int)),
  57             this, SIGNAL(error(int, int)));
  58
  59     m_database = new Database(this);
  60     m_database->openDatabase();
  61     m_database->createNotificationTable();
  62     m_database->createUserTable();
  63     m_database->createTagTable();
  64     m_database->createUserTagTable();
  65 }
  66
  67 SituareService::~SituareService()
  68 {
  69     qDebug() << __PRETTY_FUNCTION__;
  70
  71     if(m_user) {
  72         delete m_user;
  73         m_user = 0;
  74     }
  75
  76     qDeleteAll(m_friendsList.begin(), m_friendsList.end());
  77     m_friendsList.clear();
  78 }
  79
  80 void SituareService::addProfileImages(const QHash<QString, QUrl> &imageUrlList)
  81 {
  82     qDebug() << __PRETTY_FUNCTION__;
  83
  84     QHashIterator<QString, QUrl> imageUrlListIterator(imageUrlList);
  85
  86     while (imageUrlListIterator.hasNext()) {
  87         imageUrlListIterator.next();
  88         emit fetchImage(imageUrlListIterator.key(), imageUrlListIterator.value());
  89     }
  90 }
  91
  92 void SituareService::addTags(const QStringList &tags)
  93 {
  94     qDebug() << __PRETTY_FUNCTION__;
  95
  96     QHash<QString, QString> parameters;
  97     parameters.insert("tags", tags.join(","));
  98
  99     buildRequest(ADD_TAGS, parameters);
 100 }
 101
 102 void SituareService::appendAccessToken(QString &requestUrl)
 103 {
 104     qDebug() << __PRETTY_FUNCTION__;
 105
 106     requestUrl.append(m_session);
 107 }
 108
 109 void SituareService::buildRequest(const QString &script, const QHash<QString, QString> &parameters)
 110 {
 111     qDebug() << __PRETTY_FUNCTION__;
 112
 113     const QString PARAMETER_KEY_API = "api";
 114     const QString PARAMETER_VALUE_API = "2.0";
 115
 116     QString url = SITUARE_URL;
 117     url.append(script);
 118     url.append("?");
 119
 120     // append default api version parameter if not yet specified
 121     if (!parameters.contains(PARAMETER_KEY_API))
 122         url.append(PARAMETER_KEY_API + "=" + PARAMETER_VALUE_API + "&");
 123
 124     // append parameters
 125     if (!parameters.isEmpty()) {
 126         QHash<QString, QString>::const_iterator i = parameters.constBegin();
 127         while (i != parameters.constEnd()) {
 128             url.append(i.key());
 129             url.append("=");
 130             url.append(i.value());
 131             url.append("&");
 132             i++;
 133         }
 134     }
 135
 136     /// @todo BUG: Url parameter strings are not url escaped
 137
 138 //    qWarning() << __PRETTY_FUNCTION__ << "request url with parameters:" << url;
 139
 140     if (!m_session.isEmpty()) {
 141         appendAccessToken(url);
 142         sendRequest(url);
 143     } else {
 144         emit error(ErrorContext::SITUARE, SituareError::SESSION_EXPIRED);
 145     }
 146 }
 147
 148 void SituareService::clearUserData()
 149 {
 150     qDebug() << __PRETTY_FUNCTION__;
 151
 152     qDeleteAll(m_friendsList.begin(), m_friendsList.end());
 153     m_friendsList.clear();
 154
 155     if(m_user) {
 156         delete m_user;
 157         m_user = 0;
 158     }
 159     emit userDataChanged(m_user, m_friendsList);
 160 }
 161
 162 QString SituareService::degreesToString(double degrees)
 163 {
 164     qDebug() << __PRETTY_FUNCTION__;
 165
 166     // one scene pixel is about 5.4e-6 degrees, the integer part is max three digits and one
 167     // additional digit is added for maximum precision
 168     const int PRECISION = 10;
 169
 170     return QString::number(degrees, 'f', PRECISION);
 171 }
 172
 173 void SituareService::fetchMessages()
 174 {
 175     qDebug() << __PRETTY_FUNCTION__;
 176
 177     buildRequest(GET_MESSAGES, QHash<QString, QString>());
 178 }
 179
 180 void SituareService::fetchPeopleWithSimilarInterest(const qreal distance)
 181 {
 182     qDebug() << __PRETTY_FUNCTION__;
 183
 184     const int TO_KM_DIVIDER = 1000;
 185     QHash<QString, QString> parameters;
 186     parameters.insert("distance", degreesToString(distance / TO_KM_DIVIDER));
 187
 188     buildRequest(GET_PEOPLE_WITH_SIMILAR_INTEREST, parameters);
 189 }
 190
 191 void SituareService::fetchPopularTags()
 192 {
 193     qDebug() << __PRETTY_FUNCTION__;
 194
 195     buildRequest(GET_POPULAR_TAGS, QHash<QString, QString>());
 196 }
 197
 198 void SituareService::fetchLocations()
 199 {
 200     qDebug() << __PRETTY_FUNCTION__;
 201
 202     QHash<QString, QString> parameters;
 203     parameters.insert("extra_user_data", NORMAL_SIZE_PROFILE_IMAGE);
 204
 205     buildRequest(GET_LOCATIONS, parameters);
 206 }
 207
 208 SituareService::RequestName SituareService::getRequestName(const QUrl &url) const
 209 {
 210     qDebug() << __PRETTY_FUNCTION__;
 211
 212     if (url.toString().contains(GET_LOCATIONS))
 213         return SituareService::RequestGetLocations;
 214     else if (url.toString().contains(UPDATE_LOCATION))
 215         return SituareService::RequestUpdateLocation;
 216     else if (url.toString().contains(REVERSE_GEO))
 217         return SituareService::RequestReverseGeo;
 218     else if (url.toString().contains(GET_MESSAGES))
 219         return SituareService::RequestGetMessages;
 220     else if (url.toString().contains(REMOVE_MESSAGE))
 221         return SituareService::RequestRemoveMessage;
 222     else if (url.toString().contains(SEND_MESSAGE))
 223         return SituareService::RequestSendMessage;
 224     else if (url.toString().contains(GET_PEOPLE_WITH_SIMILAR_INTEREST))
 225         return SituareService::RequestGetPeopleWithSimilarInterest;
 226     else if (url.toString().contains(GET_POPULAR_TAGS))
 227         return SituareService::RequestGetPopularTags;
 228     else if (url.toString().contains(ADD_TAGS))
 229         return SituareService::RequestAddTags;
 230     else
 231         return SituareService::RequestUnknown;
 232 }
 233
 234 QHash<QString, QString> SituareService::getTags(const QString &userId)
 235 {
 236     qDebug() << __PRETTY_FUNCTION__;
 237
 238     return m_database->getTags(userId.toInt());
 239 }
 240
 241 void SituareService::imageReceived(const QString &id, const QPixmap &image)
 242 {
 243     qDebug() << __PRETTY_FUNCTION__;
 244
 245     if (m_user->userId() == id)
 246         emit imageReady(QString(), AvatarImage::create(image, AvatarImage::Large));
 247     else
 248         emit imageReady(id, AvatarImage::create(image, AvatarImage::Small));
 249 }
 250
 251 void SituareService::parseInterestingPeopleData(const QVariant &interestingPeopleData)
 252 {
 253     qDebug() << __PRETTY_FUNCTION__;
 254
 255     QVariant people = interestingPeopleData.toMap();
 256
 257     QList<User> friends;
 258     QList<User> others;
 259
 260     foreach (QVariant personVariant, people.toMap().value("friends").toList()) {
 261         User user;
 262         QMap<QString, QVariant> person = personVariant.toMap();
 263         user.setUserId(person["uid"].toString());
 264         user.setName(person["name"].toString());
 265         user.setProfileImage(AvatarImage::create(
 266                 QPixmap(":/res/images/empty_avatar.png"), AvatarImage::Small));
 267         user.setProfileImageUrl(person["pic_square"].toUrl());
 268         user.setTimestamp(person["timestamp"].toString());
 269         user.setTags(person["tags"].toString());
 270         user.setAddress(person["address"].toString());
 271         user.setNote(person["note"].toString());
 272
 273         bool latOk;
 274         qreal latitude = person["lat"].toReal(&latOk);
 275         bool lonOk;
 276         qreal longitude = person["lon"].toReal(&lonOk);
 277
 278         if (latOk && lonOk) {
 279             user.setCoordinates(GeoCoordinate(latitude, longitude));
 280
 281             qreal meters = person["distance"].toReal() * 1000;
 282             qreal value;
 283             QString unit;
 284             if (meters < 1000) {
 285                 value = meters;
 286                 unit = "m";
 287             } else {
 288                 value = meters/1000;
 289                 unit = "km";
 290             }
 291             user.setDistance(value, unit);
 292         }
 293
 294         friends.append(user);
 295
 296         //Remove comment when the actual server is used
 297         //emit fetchImage(user.userId(), user.profileImageUrl());
 298     }
 299
 300     foreach (QVariant personVariant, people.toMap().value("others").toList()) {
 301         User user;
 302         QMap<QString, QVariant> person = personVariant.toMap();
 303         user.setUserId(person["uid"].toString());
 304         user.setName(person["name"].toString());
 305         user.setProfileImage(AvatarImage::create(
 306                 QPixmap(":/res/images/empty_avatar.png"), AvatarImage::Small));
 307         user.setProfileImageUrl(person["pic_square"].toUrl());
 308         user.setTimestamp(person["timestamp"].toString());
 309         user.setTags(person["tags"].toString());
 310
 311         others.append(user);
 312
 313         emit fetchImage(user.userId(), user.profileImageUrl());
 314     }
 315
 316     emit interestingPeopleReceived(friends, others);
 317 }
 318
 319 void SituareService::parseReply(const QByteArray &jsonReply, RequestName requestName)
 320 {
 321     qDebug() << __PRETTY_FUNCTION__ << jsonReply;
 322
 323     QJson::Parser parser;
 324     bool ok;
 325
 326     QVariantMap result = parser.parse(jsonReply, &ok).toMap();
 327
 328     if (!ok) {
 329         emit error(ErrorContext::SITUARE, SituareError::INVALID_JSON);
 330     } else {
 331         QVariant resultStatus = result["ResultStatus"];
 332         QVariant resultData = result["ResultData"];
 333
 334         if (resultStatus.toString() == "ERROR") {
 335             QVariantMap errorData = resultData.toMap();
 336             emit error(ErrorContext::SITUARE, errorData["ErrorCode"].toInt());
 337         } else if (resultStatus.toString() == "OK") {
 338             if (requestName == SituareService::RequestGetLocations)
 339                 parseUserData(resultData);
 340             else if (requestName == SituareService::RequestUpdateLocation)
 341                 emit updateWasSuccessful(SituareService::SuccessfulUpdateLocation);
 342             else if (requestName == SituareService::RequestRemoveMessage)
 343                 emit updateWasSuccessful(SituareService::SuccessfulRemoveMessage);
 344             else if (requestName == SituareService::RequestReverseGeo)
 345                 parseReverseGeoData(resultData);
 346             else if (requestName == SituareService::RequestGetMessages)
 347                 parseMessagesData(resultData);
 348             else if (requestName == SituareService::RequestSendMessage)
 349                 emit updateWasSuccessful((SituareService::SuccessfulSendMessage));
 350             else if (requestName == SituareService::RequestGetPeopleWithSimilarInterest)
 351                 parseInterestingPeopleData(resultData);
 352             else if (requestName == SituareService::RequestGetPopularTags)
 353                 parsePopularTagsData(resultData);
 354             else if (requestName == SituareService::RequestAddTags)
 355                 emit updateWasSuccessful(SituareService::SuccessfulAddTags);
 356         }
 357     }
 358 }
 359
 360 void SituareService::parseReverseGeoData(const QVariant &reverseGeoData)
 361 {
 362     qDebug() << __PRETTY_FUNCTION__;
 363
 364     QVariantMap result = reverseGeoData.toMap();
 365
 366     if (result.contains("address") && !result["address"].toString().isEmpty()) {
 367         emit reverseGeoReady(result["address"].toString());
 368     } else {
 369         QStringList coordinates;
 370         coordinates.append(result["lat"].toString());
 371         coordinates.append(result["lon"].toString());
 372         emit error(ErrorContext::SITUARE, SituareError::ADDRESS_RETRIEVAL_FAILED);
 373         emit reverseGeoReady(coordinates.join(", "));
 374     }
 375 }
 376
 377 void SituareService::parseUserData(const QVariant &userData)
 378 {
 379     qDebug() << __PRETTY_FUNCTION__;
 380
 381     m_defaultImage = false;
 382
 383     QVariantMap result = userData.toMap();
 384
 385     if (result.contains("user")) {
 386
 387         QVariant userVariant = result.value("user");
 388         QMap<QString, QVariant> userMap = userVariant.toMap();
 389
 390         GeoCoordinate coordinates(userMap["latitude"].toReal(), userMap["longitude"].toReal());
 391
 392         QUrl imageUrl = userMap[NORMAL_SIZE_PROFILE_IMAGE].toUrl();
 393
 394         if(imageUrl.isEmpty()) {
 395             // user doesn't have profile image, so we need to get him a silhouette image
 396             m_defaultImage = true;
 397         }
 398
 399         QString address = userMap["address"].toString();
 400         if(address.isEmpty()) {
 401             QStringList location;
 402             location.append(QString::number(coordinates.latitude()));
 403             location.append(QString::number(coordinates.longitude()));
 404             address = location.join(", ");
 405         }
 406
 407         User user = User(address, coordinates, userMap["name"].toString(),
 408                       userMap["note"].toString(), imageUrl, userMap["timestamp"].toString(),
 409                       true, userMap["uid"].toString());
 410
 411         if(imageUrl.isEmpty()) {
 412             // user doesn't have profile image, so we need to get him a silhouette image
 413             m_defaultImage = true;
 414             user.setProfileImage(AvatarImage::create(
 415                     QPixmap(":/res/images/empty_avatar_big.png"), AvatarImage::Large));
 416         }
 417
 418         QList<User> tmpFriendsList;
 419
 420         foreach (QVariant friendsVariant, result["friends"].toList()) {
 421           QMap<QString, QVariant> friendMap = friendsVariant.toMap();
 422           QVariant distance = friendMap["distance"];
 423           QMap<QString, QVariant> distanceMap = distance.toMap();
 424
 425           GeoCoordinate coordinates(friendMap["latitude"].toReal(),friendMap["longitude"].toReal());
 426
 427           QUrl imageUrl = friendMap["profile_pic"].toUrl();
 428
 429           if(imageUrl.isEmpty()) {
 430               // friend doesn't have profile image, so we need to get him a silhouette image
 431               m_defaultImage = true;
 432           }
 433
 434           QString address = friendMap["address"].toString();
 435           if(address.isEmpty()) {
 436               QStringList location;
 437               location.append(QString::number(coordinates.latitude()));
 438               location.append(QString::number(coordinates.longitude()));
 439               address = location.join(", ");
 440           }
 441
 442           User buddy = User(address, coordinates, friendMap["name"].toString(),
 443                            friendMap["note"].toString(), imageUrl,
 444                            friendMap["timestamp"].toString(),
 445                            false, friendMap["uid"].toString(), distanceMap["units"].toString(),
 446                            distanceMap["value"].toDouble());
 447
 448           if(imageUrl.isEmpty()) {
 449               // friend doesn't have profile image, so we need to get him a silhouette image
 450               m_defaultImage = true;
 451               buddy.setProfileImage(AvatarImage::create(
 452                       QPixmap(":/res/images/empty_avatar.png"), AvatarImage::Small));
 453           }
 454
 455           tmpFriendsList.append(buddy);
 456         }
 457
 458         QHash<QString, QUrl> imageUrlList; // url list for images
 459
 460         // set unchanged profile images or add new images to imageUrlList for downloading
 461         if(m_user) {
 462             if(m_user->profileImageUrl() != user.profileImageUrl()) {
 463                 if(!user.profileImageUrl().isEmpty())
 464                     imageUrlList.insert(user.userId(), user.profileImageUrl());
 465             } else {
 466                 user.setProfileImage(m_user->profileImage());
 467             }
 468         } else {
 469             if(!user.profileImageUrl().isEmpty())
 470                 imageUrlList.insert(user.userId(), user.profileImageUrl());
 471         }
 472
 473         // clear old user object
 474         if(m_user) {
 475             delete m_user;
 476             m_user = 0;
 477         }
 478
 479         // create new user object from temporary user object
 480         m_user = new User(user);
 481
 482         // set unchanged profile images or add new images to imageUrlList for downloading
 483         if(!m_friendsList.isEmpty()) {
 484             foreach(User tmpBuddy, tmpFriendsList) {
 485                 if(!tmpBuddy.profileImageUrl().isEmpty()) {
 486                     bool found = false;
 487                     foreach(User *buddy, m_friendsList) {
 488                         if(tmpBuddy.profileImageUrl() == buddy->profileImageUrl()) {
 489                             tmpBuddy.setProfileImage(buddy->profileImage());
 490                             found = true;
 491                             break;
 492                         }
 493                     }
 494                     if(!found && !tmpBuddy.profileImageUrl().isEmpty())
 495                         imageUrlList.insert(tmpBuddy.userId(), tmpBuddy.profileImageUrl());
 496                 }
 497             }
 498         } else {
 499             foreach(User buddy, tmpFriendsList) {
 500                 if(!buddy.profileImageUrl().isEmpty())
 501                     imageUrlList.insert(buddy.userId(), buddy.profileImageUrl());
 502             }
 503         }
 504
 505         // clear old friendlist
 506         qDeleteAll(m_friendsList.begin(), m_friendsList.end());
 507         m_friendsList.clear();
 508
 509         // populate new friendlist with temporary friendlist's data
 510         foreach(User tmpFriendItem, tmpFriendsList) {
 511             User *friendItem = new User(tmpFriendItem);
 512             m_friendsList.append(friendItem);
 513         }
 514         tmpFriendsList.clear();
 515
 516         //REMOVE WHEN NOT NEEDED! get user tags and set tags to the user
 517         m_user->setTags(getTags(m_user->userId()));
 518
 519         emit userDataChanged(m_user, m_friendsList);
 520
 521         // set silhouette image to imageUrlList for downloading
 522         if(m_defaultImage)
 523             imageUrlList.insert("", QUrl(SILHOUETTE_URL));
 524
 525         addProfileImages(imageUrlList);
 526         imageUrlList.clear();
 527     }
 528 }
 529
 530 void SituareService::parseMessagesData(const QVariant &messagesData)
 531 {
 532     QVariantMap result = messagesData.toMap();
 533
 534     QList<Message> received;
 535     QList<Message> sent;
 536
 537     foreach (QVariant messageVariant, result["received"].toList()) {
 538         Message message(Message::MessageTypeReceived);
 539         QMap<QString, QVariant> messageMap = messageVariant.toMap();
 540         message.setId(messageMap["mid"].toString());
 541         message.setSenderId(messageMap["sid"].toString());
 542         message.setReceiverId(messageMap["rid"].toString());
 543         message.setSenderName(messageMap["name"].toString());
 544         uint timestampSeconds = messageMap["timestamp"].toUInt();
 545         message.setTimestamp(QDateTime::fromTime_t(timestampSeconds));
 546         message.setText(messageMap["message"].toString());
 547         message.setImage(AvatarImage::create(
 548                 QPixmap(":/res/images/empty_avatar.png"), AvatarImage::Small));
 549
 550         bool latOk;
 551         qreal latitude = messageMap["lat"].toReal(&latOk);
 552         bool lonOk;
 553         qreal longitude = messageMap["lon"].toReal(&lonOk);
 554
 555         if (latOk && lonOk) {
 556             message.setAddress(messageMap["address"].toString());
 557             message.setCoordinates(GeoCoordinate(latitude, longitude));
 558         }
 559
 560         received.append(message);
 561
 562         emit fetchImage(message.id(), messageMap["pic_square"].toString());
 563     }
 564
 565     foreach (QVariant messageVariant, result["sent"].toList()) {
 566         Message message(Message::MessageTypeSent);
 567         QMap<QString, QVariant> messageMap = messageVariant.toMap();
 568         message.setId(messageMap["mid"].toString());
 569         message.setSenderId(messageMap["sid"].toString());
 570         message.setReceiverId(messageMap["rid"].toString());
 571         message.setSenderName(messageMap["name"].toString());
 572         uint timestampSeconds = messageMap["timestamp"].toUInt();
 573         message.setTimestamp(QDateTime::fromTime_t(timestampSeconds));
 574         message.setText(messageMap["message"].toString());
 575         message.setImage(AvatarImage::create(
 576                 QPixmap(":/res/images/empty_avatar.png"), AvatarImage::Small));
 577
 578         bool latOk;
 579         qreal latitude = messageMap["lat"].toReal(&latOk);
 580         bool lonOk;
 581         qreal longitude = messageMap["lon"].toReal(&lonOk);
 582
 583         if (latOk && lonOk) {
 584             message.setAddress(messageMap["address"].toString());
 585             message.setCoordinates(GeoCoordinate(latitude, longitude));
 586         }
 587
 588         sent.append(message);
 589
 590         emit fetchImage(message.id(), messageMap["pic_square"].toString());
 591     }
 592
 593     emit messagesReceived(received, sent);
 594 }
 595
 596 void SituareService::parsePopularTagsData(const QVariant &popularTagsData)
 597 {
 598     qDebug() << __PRETTY_FUNCTION__;
 599
 600     QVariantMap result = popularTagsData.toMap();
 601     QHash<QString, QString> popularTags;
 602
 603     foreach (QVariant tagVariant, result["popular_tags"].toList()) {
 604         QMap<QString, QVariant> tag = tagVariant.toMap();
 605         popularTags.insert(tag["tid"].toString(), tag["name"].toString());
 606     }
 607
 608     emit popularTagsReceived(popularTags);
 609 }
 610
 611 void SituareService::removeMessage(const QString &id)
 612 {
 613     qDebug() << __PRETTY_FUNCTION__;
 614
 615     QHash<QString, QString> parameters;
 616     parameters.insert("mid", id);
 617
 618     buildRequest(REMOVE_MESSAGE, parameters);
 619 }
 620
 621
 622 void SituareService::removeTags(const QStringList &tags)
 623 {
 624     qDebug() << __PRETTY_FUNCTION__;
 625
 626     if (m_database->removeTags(613374451, tags))
 627         emit updateWasSuccessful(SituareService::SuccessfulRemoveTags);
 628 }
 629
 630 void SituareService::requestFinished(QNetworkReply *reply)
 631 {
 632     qDebug() << __PRETTY_FUNCTION__;
 633
 634     //Reply from situare
 635     if (m_currentRequests.contains(reply)) {
 636         if (reply->error())
 637             emit error(ErrorContext::NETWORK, reply->error());
 638         else
 639             parseReply(reply->readAll(), getRequestName(reply->url()));
 640
 641         m_currentRequests.removeAll(reply);
 642         reply->deleteLater();
 643     }
 644 }
 645
 646 void SituareService::reverseGeo(const GeoCoordinate &coordinates)
 647 {
 648     qDebug() << __PRETTY_FUNCTION__;
 649
 650     QHash<QString, QString> parameters;
 651     parameters.insert("lat", degreesToString(coordinates.latitude()));
 652     parameters.insert("lon", degreesToString(coordinates.longitude()));
 653     parameters.insert("format", "json");
 654
 655     buildRequest(REVERSE_GEO, parameters);
 656 }
 657
 658 void SituareService::searchPeopleByTag(const QString &tag)
 659 {
 660     qDebug() << __PRETTY_FUNCTION__;
 661
 662     QByteArray arr = m_database->getInterestingPeopleByTag(613374451, tag);
 663
 664     parseInterestingPeopleData(arr);
 665 }
 666
 667 void SituareService::sendMessage(const QString &receiverId, const QString &message,
 668                                  const GeoCoordinate &coordinates)
 669 {
 670     qDebug() << __PRETTY_FUNCTION__;
 671
 672     QHash<QString, QString> parameters;
 673     parameters.insert("rid", receiverId);
 674     parameters.insert("message", message);
 675
 676     if (coordinates.isValid()) {
 677         parameters.insert("lat", degreesToString(coordinates.latitude()));
 678         parameters.insert("lon", degreesToString(coordinates.longitude()));
 679     }
 680
 681     buildRequest(SEND_MESSAGE, parameters);
 682 }
 683
 684 void SituareService::sendRequest(const QString &requestUrl)
 685 {
 686     qDebug() << __PRETTY_FUNCTION__ << "requestUrl" << requestUrl;
 687
 688     // make and send the request
 689     QNetworkRequest request;
 690     request.setUrl(QUrl(requestUrl));
 691     request.setAttribute(QNetworkRequest::CacheSaveControlAttribute, false);
 692     QNetworkReply *reply = m_networkManager->get(request, true);
 693     m_currentRequests.append(reply);
 694 }
 695
 696 void SituareService::updateSession(const QString &session)
 697 {
 698     qDebug() << __PRETTY_FUNCTION__;
 699
 700     m_session = session;
 701
 702     if (m_session.isEmpty())
 703         clearUserData();
 704 }
 705
 706 void SituareService::updateLocation(const GeoCoordinate &coordinates, const QString &status,
 707                                     const bool &publish)
 708 {
 709     qDebug() << __PRETTY_FUNCTION__;
 710
 711     QHash<QString, QString> parameters;
 712     parameters.insert("lat", degreesToString(coordinates.latitude()));
 713     parameters.insert("lon", degreesToString(coordinates.longitude()));
 714     parameters.insert("publish", publish ? "true" : "false");
 715     parameters.insert("data", status); ///< @todo if !empty ???
 716
 717     buildRequest(UPDATE_LOCATION, parameters);
 718 }