GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r437:7437ef3ab6da

1

#include "AmdaProvider.h"

1

#include "AmdaProvider.h"

2

#include "AmdaDefs.h"

2

#include "AmdaDefs.h"

3

#include "AmdaResultParser.h"

3

#include "AmdaResultParser.h"

4

5

#include <Data/DataProviderParameters.h>

5

#include <Data/DataProviderParameters.h>

6

#include <Network/NetworkController.h>

6

#include <Network/NetworkController.h>

7

#include <SqpApplication.h>

7

#include <SqpApplication.h>

8

#include <Variable/Variable.h>

8

#include <Variable/Variable.h>

9

10

#include <QNetworkAccessManager>

10

#include <QNetworkAccessManager>

11

#include <QNetworkReply>

11

#include <QNetworkReply>

12

#include <QTemporaryFile>

12

#include <QTemporaryFile>

13

#include <QThread>

13

#include <QThread>

14

15

Q_LOGGING_CATEGORY(LOG_AmdaProvider, "AmdaProvider")

15

Q_LOGGING_CATEGORY(LOG_AmdaProvider, "AmdaProvider")

16

17

namespace {

17

namespace {

18

19

/// URL format for a request on AMDA server. The parameters are as follows:

19

/// URL format for a request on AMDA server. The parameters are as follows:

20

/// - %1: start date

20

/// - %1: start date

21

/// - %2: end date

21

/// - %2: end date

22

/// - %3: parameter id

22

/// - %3: parameter id

23

const auto AMDA_URL_FORMAT = QStringLiteral(

23

const auto AMDA_URL_FORMAT = QStringLiteral(

24

"http://amda.irap.omp.eu/php/rest/"

24

"http://amda.irap.omp.eu/php/rest/"

25

"getParameter.php?startTime=%1&stopTime=%2&parameterID=%3&~~sampling=60&~~outputFormat=ASCII&"

25

"getParameter.php?startTime=%1&stopTime=%2&parameterID=%3&outputFormat=ASCII&"

26

"timeFormat=ISO8601&gzip=0");

26

"timeFormat=ISO8601&gzip=0");

27

28

/// Dates format passed in the URL (e.g 2013-09-23T09:00)

28

/// Dates format passed in the URL (e.g 2013-09-23T09:00)

29

const auto AMDA_TIME_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss");

29

const auto AMDA_TIME_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss");

30

31

/// Formats a time to a date that can be passed in URL

31

/// Formats a time to a date that can be passed in URL

32

QString dateFormat(double sqpDateTime) noexcept

32

QString dateFormat(double sqpDateTime) noexcept

33

{

33

{

34

auto dateTime = QDateTime::fromMSecsSinceEpoch(sqpDateTime * 1000.);

34

auto dateTime = QDateTime::fromMSecsSinceEpoch(sqpDateTime * 1000.);

35

return dateTime.toString(AMDA_TIME_FORMAT);

35

return dateTime.toString(AMDA_TIME_FORMAT);

36

}

36

}

37

38

} // namespace

38

} // namespace

39

40

AmdaProvider::AmdaProvider()

40

AmdaProvider::AmdaProvider()

41

{

41

{

42

qCDebug(LOG_AmdaProvider()) << tr("AmdaProvider::AmdaProvider") << QThread::currentThread();

42

qCDebug(LOG_AmdaProvider()) << tr("AmdaProvider::AmdaProvider") << QThread::currentThread();

43

if (auto app = sqpApp) {

43

if (auto app = sqpApp) {

44

auto &networkController = app->networkController();

44

auto &networkController = app->networkController();

45

connect(this, SIGNAL(requestConstructed(QNetworkRequest, QUuid,

45

connect(this, SIGNAL(requestConstructed(QNetworkRequest, QUuid,

46

std::function<void(QNetworkReply *, QUuid)>)),

46

std::function<void(QNetworkReply *, QUuid)>)),

47

&networkController,

47

&networkController,

48

SLOT(onProcessRequested(QNetworkRequest, QUuid,

48

SLOT(onProcessRequested(QNetworkRequest, QUuid,

49

std::function<void(QNetworkReply *, QUuid)>)));

49

std::function<void(QNetworkReply *, QUuid)>)));

50

51

52

connect(&sqpApp->networkController(), SIGNAL(replyDownloadProgress(QUuid, double)), this,

52

connect(&sqpApp->networkController(), SIGNAL(replyDownloadProgress(QUuid, double)), this,

53

SIGNAL(dataProvidedProgress(QUuid, double)));

53

SIGNAL(dataProvidedProgress(QUuid, double)));

54

}

54

}

55

}

55

}

