HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r628:40f1a68a746c

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 <Common/DateUtils.h>

5

#include <Common/DateUtils.h>

6

#include <Data/DataProviderParameters.h>

6

#include <Data/DataProviderParameters.h>

7

#include <Network/NetworkController.h>

7

#include <Network/NetworkController.h>

8

#include <SqpApplication.h>

8

#include <SqpApplication.h>

9

#include <Variable/Variable.h>

9

#include <Variable/Variable.h>

10

11

#include <QNetworkAccessManager>

11

#include <QNetworkAccessManager>

12

#include <QNetworkReply>

12

#include <QNetworkReply>

13

#include <QTemporaryFile>

13

#include <QTemporaryFile>

14

#include <QThread>

14

#include <QThread>

15

16

Q_LOGGING_CATEGORY(LOG_AmdaProvider, "AmdaProvider")

16

Q_LOGGING_CATEGORY(LOG_AmdaProvider, "AmdaProvider")

17

18

namespace {

18

namespace {

19

20

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

20

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

21

/// - %1: start date

21

/// - %1: start date

22

/// - %2: end date

22

/// - %2: end date

23

/// - %3: parameter id

23

/// - %3: parameter id

24

const auto AMDA_URL_FORMAT = QStringLiteral(

24

const auto AMDA_URL_FORMAT = QStringLiteral(

25

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

25

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

26

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

26

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

27

"timeFormat=ISO8601&gzip=0");

27

"timeFormat=ISO8601&gzip=0");

28

29

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

29

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

30

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

30

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

31

32

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

32

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

33

QString dateFormat(double sqpRange) noexcept

33

QString dateFormat(double sqpRange) noexcept

34

{

34

{

35

auto dateTime = DateUtils::dateTime(sqpRange);

35

auto dateTime = DateUtils::dateTime(sqpRange);

36

return dateTime.toString(AMDA_TIME_FORMAT);

36

return dateTime.toString(AMDA_TIME_FORMAT);

37

}

37

}

38

39

AmdaResultParser::ValueType valueType(const QString &valueType)

39

AmdaResultParser::ValueType valueType(const QString &valueType)

40

{

40

{

41

if (valueType == QStringLiteral("scalar")) {

41

if (valueType == QStringLiteral("scalar")) {

42

return AmdaResultParser::ValueType::SCALAR;

42

return AmdaResultParser::ValueType::SCALAR;

43

}

43

}

44

else if (valueType == QStringLiteral("vector")) {

44

else if (valueType == QStringLiteral("vector")) {

45

return AmdaResultParser::ValueType::VECTOR;

45

return AmdaResultParser::ValueType::VECTOR;

46

}

46

}

47

else {

47

else {

48

return AmdaResultParser::ValueType::UNKNOWN;

48

return AmdaResultParser::ValueType::UNKNOWN;

49

}

49

}

50

}

50

}

51

52

} // namespace

52

} // namespace

53

54

AmdaProvider::AmdaProvider()

54

AmdaProvider::AmdaProvider()

55

{

55

{

56

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

56

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

57

if (auto app = sqpApp) {

57

if (auto app = sqpApp) {

58

auto &networkController = app->networkController();

58

auto &networkController = app->networkController();

59

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

59

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

60

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

60

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

61

&networkController,

61

&networkController,

62

SLOT(onProcessRequested(QNetworkRequest, QUuid,

62

SLOT(onProcessRequested(QNetworkRequest, QUuid,

63

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

63

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

64

65

66

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

66

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

67

SIGNAL(dataProvidedProgress(QUuid, double)));

67

SIGNAL(dataProvidedProgress(QUuid, double)));

68

}

68

}

69

}

69

}

70

71

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

71

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

72

{

72

{

73

// NOTE: Try to use multithread if possible

73

// NOTE: Try to use multithread if possible

74

const auto times = parameters.m_Times;

74

const auto times = parameters.m_Times;

75

const auto data = parameters.m_Data;

75

const auto data = parameters.m_Data;

76

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

76

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

77

this->retrieveData(acqIdentifier, dateTime, data);

77

this->retrieveData(acqIdentifier, dateTime, data);

78

79

// TORM

79

// TORM when AMDA will support quick asynchrone request

80

// QThread::msleep(200);

80

QThread::msleep(1000);

81

}

81

}

82

}

82

}

83

84

void AmdaProvider::requestDataAborting(QUuid acqIdentifier)

84

void AmdaProvider::requestDataAborting(QUuid acqIdentifier)

85

{

85

{

86

if (auto app = sqpApp) {

86

if (auto app = sqpApp) {

87

auto &networkController = app->networkController();

87

auto &networkController = app->networkController();

88

networkController.onReplyCanceled(acqIdentifier);

88

networkController.onReplyCanceled(acqIdentifier);

89

}

89

}

90

}

90

}

91

92

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

92

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

93

