Mercurial > hg > orthanc-stone

comparison Framework/Toolbox/OrthancApiClient.cpp @ 383:939f626eb6d7

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
removing converters in OrthancApiClient
author Sebastien Jodogne <s.jodogne@gmail.com>
date Tue, 06 Nov 2018 20:12:42 +0100
parents dd4c7e82b4be
children aee3d7941c9b
comparison
equal deleted inserted replaced
382:dd4c7e82b4be 383:939f626eb6d7
64 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); 64 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
65 } 65 }
66 } 66 }
67 67
68 68
69 class OrthancApiClient::WebServicePayload : public Orthanc::IDynamicObject
70 {
71 private:
72 std::auto_ptr< MessageHandler<EmptyResponseReadyMessage> > emptyHandler_;
73 std::auto_ptr< MessageHandler<JsonResponseReadyMessage> > jsonHandler_;
74 std::auto_ptr< MessageHandler<BinaryResponseReadyMessage> > binaryHandler_;
75 std::auto_ptr< MessageHandler<IWebService::HttpRequestErrorMessage> > failureHandler_;
76 std::auto_ptr< Orthanc::IDynamicObject > userPayload_;
77
78 void NotifyConversionError(const IWebService::HttpRequestSuccessMessage& message) const
79 {
80 if (failureHandler_.get() != NULL)
81 {
82 failureHandler_->Apply(IWebService::HttpRequestErrorMessage
83 (message.GetUri(), userPayload_.get()));
84 }
85 }
86
87 public:
88 WebServicePayload(MessageHandler<EmptyResponseReadyMessage>* handler,
89 MessageHandler<IWebService::HttpRequestErrorMessage>* failureHandler,
90 Orthanc::IDynamicObject* userPayload) :
91 emptyHandler_(handler),
92 failureHandler_(failureHandler),
93 userPayload_(userPayload)
94 {
95 if (handler == NULL)
96 {
97 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
98 }
99 }
100
101 WebServicePayload(MessageHandler<BinaryResponseReadyMessage>* handler,
102 MessageHandler<IWebService::HttpRequestErrorMessage>* failureHandler,
103 Orthanc::IDynamicObject* userPayload) :
104 binaryHandler_(handler),
105 failureHandler_(failureHandler),
106 userPayload_(userPayload)
107 {
108 if (handler == NULL)
109 {
110 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
111 }
112 }
113
114 WebServicePayload(MessageHandler<JsonResponseReadyMessage>* handler,
115 MessageHandler<IWebService::HttpRequestErrorMessage>* failureHandler,
116 Orthanc::IDynamicObject* userPayload) :
117 jsonHandler_(handler),
118 failureHandler_(failureHandler),
119 userPayload_(userPayload)
120 {
121 if (handler == NULL)
122 {
123 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
124 }
125 }
126
127 void HandleSuccess(const IWebService::HttpRequestSuccessMessage& message) const
128 {
129 if (emptyHandler_.get() != NULL)
130 {
131 emptyHandler_->Apply(OrthancApiClient::EmptyResponseReadyMessage
132 (message.GetUri(), userPayload_.get()));
133 }
134 else if (binaryHandler_.get() != NULL)
135 {
136 binaryHandler_->Apply(OrthancApiClient::BinaryResponseReadyMessage
137 (message.GetUri(), message.GetAnswer(),
138 message.GetAnswerSize(), userPayload_.get()));
139 }
140 else if (jsonHandler_.get() != NULL)
141 {
142 Json::Value response;
143 if (MessagingToolbox::ParseJson(response, message.GetAnswer(), message.GetAnswerSize()))
144 {
145 jsonHandler_->Apply(OrthancApiClient::JsonResponseReadyMessage
146 (message.GetUri(), response, userPayload_.get()));
147 }
148 else
149 {
150 NotifyConversionError(message);
151 }
152 }
153 else
154 {
155 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
156 }
157 }
158
159 void HandleFailure(const IWebService::HttpRequestErrorMessage& message) const
160 {
161 if (failureHandler_.get() != NULL)
162 {
163 failureHandler_->Apply(IWebService::HttpRequestErrorMessage
164 (message.GetUri(), userPayload_.get()));
165 }
166 }
167 };
168
169
69 OrthancApiClient::OrthancApiClient(MessageBroker& broker, 170 OrthancApiClient::OrthancApiClient(MessageBroker& broker,
70 IWebService& orthanc) : 171 IWebService& orthanc) :
71 IObservable(broker), 172 IObservable(broker),
173 IObserver(broker),
72 orthanc_(orthanc) 174 orthanc_(orthanc)
73 { 175 {
74 } 176 }
75 177
76 // performs the translation between IWebService messages and OrthancApiClient messages 178
77 // TODO: handle destruction of this object (with shared_ptr ?::delete_later ???) 179 void OrthancApiClient::GetJsonAsync(
78 class HttpResponseToJsonConverter : public IObserver, IObservable 180 const std::string& uri,
79 { 181 MessageHandler<JsonResponseReadyMessage>* successCallback,
80 private: 182 MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallback,
81 std::auto_ptr<MessageHandler<OrthancApiClient::JsonResponseReadyMessage> > orthancApiSuccessCallback_; 183 Orthanc::IDynamicObject* payload)
82 std::auto_ptr<MessageHandler<IWebService::HttpRequestErrorMessage> > orthancApiFailureCallback_; 184 {
83 185 orthanc_.GetAsync(uri, IWebService::Headers(),
84 public: 186 new WebServicePayload(successCallback, failureCallback, payload),
85 HttpResponseToJsonConverter(MessageBroker& broker, 187 new Callable<OrthancApiClient, IWebService::HttpRequestSuccessMessage>
86 MessageHandler<OrthancApiClient::JsonResponseReadyMessage>* orthancApiSuccessCallback, 188 (*this, &OrthancApiClient::NotifyHttpSuccess),
87 MessageHandler<IWebService::HttpRequestErrorMessage>* orthancApiFailureCallback) 189 new Callable<OrthancApiClient, IWebService::HttpRequestErrorMessage>
88 : IObserver(broker), 190 (*this, &OrthancApiClient::NotifyHttpError));
89 IObservable(broker), 191 }
90 orthancApiSuccessCallback_(orthancApiSuccessCallback), 192
91 orthancApiFailureCallback_(orthancApiFailureCallback) 193
92 { 194 void OrthancApiClient::GetBinaryAsync(
93 } 195 const std::string& uri,
94 196 const std::string& contentType,
95 void ConvertResponseToJson(const IWebService::HttpRequestSuccessMessage& message) 197 MessageHandler<BinaryResponseReadyMessage>* successCallback,
96 { 198 MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallback,
97 Json::Value response; 199 Orthanc::IDynamicObject* payload)
98 if (MessagingToolbox::ParseJson(response, message.GetAnswer(), message.GetAnswerSize()))
99 {
100 if (orthancApiSuccessCallback_.get() != NULL)
101 {
102 orthancApiSuccessCallback_->Apply(OrthancApiClient::JsonResponseReadyMessage
103 (message.GetUri(), response, message.GetPayloadPointer()));
104 }
105 }
106 else if (orthancApiFailureCallback_.get() != NULL)
107 {
108 orthancApiFailureCallback_->Apply(IWebService::HttpRequestErrorMessage
109 (message.GetUri(), message.GetPayloadPointer()));
110 }
111
112 delete this; // hack untill we find someone to take ownership of this object (https://isocpp.org/wiki/faq/freestore-mgmt#delete-this)
113 }
114
115 void ConvertError(const IWebService::HttpRequestErrorMessage& message)
116 {
117 if (orthancApiFailureCallback_.get() != NULL)
118 {
119 orthancApiFailureCallback_->Apply(IWebService::HttpRequestErrorMessage(message.GetUri(), message.GetPayloadPointer()));
120 }
121
122 delete this; // hack untill we find someone to take ownership of this object (https://isocpp.org/wiki/faq/freestore-mgmt#delete-this)
123 }
124 };
125
126 // performs the translation between IWebService messages and OrthancApiClient messages
127 // TODO: handle destruction of this object (with shared_ptr ?::delete_later ???)
128 class HttpResponseToBinaryConverter : public IObserver, IObservable
129 {
130 private:
131 std::auto_ptr<MessageHandler<OrthancApiClient::BinaryResponseReadyMessage> > orthancApiSuccessCallback_;
132 std::auto_ptr<MessageHandler<IWebService::HttpRequestErrorMessage> > orthancApiFailureCallback_;
133
134 public:
135 HttpResponseToBinaryConverter(MessageBroker& broker,
136 MessageHandler<OrthancApiClient::BinaryResponseReadyMessage>* orthancApiSuccessCallback,
137 MessageHandler<IWebService::HttpRequestErrorMessage>* orthancApiFailureCallback)
138 : IObserver(broker),
139 IObservable(broker),
140 orthancApiSuccessCallback_(orthancApiSuccessCallback),
141 orthancApiFailureCallback_(orthancApiFailureCallback)
142 {
143 }
144
145 void ConvertResponseToBinary(const IWebService::HttpRequestSuccessMessage& message)
146 {
147 if (orthancApiSuccessCallback_.get() != NULL)
148 {
149 orthancApiSuccessCallback_->Apply(OrthancApiClient::BinaryResponseReadyMessage
150 (message.GetUri(), message.GetAnswer(),
151 message.GetAnswerSize(), message.GetPayloadPointer()));
152 }
153 else if (orthancApiFailureCallback_.get() != NULL)
154 {
155 orthancApiFailureCallback_->Apply(IWebService::HttpRequestErrorMessage
156 (message.GetUri(), message.GetPayloadPointer()));
157 }
158
159 delete this; // hack untill we find someone to take ownership of this object (https://isocpp.org/wiki/faq/freestore-mgmt#delete-this)
160 }
161
162 void ConvertError(const IWebService::HttpRequestErrorMessage& message)
163 {
164 if (orthancApiFailureCallback_.get() != NULL)
165 {
166 orthancApiFailureCallback_->Apply(IWebService::HttpRequestErrorMessage(message.GetUri(), message.GetPayloadPointer()));
167 }
168
169 delete this; // hack untill we find someone to take ownership of this object (https://isocpp.org/wiki/faq/freestore-mgmt#delete-this)
170 }
171 };
172
173 // performs the translation between IWebService messages and OrthancApiClient messages
174 // TODO: handle destruction of this object (with shared_ptr ?::delete_later ???)
175 class HttpResponseToEmptyConverter : public IObserver, IObservable
176 {
177 private:
178 std::auto_ptr<MessageHandler<OrthancApiClient::EmptyResponseReadyMessage> > orthancApiSuccessCallback_;
179 std::auto_ptr<MessageHandler<IWebService::HttpRequestErrorMessage> > orthancApiFailureCallback_;
180
181 public:
182 HttpResponseToEmptyConverter(MessageBroker& broker,
183 MessageHandler<OrthancApiClient::EmptyResponseReadyMessage>* orthancApiSuccessCallback,
184 MessageHandler<IWebService::HttpRequestErrorMessage>* orthancApiFailureCallback)
185 : IObserver(broker),
186 IObservable(broker),
187 orthancApiSuccessCallback_(orthancApiSuccessCallback),
188 orthancApiFailureCallback_(orthancApiFailureCallback)
189 {
190 }
191
192 void ConvertResponseToEmpty(const IWebService::HttpRequestSuccessMessage& message)
193 {
194 if (orthancApiSuccessCallback_.get() != NULL)
195 {
196 orthancApiSuccessCallback_->Apply(OrthancApiClient::EmptyResponseReadyMessage
197 (message.GetUri(), message.GetPayloadPointer()));
198 }
199 else if (orthancApiFailureCallback_.get() != NULL)
200 {
201 orthancApiFailureCallback_->Apply(IWebService::HttpRequestErrorMessage
202 (message.GetUri(), message.GetPayloadPointer()));
203 }
204
205 delete this; // hack untill we find someone to take ownership of this object (https://isocpp.org/wiki/faq/freestore-mgmt#delete-this)
206 }
207
208 void ConvertError(const IWebService::HttpRequestErrorMessage& message)
209 {
210 if (orthancApiFailureCallback_.get() != NULL)
211 {
212 orthancApiFailureCallback_->Apply(IWebService::HttpRequestErrorMessage(message.GetUri(), message.GetPayloadPointer()));
213 }
214
215 delete this; // hack untill we find someone to take ownership of this object (https://isocpp.org/wiki/faq/freestore-mgmt#delete-this)
216 }
217 };
218
219
220 void OrthancApiClient::GetJsonAsync(const std::string& uri,
221 MessageHandler<JsonResponseReadyMessage>* successCallback,
222 MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallback,
223 Orthanc::IDynamicObject* payload)
224 {
225 HttpResponseToJsonConverter* converter = new HttpResponseToJsonConverter(broker_, successCallback, failureCallback); // it is currently deleting itself after being used
226 orthanc_.GetAsync(uri, IWebService::Headers(), payload,
227 new Callable<HttpResponseToJsonConverter, IWebService::HttpRequestSuccessMessage>(*converter, &HttpResponseToJsonConverter::ConvertResponseToJson),
228 new Callable<HttpResponseToJsonConverter, IWebService::HttpRequestErrorMessage>(*converter, &HttpResponseToJsonConverter::ConvertError));
229
230 }
231
232
233 void OrthancApiClient::GetBinaryAsync(const std::string& uri,
234 const std::string& contentType,
235 MessageHandler<BinaryResponseReadyMessage>* successCallback,
236 MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallback,
237 Orthanc::IDynamicObject* payload)
238 { 200 {
239 IWebService::Headers headers; 201 IWebService::Headers headers;
240 headers["Accept"] = contentType; 202 headers["Accept"] = contentType;
241 GetBinaryAsync(uri, headers, successCallback, failureCallback, payload); 203 GetBinaryAsync(uri, headers, successCallback, failureCallback, payload);
242 } 204 }
243 205
244 206
245 void OrthancApiClient::GetBinaryAsync(const std::string& uri, 207 void OrthancApiClient::GetBinaryAsync(
246 const IWebService::Headers& headers, 208 const std::string& uri,
247 MessageHandler<BinaryResponseReadyMessage>* successCallback, 209 const IWebService::Headers& headers,
248 MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallback, 210 MessageHandler<BinaryResponseReadyMessage>* successCallback,
249 Orthanc::IDynamicObject* payload) 211 MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallback,
250 { 212 Orthanc::IDynamicObject* payload)
251 HttpResponseToBinaryConverter* converter = new HttpResponseToBinaryConverter(broker_, successCallback, failureCallback); // it is currently deleting itself after being used 213 {
252 orthanc_.GetAsync(uri, headers, payload, 214 orthanc_.GetAsync(uri, headers,
253 new Callable<HttpResponseToBinaryConverter, IWebService::HttpRequestSuccessMessage>(*converter, &HttpResponseToBinaryConverter::ConvertResponseToBinary), 215 new WebServicePayload(successCallback, failureCallback, payload),
254 new Callable<HttpResponseToBinaryConverter, IWebService::HttpRequestErrorMessage>(*converter, &HttpResponseToBinaryConverter::ConvertError)); 216 new Callable<OrthancApiClient, IWebService::HttpRequestSuccessMessage>
255 } 217 (*this, &OrthancApiClient::NotifyHttpSuccess),
256 218 new Callable<OrthancApiClient, IWebService::HttpRequestErrorMessage>
257 219 (*this, &OrthancApiClient::NotifyHttpError));
258 void OrthancApiClient::PostBinaryAsyncExpectJson(const std::string& uri, 220 }
259 const std::string& body, 221
260 MessageHandler<JsonResponseReadyMessage>* successCallback, 222
261 MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallback, 223 void OrthancApiClient::PostBinaryAsyncExpectJson(
262 Orthanc::IDynamicObject* payload) 224 const std::string& uri,
263 { 225 const std::string& body,
264 HttpResponseToJsonConverter* converter = new HttpResponseToJsonConverter(broker_, successCallback, failureCallback); // it is currently deleting itself after being used 226 MessageHandler<JsonResponseReadyMessage>* successCallback,
265 orthanc_.PostAsync(uri, IWebService::Headers(), body, payload, 227 MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallback,
266 new Callable<HttpResponseToJsonConverter, IWebService::HttpRequestSuccessMessage>(*converter, &HttpResponseToJsonConverter::ConvertResponseToJson), 228 Orthanc::IDynamicObject* payload)
267 new Callable<HttpResponseToJsonConverter, IWebService::HttpRequestErrorMessage>(*converter, &HttpResponseToJsonConverter::ConvertError)); 229 {
268 230 orthanc_.PostAsync(uri, IWebService::Headers(), body,
269 } 231 new WebServicePayload(successCallback, failureCallback, payload),
270 232 new Callable<OrthancApiClient, IWebService::HttpRequestSuccessMessage>
271 233 (*this, &OrthancApiClient::NotifyHttpSuccess),
272 void OrthancApiClient::PostJsonAsyncExpectJson(const std::string& uri, 234 new Callable<OrthancApiClient, IWebService::HttpRequestErrorMessage>
273 const Json::Value& data, 235 (*this, &OrthancApiClient::NotifyHttpError));
274 MessageHandler<JsonResponseReadyMessage>* successCallback, 236
275 MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallback, 237 }
276 Orthanc::IDynamicObject* payload) 238
239
240 void OrthancApiClient::PostJsonAsyncExpectJson(
241 const std::string& uri,
242 const Json::Value& data,
243 MessageHandler<JsonResponseReadyMessage>* successCallback,
244 MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallback,
245 Orthanc::IDynamicObject* payload)
277 { 246 {
278 std::string body; 247 std::string body;
279 MessagingToolbox::JsonToString(body, data); 248 MessagingToolbox::JsonToString(body, data);
280 return PostBinaryAsyncExpectJson(uri, body, successCallback, failureCallback, payload); 249 return PostBinaryAsyncExpectJson(uri, body, successCallback, failureCallback, payload);
281 } 250 }
282 251
283 252
284 void OrthancApiClient::DeleteAsync(const std::string& uri, 253 void OrthancApiClient::DeleteAsync(
285 MessageHandler<EmptyResponseReadyMessage>* successCallback, 254 const std::string& uri,
286 MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallback, 255 MessageHandler<EmptyResponseReadyMessage>* successCallback,
287 Orthanc::IDynamicObject* payload) 256 MessageHandler<IWebService::HttpRequestErrorMessage>* failureCallback,
288 { 257 Orthanc::IDynamicObject* payload)
289 HttpResponseToEmptyConverter* converter = new HttpResponseToEmptyConverter(broker_, successCallback, failureCallback); // it is currently deleting itself after being used 258 {
290 orthanc_.DeleteAsync(uri, IWebService::Headers(), payload, 259 orthanc_.DeleteAsync(uri, IWebService::Headers(),
291 new Callable<HttpResponseToEmptyConverter, IWebService::HttpRequestSuccessMessage>(*converter, &HttpResponseToEmptyConverter::ConvertResponseToEmpty), 260 new WebServicePayload(successCallback, failureCallback, payload),
292 new Callable<HttpResponseToEmptyConverter, IWebService::HttpRequestErrorMessage>(*converter, &HttpResponseToEmptyConverter::ConvertError)); 261 new Callable<OrthancApiClient, IWebService::HttpRequestSuccessMessage>
293 } 262 (*this, &OrthancApiClient::NotifyHttpSuccess),
294 263 new Callable<OrthancApiClient, IWebService::HttpRequestErrorMessage>
295 264 (*this, &OrthancApiClient::NotifyHttpError));
296 class OrthancApiClient::WebServicePayload : public boost::noncopyable 265 }
297 { 266
298 private: 267
299 std::auto_ptr< MessageHandler<EmptyResponseReadyMessage> > emptyHandler_; 268 void OrthancApiClient::NotifyHttpSuccess(const IWebService::HttpRequestSuccessMessage& message)
300 std::auto_ptr< MessageHandler<JsonResponseReadyMessage> > jsonHandler_; 269 {
301 std::auto_ptr< MessageHandler<BinaryResponseReadyMessage> > binaryHandler_; 270 if (message.HasPayload())
302 std::auto_ptr< Orthanc::IDynamicObject > userPayload; 271 {
303 }; 272 dynamic_cast<const WebServicePayload&>(message.GetPayload()).HandleSuccess(message);
273 }
274 else
275 {
276 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
277 }
278 }
279
280
281 void OrthancApiClient::NotifyHttpError(const IWebService::HttpRequestErrorMessage& message)
282 {
283 if (message.HasPayload())
284 {
285 dynamic_cast<const WebServicePayload&>(message.GetPayload()).HandleFailure(message);
286 }
287 else
288 {
289 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
290 }
291 }
304 } 292 }