56

57

void AmdaProvider::requestDataLoading(QUuid token, const DataProviderParameters &parameters)

57

void AmdaProvider::requestDataLoading(QUuid token, const DataProviderParameters &parameters)

58

{

58

{

59

// NOTE: Try to use multithread if possible

59

// NOTE: Try to use multithread if possible

60

const auto times = parameters.m_Times;

60

const auto times = parameters.m_Times;

61

const auto data = parameters.m_Data;

61

const auto data = parameters.m_Data;

62

for (const auto &dateTime : qAsConst(times)) {

62

for (const auto &dateTime : qAsConst(times)) {

63

retrieveData(token, dateTime, data);

63

retrieveData(token, dateTime, data);

64

}

64

}

65

}

65

}

66

67

void AmdaProvider::requestDataAborting(QUuid identifier)

67

void AmdaProvider::requestDataAborting(QUuid identifier)

68

{

68

{

69

if (auto app = sqpApp) {

69

if (auto app = sqpApp) {

70

auto &networkController = app->networkController();

70

auto &networkController = app->networkController();

71

networkController.onReplyCanceled(identifier);

71

networkController.onReplyCanceled(identifier);

72

}

72

}

73

}

73

}

74

75

void AmdaProvider::retrieveData(QUuid token, const SqpDateTime &dateTime, const QVariantHash &data)

75

void AmdaProvider::retrieveData(QUuid token, const SqpDateTime &dateTime, const QVariantHash &data)

76

{

76

{

77

// Retrieves product ID from data: if the value is invalid, no request is made

77

// Retrieves product ID from data: if the value is invalid, no request is made

78

auto productId = data.value(AMDA_XML_ID_KEY).toString();

78

auto productId = data.value(AMDA_XML_ID_KEY).toString();

79

if (productId.isNull()) {

79

if (productId.isNull()) {

80

qCCritical(LOG_AmdaProvider()) << tr("Can't retrieve data: unknown product id");

80

qCCritical(LOG_AmdaProvider()) << tr("Can't retrieve data: unknown product id");

81

return;

81

return;

82

}

82

}

83

qCInfo(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData") << dateTime;

83

qCInfo(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData") << dateTime;

84

85

// /////////// //

85

// /////////// //

86

// Creates URL //

86

// Creates URL //

87

// /////////// //

87

// /////////// //

88

89

auto startDate = dateFormat(dateTime.m_TStart);

89

auto startDate = dateFormat(dateTime.m_TStart);

90

auto endDate = dateFormat(dateTime.m_TEnd);

90

auto endDate = dateFormat(dateTime.m_TEnd);

91

92

auto url = QUrl{QString{AMDA_URL_FORMAT}.arg(startDate, endDate, productId)};

92

auto url = QUrl{QString{AMDA_URL_FORMAT}.arg(startDate, endDate, productId)};

93

qCInfo(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData url:") << url;

93

qCInfo(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData url:") << url;

94

auto tempFile = std::make_shared<QTemporaryFile>();

94

auto tempFile = std::make_shared<QTemporaryFile>();

95

96

// LAMBDA

96

// LAMBDA

97

auto httpDownloadFinished

97

auto httpDownloadFinished

98

= [this, dateTime, tempFile, token](QNetworkReply *reply, QUuid dataId) noexcept {

98

= [this, dateTime, tempFile, token](QNetworkReply *reply, QUuid dataId) noexcept {

99

Q_UNUSED(dataId);

99

Q_UNUSED(dataId);

100

101

// Don't do anything if the reply was abort

101

// Don't do anything if the reply was abort

102

if (reply->error() != QNetworkReply::OperationCanceledError) {

102

if (reply->error() != QNetworkReply::OperationCanceledError) {

103

104

if (tempFile) {

104

if (tempFile) {

105

auto replyReadAll = reply->readAll();

105

auto replyReadAll = reply->readAll();

106

if (!replyReadAll.isEmpty()) {

106

if (!replyReadAll.isEmpty()) {

107

tempFile->write(replyReadAll);

107

tempFile->write(replyReadAll);

108

}

108

}

109

tempFile->close();

109

tempFile->close();

110

111

// Parse results file

111

// Parse results file

112

if (auto dataSeries = AmdaResultParser::readTxt(tempFile->fileName())) {

112

if (auto dataSeries = AmdaResultParser::readTxt(tempFile->fileName())) {

113

emit dataProvided(token, dataSeries, dateTime);

113

emit dataProvided(token, dataSeries, dateTime);

114

}

114

}

115

else {

115

else {

116

/// @todo ALX : debug

116

/// @todo ALX : debug

117

}

117

}

118

}

118

}

119

}

119

}

120

121

};

121

};

122

auto httpFinishedLambda

122

auto httpFinishedLambda

123

= [this, httpDownloadFinished, tempFile](QNetworkReply *reply, QUuid dataId) noexcept {

123

= [this, httpDownloadFinished, tempFile](QNetworkReply *reply, QUuid dataId) noexcept {

124

125

// Don't do anything if the reply was abort

125

// Don't do anything if the reply was abort

126

if (reply->error() != QNetworkReply::OperationCanceledError) {

126

if (reply->error() != QNetworkReply::OperationCanceledError) {

127

auto downloadFileUrl = QUrl{QString{reply->readAll()}};

127

auto downloadFileUrl = QUrl{QString{reply->readAll()}};

128

129

130

qCInfo(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData downloadFileUrl:")

130

qCInfo(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData downloadFileUrl:")

131

<< downloadFileUrl;

131

<< downloadFileUrl;

132

// Executes request for downloading file //

132

// Executes request for downloading file //

133

134

// Creates destination file

134

// Creates destination file

135

if (tempFile->open()) {

135

if (tempFile->open()) {

136

// Executes request

136

// Executes request

137

emit requestConstructed(QNetworkRequest{downloadFileUrl}, dataId,

137

emit requestConstructed(QNetworkRequest{downloadFileUrl}, dataId,

138

httpDownloadFinished);

138

httpDownloadFinished);

139

}

139

}

140

}

140

}

141

};

141

};

142

143

// //////////////// //

143

// //////////////// //

144

// Executes request //

144

// Executes request //

145

// //////////////// //

145

// //////////////// //

146

emit requestConstructed(QNetworkRequest{url}, token, httpFinishedLambda);

146

emit requestConstructed(QNetworkRequest{url}, token, httpFinishedLambda);

147

}

147

}

	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

             #include "AmdaProvider.h"
             #include "AmdaDefs.h"
             #include "AmdaResultParser.h"
             #include <Data/DataProviderParameters.h>
             #include <Network/NetworkController.h>
             #include <SqpApplication.h>
             #include <Variable/Variable.h>
             #include <QNetworkAccessManager>
             #include <QNetworkReply>
             #include <QTemporaryFile>
             #include <QThread>
             Q_LOGGING_CATEGORY(LOG_AmdaProvider, "AmdaProvider")
             namespace {
             /// URL format for a request on AMDA server. The parameters are as follows:
             /// - %1: start date
             /// - %2: end date
             /// - %3: parameter id
             const auto AMDA_URL_FORMAT = QStringLiteral(
                 "http://amda.irap.omp.eu/php/rest/"
-                "getParameter.php?startTime=%1&stopTime=%2&parameterID=%3&sampling=60&outputFormat=ASCII&"
+                "getParameter.php?startTime=%1&stopTime=%2&parameterID=%3&outputFormat=ASCII&"
                 "timeFormat=ISO8601&gzip=0");
             /// Dates format passed in the URL (e.g 2013-09-23T09:00)
             const auto AMDA_TIME_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss");
             /// Formats a time to a date that can be passed in URL
             QString dateFormat(double sqpDateTime) noexcept
             {
                 auto dateTime = QDateTime::fromMSecsSinceEpoch(sqpDateTime * 1000.);
                 return dateTime.toString(AMDA_TIME_FORMAT);
             }
             } // namespace
             AmdaProvider::AmdaProvider()
             {
                 qCDebug(LOG_AmdaProvider()) << tr("AmdaProvider::AmdaProvider") << QThread::currentThread();
                 if (auto app = sqpApp) {
                     auto &networkController = app->networkController();
                     connect(this, SIGNAL(requestConstructed(QNetworkRequest, QUuid,
                                                             std::function<void(QNetworkReply *, QUuid)>)),
                             &networkController,
                             SLOT(onProcessRequested(QNetworkRequest, QUuid,
                                                     std::function<void(QNetworkReply *, QUuid)>)));
                     connect(&sqpApp->networkController(), SIGNAL(replyDownloadProgress(QUuid, double)), this,
                             SIGNAL(dataProvidedProgress(QUuid, double)));
                 }
             }
             void AmdaProvider::requestDataLoading(QUuid token, const DataProviderParameters &parameters)
             {
                 // NOTE: Try to use multithread if possible
                 const auto times = parameters.m_Times;
                 const auto data = parameters.m_Data;
                 for (const auto &dateTime : qAsConst(times)) {
                     retrieveData(token, dateTime, data);
                 }
             }
             void AmdaProvider::requestDataAborting(QUuid identifier)
             {
                 if (auto app = sqpApp) {
                     auto &networkController = app->networkController();
                     networkController.onReplyCanceled(identifier);
                 }
             }
             void AmdaProvider::retrieveData(QUuid token, const SqpDateTime &dateTime, const QVariantHash &data)
             {
                 // Retrieves product ID from data: if the value is invalid, no request is made
                 auto productId = data.value(AMDA_XML_ID_KEY).toString();
                 if (productId.isNull()) {
                     qCCritical(LOG_AmdaProvider()) << tr("Can't retrieve data: unknown product id");
                     return;
                 }
                 qCInfo(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData") << dateTime;
                 // /////////// //
                 // Creates URL //
                 // /////////// //
                 auto startDate = dateFormat(dateTime.m_TStart);
                 auto endDate = dateFormat(dateTime.m_TEnd);
                 auto url = QUrl{QString{AMDA_URL_FORMAT}.arg(startDate, endDate, productId)};
                 qCInfo(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData url:") << url;
                 auto tempFile = std::make_shared<QTemporaryFile>();
                 // LAMBDA
                 auto httpDownloadFinished
                     = [this, dateTime, tempFile, token](QNetworkReply *reply, QUuid dataId) noexcept {
                           Q_UNUSED(dataId);
                           // Don't do anything if the reply was abort
                           if (reply->error() != QNetworkReply::OperationCanceledError) {
                               if (tempFile) {
                                   auto replyReadAll = reply->readAll();
                                   if (!replyReadAll.isEmpty()) {
                                       tempFile->write(replyReadAll);
                                   }
                                   tempFile->close();
                                   // Parse results file
                                   if (auto dataSeries = AmdaResultParser::readTxt(tempFile->fileName())) {
                                       emit dataProvided(token, dataSeries, dateTime);
                                   }
                                   else {
                                       /// @todo ALX : debug
                                   }
                               }
                           }
                       };
                 auto httpFinishedLambda
                     = [this, httpDownloadFinished, tempFile](QNetworkReply *reply, QUuid dataId) noexcept {
                           // Don't do anything if the reply was abort
                           if (reply->error() != QNetworkReply::OperationCanceledError) {
                               auto downloadFileUrl = QUrl{QString{reply->readAll()}};
                               qCInfo(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData downloadFileUrl:")
                                                          << downloadFileUrl;
                               // Executes request for downloading file //
                               // Creates destination file
                               if (tempFile->open()) {
                                   // Executes request
                                   emit requestConstructed(QNetworkRequest{downloadFileUrl}, dataId,
                                                           httpDownloadFinished);
                               }
                           }
                       };
                 // //////////////// //
                 // Executes request //
                 // //////////////// //
                 emit requestConstructed(QNetworkRequest{url}, token, httpFinishedLambda);
             }