{

93

{

94

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

94

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

95

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

95

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

96

if (productId.isNull()) {

96

if (productId.isNull()) {

97

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

97

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

98

return;

98

return;

99

}

99

}

100

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

100

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

101

102

// Retrieves the data type that determines whether the expected format for the result file is

102

// Retrieves the data type that determines whether the expected format for the result file is

103

// scalar, vector...

103

// scalar, vector...

104

auto productValueType = valueType(data.value(AMDA_DATA_TYPE_KEY).toString());

104

auto productValueType = valueType(data.value(AMDA_DATA_TYPE_KEY).toString());

105

106

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

106

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

107

// Creates URL //

107

// Creates URL //

108

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

108

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

109

110

auto startDate = dateFormat(dateTime.m_TStart);

110

auto startDate = dateFormat(dateTime.m_TStart);

111

auto endDate = dateFormat(dateTime.m_TEnd);

111

auto endDate = dateFormat(dateTime.m_TEnd);

112

113

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

113

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

114

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

114

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

115

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

115

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

116

117

// LAMBDA

117

// LAMBDA

118

auto httpDownloadFinished = [this, dateTime, tempFile,

118

auto httpDownloadFinished = [this, dateTime, tempFile,

119

productValueType](QNetworkReply *reply, QUuid dataId) noexcept {

119

productValueType](QNetworkReply *reply, QUuid dataId) noexcept {

120

121

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

121

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

122

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

122

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

123

124

if (tempFile) {

124

if (tempFile) {

125

auto replyReadAll = reply->readAll();

125

auto replyReadAll = reply->readAll();

126

if (!replyReadAll.isEmpty()) {

126

if (!replyReadAll.isEmpty()) {

127

tempFile->write(replyReadAll);

127

tempFile->write(replyReadAll);

128

}

128

}

129

tempFile->close();

129

tempFile->close();

130

131

// Parse results file

131

// Parse results file

132

if (auto dataSeries

132

if (auto dataSeries

133

= AmdaResultParser::readTxt(tempFile->fileName(), productValueType)) {

133

= AmdaResultParser::readTxt(tempFile->fileName(), productValueType)) {

134

emit dataProvided(dataId, dataSeries, dateTime);

134

emit dataProvided(dataId, dataSeries, dateTime);

135

}

135

}

136

else {

136

else {

137

/// @todo ALX : debug

137

/// @todo ALX : debug

138

}

138

}

139

}

139

}

140

}

140

}

141

142

};

142

};

143

auto httpFinishedLambda

143

auto httpFinishedLambda

144

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

144

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

145

146

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

146

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

147

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

147

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

148

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

148

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

149

150

151

qCInfo(LOG_AmdaProvider())

151

qCInfo(LOG_AmdaProvider())

152

<< tr("TORM AmdaProvider::retrieveData downloadFileUrl:") << downloadFileUrl;

152

<< tr("TORM AmdaProvider::retrieveData downloadFileUrl:") << downloadFileUrl;

153

// Executes request for downloading file //

153

// Executes request for downloading file //

154

155

// Creates destination file

155

// Creates destination file

156

if (tempFile->open()) {

156

if (tempFile->open()) {

157

// Executes request

157

// Executes request

158

emit requestConstructed(QNetworkRequest{downloadFileUrl}, dataId,

158

emit requestConstructed(QNetworkRequest{downloadFileUrl}, dataId,

159

httpDownloadFinished);

159

httpDownloadFinished);

160

}

160

}

161

}

161

}

162

};

162

};

163

164

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

164

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

165

// Executes request //

165

// Executes request //

166

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

166

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

167

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

167

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

168

}

168

}

	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 <Common/DateUtils.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&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 sqpRange) noexcept
             {
                 auto dateTime = DateUtils::dateTime(sqpRange);
                 return dateTime.toString(AMDA_TIME_FORMAT);
             }
             AmdaResultParser::ValueType valueType(const QString &valueType)
             {
                 if (valueType == QStringLiteral("scalar")) {
                     return AmdaResultParser::ValueType::SCALAR;
                 }
                 else if (valueType == QStringLiteral("vector")) {
                     return AmdaResultParser::ValueType::VECTOR;
                 }
                 else {
                     return AmdaResultParser::ValueType::UNKNOWN;
                 }
             }
             } // 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 acqIdentifier, 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)) {
                     this->retrieveData(acqIdentifier, dateTime, data);
-                    // TORM
+                    // TORM when AMDA will support quick asynchrone request
-                    // QThread::msleep(200);
+                    QThread::msleep(1000);
                 }
             }
             void AmdaProvider::requestDataAborting(QUuid acqIdentifier)
             {
                 if (auto app = sqpApp) {
                     auto &networkController = app->networkController();
                     networkController.onReplyCanceled(acqIdentifier);
                 }
             }
             void AmdaProvider::retrieveData(QUuid token, const SqpRange &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;
                 }
                 qCDebug(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData") << dateTime;
                 // Retrieves the data type that determines whether the expected format for the result file is
                 // scalar, vector...
                 auto productValueType = valueType(data.value(AMDA_DATA_TYPE_KEY).toString());
                 // /////////// //
                 // 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("TORM AmdaProvider::retrieveData url:") << url;
                 auto tempFile = std::make_shared<QTemporaryFile>();
                 // LAMBDA
                 auto httpDownloadFinished = [this, dateTime, tempFile,
                                              productValueType](QNetworkReply *reply, QUuid dataId) noexcept {
                     // 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(), productValueType)) {
                                 emit dataProvided(dataId, 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("TORM 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);
             }