GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r752:22c6ca1df132

Implement progression for AmdaProvider.

perrinel -

r752:22c6ca1df132

parent child

Context file:

r752:22c6ca1df132

plugins/amda/include/AmdaProvider.h +3 -1

              * @brief The AmdaProvider class is an example of how a data provider can generate data
              */
             class SCIQLOP_AMDA_EXPORT AmdaProvider : public IDataProvider {
+                Q_OBJECT
             public:
                 explicit AmdaProvider();
                 std::shared_ptr<IDataProvider> clone() const override;
                 void requestDataAborting(QUuid acqIdentifier) override;
             private slots:
-                void onReplyDownloadProgress(QUuid, const QNetworkRequest &, double progress);
+                void onReplyDownloadProgress(QUuid acqIdentifier,
+                                             std::shared_ptr<QNetworkRequest> networkRequest, double progress);
             private:
                 void retrieveData(QUuid token, const SqpRange &dateTime, const QVariantHash &data);

plugins/amda/src/AmdaProvider.cpp +29 -22

             /// Dates format passed in the URL (e.g 2013-09-23T09:00)
             const auto AMDA_TIME_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss");
-            // struct AmdaProgression {
-            //    QUuid acqIdentifier;
-            //    std::map<QNetworkRequest, double> m_RequestId;
-            //};
             /// Formats a time to a date that can be passed in URL
             QString dateFormat(double sqpRange) noexcept
             {
                 qCDebug(LOG_AmdaProvider()) << tr("AmdaProvider::AmdaProvider") << QThread::currentThread();
                 if (auto app = sqpApp) {
                     auto &networkController = app->networkController();
-                    connect(this, SIGNAL(requestConstructed(QNetworkRequest, QUuid,
+                    connect(this, SIGNAL(requestConstructed(std::shared_ptr<QNetworkRequest>, QUuid,
                                                             std::function<void(QNetworkReply *, QUuid)>)),
                             &networkController,
-                            SLOT(onProcessRequested(QNetworkRequest, QUuid,
+                            SLOT(onProcessRequested(std::shared_ptr<QNetworkRequest>, QUuid,
                                                     std::function<void(QNetworkReply *, QUuid)>)));
                     connect(&sqpApp->networkController(),
-                            SIGNAL(replyDownloadProgress(QUuid, const QNetworkRequest &, double)), this,
+                            SIGNAL(replyDownloadProgress(QUuid, std::shared_ptr<QNetworkRequest>, double)),
-                            SLOT(onReplyDownloadProgress(QUuid, const QNetworkRequest &, double)));
+                            this,
+                            SLOT(onReplyDownloadProgress(QUuid, std::shared_ptr<QNetworkRequest>, double)));
                 }
             }
             }
             void AmdaProvider::onReplyDownloadProgress(QUuid acqIdentifier,
-                                                       const QNetworkRequest &networkRequest, double progress)
+                                                       std::shared_ptr<QNetworkRequest> networkRequest,
+                                                       double progress)
             {
-                qCCritical(LOG_AmdaProvider()) << tr("onReplyDownloadProgress") << progress;
+                qCDebug(LOG_AmdaProvider()) << tr("onReplyDownloadProgress") << acqIdentifier
+                                            << networkRequest.get() << progress;
                 auto acqIdToRequestProgressMapIt = m_AcqIdToRequestProgressMap.find(acqIdentifier);
                 if (acqIdToRequestProgressMapIt != m_AcqIdToRequestProgressMap.end()) {
-                    qCCritical(LOG_AmdaProvider()) << tr("1 onReplyDownloadProgress") << progress;
+                    qCDebug(LOG_AmdaProvider()) << tr("1 onReplyDownloadProgress found") << progress;
-                    auto requestPtr = &networkRequest;
+                    auto requestPtr = networkRequest;
-                    auto findRequest
+                    auto findRequest = [requestPtr](const auto &entry) { return requestPtr == entry.first; };
-                        = [requestPtr](const auto &entry) { return requestPtr == entry.first.get(); };
                     auto &requestProgressMap = acqIdToRequestProgressMapIt->second;
                     auto requestProgressMapEnd = requestProgressMap.end();
                         requestProgressMapIt->second = progress;
                     }
                     else {
-                        qCCritical(LOG_AmdaProvider()) << tr("Can't retrieve Request in progress");
+                        qCCritical(LOG_AmdaProvider()) << tr("Can't retrieve Request in progress")
+                                                       << acqIdentifier << networkRequest.get() << progress;
                     }
                 }
                 acqIdToRequestProgressMapIt = m_AcqIdToRequestProgressMap.find(acqIdentifier);
                 if (acqIdToRequestProgressMapIt != m_AcqIdToRequestProgressMap.end()) {
-                    qCCritical(LOG_AmdaProvider()) << tr("2 onReplyDownloadProgress") << progress;
                     double finalProgress = 0.0;
                     auto &requestProgressMap = acqIdToRequestProgressMapIt->second;
                     for (auto requestProgress : requestProgressMap) {
                         finalProgress += requestProgress.second;
+                        qCDebug(LOG_AmdaProvider()) << tr("current final progress without freq:")
+                                                    << finalProgress << requestProgress.second;
                     }
                     if (fraq > 0) {
                         finalProgress = finalProgress / fraq;
                     }
-                    qCCritical(LOG_AmdaProvider()) << tr("2 onReplyDownloadProgress") << finalProgress;
+                    qCDebug(LOG_AmdaProvider()) << tr("2 onReplyDownloadProgress final progress") << fraq
+                                                << finalProgress;
                     emit dataProvidedProgress(acqIdentifier, finalProgress);
                 }
                 else {
                 auto endDate = dateFormat(dateTime.m_TEnd);
                 auto url = QUrl{QString{AMDA_URL_FORMAT}.arg(startDate, endDate, productId)};
-                qCInfo(LOG_AmdaProvider()) << tr("TORM AmdaProvider::retrieveData url:") << url;
+                qCDebug(LOG_AmdaProvider()) << tr("TORM AmdaProvider::retrieveData url:") << url;
                 auto tempFile = std::make_shared<QTemporaryFile>();
                 // LAMBDA
                               // Creates destination file
                               if (tempFile->open()) {
-                                  // Executes request
+                                  // Executes request and store the request for progression
                                   auto request = std::make_shared<QNetworkRequest>(downloadFileUrl);
                                   updateRequestProgress(dataId, request, 0.0);
-                                  emit requestConstructed(*request.get(), dataId, httpDownloadFinished);
+                                  emit requestConstructed(request, dataId, httpDownloadFinished);
                               }
                           }
                           else {
                 // //////////////// //
                 auto request = std::make_shared<QNetworkRequest>(url);
+                qCDebug(LOG_AmdaProvider()) << tr("First Request creation") << request.get();
                 updateRequestProgress(token, request, 0.0);
-                emit requestConstructed(*request.get(), token, httpFinishedLambda);
+                emit requestConstructed(request, token, httpFinishedLambda);
             }
             void AmdaProvider::updateRequestProgress(QUuid acqIdentifier,
                     auto requestProgressMapIt = requestProgressMap.find(request);
                     if (requestProgressMapIt != requestProgressMap.end()) {
                         requestProgressMapIt->second = progress;
+                        qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress new progress for request")
+                                                    << acqIdentifier << request.get() << progress;
                     }
                     else {
+                        qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress new request") << acqIdentifier
+                                                    << request.get() << progress;
                         acqIdToRequestProgressMapIt->second.insert(std::make_pair(request, progress));
                     }
                 }
                 else {
+                    qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress new acqIdentifier")
+                                                << acqIdentifier << request.get() << progress;
                     auto requestProgressMap = std::map<std::shared_ptr<QNetworkRequest>, double>{};
                     requestProgressMap.insert(std::make_pair(request, progress));
                     m_AcqIdToRequestProgressMap.insert(

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages