Mercurial > hg > orthanc
annotate Plugins/Samples/Common/OrthancPluginCppWrapper.cpp @ 3416:541c787e2230
reorganization
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Tue, 11 Jun 2019 21:38:34 +0200 |
parents | b9cba6a91780 |
children | e2b032584a83 |
rev | line source |
---|---|
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
1 /** |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
2 * Orthanc - A Lightweight, RESTful DICOM Store |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
4 * Department, University Hospital of Liege, Belgium |
3060
4e43e67f8ecf
preparing for 2019
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3039
diff
changeset
|
5 * Copyright (C) 2017-2019 Osimis S.A., Belgium |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
6 * |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
7 * This program is free software: you can redistribute it and/or |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
8 * modify it under the terms of the GNU General Public License as |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
9 * published by the Free Software Foundation, either version 3 of the |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
10 * License, or (at your option) any later version. |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
11 * |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
12 * In addition, as a special exception, the copyright holders of this |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
13 * program give permission to link the code of its release with the |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
14 * OpenSSL project's "OpenSSL" library (or with modified versions of it |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
15 * that use the same license as the "OpenSSL" library), and distribute |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
16 * the linked executables. You must obey the GNU General Public License |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
17 * in all respects for all of the code used other than "OpenSSL". If you |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
18 * modify file(s) with this exception, you may extend this exception to |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
19 * your version of the file(s), but you are not obligated to do so. If |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
20 * you do not wish to do so, delete this exception statement from your |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
21 * version. If you delete this exception statement from all source files |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
22 * in the program, then also delete it here. |
2850 | 23 * |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
24 * This program is distributed in the hope that it will be useful, but |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
25 * WITHOUT ANY WARRANTY; without even the implied warranty of |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
27 * General Public License for more details. |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
28 * |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
29 * You should have received a copy of the GNU General Public License |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
30 * along with this program. If not, see <http://www.gnu.org/licenses/>. |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
31 **/ |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
32 |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
33 |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
34 #include "OrthancPluginCppWrapper.h" |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
35 |
3394 | 36 #include <boost/algorithm/string/predicate.hpp> |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
37 #include <json/reader.h> |
2058
43cd2ab060c7
cont OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2048
diff
changeset
|
38 #include <json/writer.h> |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
39 |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
40 |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
41 namespace OrthancPlugins |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
42 { |
3028 | 43 static OrthancPluginContext* globalContext_ = NULL; |
2958
bb7a66efbeb1
OrthancPlugins::SetGlobalContext() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2851
diff
changeset
|
44 |
bb7a66efbeb1
OrthancPlugins::SetGlobalContext() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2851
diff
changeset
|
45 |
3028 | 46 void SetGlobalContext(OrthancPluginContext* context) |
2958
bb7a66efbeb1
OrthancPlugins::SetGlobalContext() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2851
diff
changeset
|
47 { |
3028 | 48 if (context == NULL) |
49 { | |
50 ORTHANC_PLUGINS_THROW_EXCEPTION(NullPointer); | |
51 } | |
52 else if (globalContext_ == NULL) | |
53 { | |
54 globalContext_ = context; | |
55 } | |
56 else | |
57 { | |
58 ORTHANC_PLUGINS_THROW_EXCEPTION(BadSequenceOfCalls); | |
59 } | |
3026 | 60 } |
61 | |
62 | |
3028 | 63 bool HasGlobalContext() |
64 { | |
65 return globalContext_ != NULL; | |
66 } | |
67 | |
68 | |
69 OrthancPluginContext* GetGlobalContext() | |
70 { | |
71 if (globalContext_ == NULL) | |
72 { | |
73 ORTHANC_PLUGINS_THROW_EXCEPTION(BadSequenceOfCalls); | |
74 } | |
75 else | |
76 { | |
77 return globalContext_; | |
78 } | |
79 } | |
2958
bb7a66efbeb1
OrthancPlugins::SetGlobalContext() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2851
diff
changeset
|
80 |
bb7a66efbeb1
OrthancPlugins::SetGlobalContext() in OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2851
diff
changeset
|
81 |
3028 | 82 void MemoryBuffer::Check(OrthancPluginErrorCode code) |
2062
40ffd0e8676a
generation of etag in ServeFolders
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2059
diff
changeset
|
83 { |
3028 | 84 if (code != OrthancPluginErrorCode_Success) |
85 { | |
86 // Prevent using garbage information | |
87 buffer_.data = NULL; | |
88 buffer_.size = 0; | |
89 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(code); | |
90 } | |
2062
40ffd0e8676a
generation of etag in ServeFolders
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2059
diff
changeset
|
91 } |
40ffd0e8676a
generation of etag in ServeFolders
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2059
diff
changeset
|
92 |
40ffd0e8676a
generation of etag in ServeFolders
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2059
diff
changeset
|
93 |
3028 | 94 bool MemoryBuffer::CheckHttp(OrthancPluginErrorCode code) |
2264
8e5e0de75839
primitives for HTTP client in plugin C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2263
diff
changeset
|
95 { |
3028 | 96 if (code != OrthancPluginErrorCode_Success) |
97 { | |
98 // Prevent using garbage information | |
99 buffer_.data = NULL; | |
100 buffer_.size = 0; | |
101 } | |
102 | |
103 if (code == OrthancPluginErrorCode_Success) | |
104 { | |
105 return true; | |
106 } | |
107 else if (code == OrthancPluginErrorCode_UnknownResource || | |
108 code == OrthancPluginErrorCode_InexistentItem) | |
109 { | |
110 return false; | |
111 } | |
112 else | |
113 { | |
114 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(code); | |
115 } | |
2264
8e5e0de75839
primitives for HTTP client in plugin C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2263
diff
changeset
|
116 } |
8e5e0de75839
primitives for HTTP client in plugin C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2263
diff
changeset
|
117 |
8e5e0de75839
primitives for HTTP client in plugin C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2263
diff
changeset
|
118 |
3028 | 119 MemoryBuffer::MemoryBuffer() |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
120 { |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
121 buffer_.data = NULL; |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
122 buffer_.size = 0; |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
123 } |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
124 |
3028 | 125 |
126 void MemoryBuffer::Clear() | |
3026 | 127 { |
3028 | 128 if (buffer_.data != NULL) |
129 { | |
130 OrthancPluginFreeMemoryBuffer(GetGlobalContext(), &buffer_); | |
131 buffer_.data = NULL; | |
132 buffer_.size = 0; | |
133 } | |
3026 | 134 } |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
135 |
3026 | 136 |
3028 | 137 void MemoryBuffer::Assign(OrthancPluginMemoryBuffer& other) |
138 { | |
139 Clear(); | |
140 | |
141 buffer_.data = other.data; | |
142 buffer_.size = other.size; | |
143 | |
144 other.data = NULL; | |
145 other.size = 0; | |
146 } | |
3026 | 147 |
148 | |
3320 | 149 void MemoryBuffer::Swap(MemoryBuffer& other) |
150 { | |
151 std::swap(buffer_.data, other.buffer_.data); | |
152 std::swap(buffer_.size, other.buffer_.size); | |
153 } | |
154 | |
155 | |
3028 | 156 OrthancPluginMemoryBuffer MemoryBuffer::Release() |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
157 { |
3028 | 158 OrthancPluginMemoryBuffer result = buffer_; |
159 | |
3026 | 160 buffer_.data = NULL; |
161 buffer_.size = 0; | |
3028 | 162 |
163 return result; | |
3026 | 164 } |
3028 | 165 |
166 | |
167 void MemoryBuffer::ToString(std::string& target) const | |
168 { | |
169 if (buffer_.size == 0) | |
170 { | |
171 target.clear(); | |
172 } | |
173 else | |
174 { | |
175 target.assign(reinterpret_cast<const char*>(buffer_.data), buffer_.size); | |
176 } | |
177 } | |
3026 | 178 |
179 | |
3028 | 180 void MemoryBuffer::ToJson(Json::Value& target) const |
181 { | |
182 if (buffer_.data == NULL || | |
183 buffer_.size == 0) | |
184 { | |
185 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); | |
186 } | |
3026 | 187 |
3028 | 188 const char* tmp = reinterpret_cast<const char*>(buffer_.data); |
3026 | 189 |
3028 | 190 Json::Reader reader; |
191 if (!reader.parse(tmp, tmp + buffer_.size, target)) | |
192 { | |
193 LogError("Cannot convert some memory buffer to JSON"); | |
194 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); | |
195 } | |
196 } | |
3026 | 197 |
198 | |
3028 | 199 bool MemoryBuffer::RestApiGet(const std::string& uri, |
200 bool applyPlugins) | |
3026 | 201 { |
3028 | 202 Clear(); |
3026 | 203 |
3028 | 204 if (applyPlugins) |
205 { | |
206 return CheckHttp(OrthancPluginRestApiGetAfterPlugins(GetGlobalContext(), &buffer_, uri.c_str())); | |
207 } | |
208 else | |
209 { | |
210 return CheckHttp(OrthancPluginRestApiGet(GetGlobalContext(), &buffer_, uri.c_str())); | |
211 } | |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
212 } |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
213 |
3028 | 214 bool MemoryBuffer::RestApiGet(const std::string& uri, |
215 const std::map<std::string, std::string>& httpHeaders, | |
216 bool applyPlugins) | |
3026 | 217 { |
3028 | 218 Clear(); |
219 | |
220 std::vector<const char*> headersKeys; | |
221 std::vector<const char*> headersValues; | |
3039 | 222 |
223 for (std::map<std::string, std::string>::const_iterator | |
224 it = httpHeaders.begin(); it != httpHeaders.end(); it++) | |
3028 | 225 { |
226 headersKeys.push_back(it->first.c_str()); | |
227 headersValues.push_back(it->second.c_str()); | |
228 } | |
229 | |
3039 | 230 return CheckHttp(OrthancPluginRestApiGet2( |
231 GetGlobalContext(), &buffer_, uri.c_str(), httpHeaders.size(), | |
232 (headersKeys.empty() ? NULL : &headersKeys[0]), | |
233 (headersValues.empty() ? NULL : &headersValues[0]), applyPlugins)); | |
3026 | 234 } |
3028 | 235 |
236 bool MemoryBuffer::RestApiPost(const std::string& uri, | |
3400
0faae6f6e3c5
fixed some inconsistencies with pointer types in the plugin sdk
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3399
diff
changeset
|
237 const void* body, |
3028 | 238 size_t bodySize, |
239 bool applyPlugins) | |
240 { | |
241 Clear(); | |
3405
408ffcb4038f
reorganizing build instructions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3404
diff
changeset
|
242 |
408ffcb4038f
reorganizing build instructions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3404
diff
changeset
|
243 // Cast for compatibility with Orthanc SDK <= 1.5.6 |
408ffcb4038f
reorganizing build instructions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3404
diff
changeset
|
244 const char* b = reinterpret_cast<const char*>(body); |
3028 | 245 |
246 if (applyPlugins) | |
247 { | |
3405
408ffcb4038f
reorganizing build instructions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3404
diff
changeset
|
248 return CheckHttp(OrthancPluginRestApiPostAfterPlugins(GetGlobalContext(), &buffer_, uri.c_str(), b, bodySize)); |
3028 | 249 } |
250 else | |
251 { | |
3405
408ffcb4038f
reorganizing build instructions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3404
diff
changeset
|
252 return CheckHttp(OrthancPluginRestApiPost(GetGlobalContext(), &buffer_, uri.c_str(), b, bodySize)); |
3028 | 253 } |
254 } | |
3026 | 255 |
256 | |
3028 | 257 bool MemoryBuffer::RestApiPut(const std::string& uri, |
3400
0faae6f6e3c5
fixed some inconsistencies with pointer types in the plugin sdk
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3399
diff
changeset
|
258 const void* body, |
3028 | 259 size_t bodySize, |
260 bool applyPlugins) | |
261 { | |
262 Clear(); | |
3026 | 263 |
3405
408ffcb4038f
reorganizing build instructions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3404
diff
changeset
|
264 // Cast for compatibility with Orthanc SDK <= 1.5.6 |
408ffcb4038f
reorganizing build instructions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3404
diff
changeset
|
265 const char* b = reinterpret_cast<const char*>(body); |
408ffcb4038f
reorganizing build instructions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3404
diff
changeset
|
266 |
3028 | 267 if (applyPlugins) |
268 { | |
3405
408ffcb4038f
reorganizing build instructions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3404
diff
changeset
|
269 return CheckHttp(OrthancPluginRestApiPutAfterPlugins(GetGlobalContext(), &buffer_, uri.c_str(), b, bodySize)); |
3028 | 270 } |
271 else | |
272 { | |
3405
408ffcb4038f
reorganizing build instructions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3404
diff
changeset
|
273 return CheckHttp(OrthancPluginRestApiPut(GetGlobalContext(), &buffer_, uri.c_str(), b, bodySize)); |
3028 | 274 } |
3026 | 275 } |
3028 | 276 |
3026 | 277 |
3028 | 278 bool MemoryBuffer::RestApiPost(const std::string& uri, |
279 const Json::Value& body, | |
280 bool applyPlugins) | |
3026 | 281 { |
3028 | 282 Json::FastWriter writer; |
283 return RestApiPost(uri, writer.write(body), applyPlugins); | |
3026 | 284 } |
285 | |
3028 | 286 |
287 bool MemoryBuffer::RestApiPut(const std::string& uri, | |
288 const Json::Value& body, | |
289 bool applyPlugins) | |
290 { | |
291 Json::FastWriter writer; | |
292 return RestApiPut(uri, writer.write(body), applyPlugins); | |
293 } | |
3026 | 294 |
3028 | 295 |
296 void MemoryBuffer::CreateDicom(const Json::Value& tags, | |
297 OrthancPluginCreateDicomFlags flags) | |
298 { | |
299 Clear(); | |
300 | |
301 Json::FastWriter writer; | |
302 std::string s = writer.write(tags); | |
3026 | 303 |
3028 | 304 Check(OrthancPluginCreateDicom(GetGlobalContext(), &buffer_, s.c_str(), NULL, flags)); |
3026 | 305 } |
3028 | 306 |
307 void MemoryBuffer::CreateDicom(const Json::Value& tags, | |
308 const OrthancImage& pixelData, | |
309 OrthancPluginCreateDicomFlags flags) | |
3026 | 310 { |
3028 | 311 Clear(); |
312 | |
313 Json::FastWriter writer; | |
314 std::string s = writer.write(tags); | |
315 | |
316 Check(OrthancPluginCreateDicom(GetGlobalContext(), &buffer_, s.c_str(), pixelData.GetObject(), flags)); | |
3026 | 317 } |
3028 | 318 |
319 | |
320 void MemoryBuffer::ReadFile(const std::string& path) | |
321 { | |
322 Clear(); | |
323 Check(OrthancPluginReadFile(GetGlobalContext(), &buffer_, path.c_str())); | |
324 } | |
3026 | 325 |
326 | |
3028 | 327 void MemoryBuffer::GetDicomQuery(const OrthancPluginWorklistQuery* query) |
3026 | 328 { |
3028 | 329 Clear(); |
330 Check(OrthancPluginWorklistGetDicomQuery(GetGlobalContext(), &buffer_, query)); | |
3026 | 331 } |
332 | |
333 | |
3028 | 334 void OrthancString::Assign(char* str) |
335 { | |
336 if (str == NULL) | |
337 { | |
338 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); | |
339 } | |
340 else | |
341 { | |
342 Clear(); | |
343 str_ = str; | |
344 } | |
345 } | |
3026 | 346 |
347 | |
3028 | 348 void OrthancString::Clear() |
349 { | |
350 if (str_ != NULL) | |
351 { | |
352 OrthancPluginFreeString(GetGlobalContext(), str_); | |
353 str_ = NULL; | |
354 } | |
355 } | |
3026 | 356 |
357 | |
3028 | 358 void OrthancString::ToString(std::string& target) const |
359 { | |
360 if (str_ == NULL) | |
361 { | |
362 target.clear(); | |
363 } | |
364 else | |
365 { | |
366 target.assign(str_); | |
367 } | |
368 } | |
3026 | 369 |
370 | |
3028 | 371 void OrthancString::ToJson(Json::Value& target) const |
372 { | |
373 if (str_ == NULL) | |
374 { | |
375 LogError("Cannot convert an empty memory buffer to JSON"); | |
376 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); | |
377 } | |
378 | |
379 Json::Reader reader; | |
380 if (!reader.parse(str_, target)) | |
381 { | |
382 LogError("Cannot convert some memory buffer to JSON"); | |
383 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); | |
384 } | |
385 } | |
3026 | 386 |
387 | |
3028 | 388 void MemoryBuffer::DicomToJson(Json::Value& target, |
389 OrthancPluginDicomToJsonFormat format, | |
390 OrthancPluginDicomToJsonFlags flags, | |
391 uint32_t maxStringLength) | |
392 { | |
393 OrthancString str; | |
394 str.Assign(OrthancPluginDicomBufferToJson | |
395 (GetGlobalContext(), GetData(), GetSize(), format, flags, maxStringLength)); | |
396 str.ToJson(target); | |
397 } | |
3026 | 398 |
399 | |
3028 | 400 bool MemoryBuffer::HttpGet(const std::string& url, |
401 const std::string& username, | |
402 const std::string& password) | |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
403 { |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
404 Clear(); |
3028 | 405 return CheckHttp(OrthancPluginHttpGet(GetGlobalContext(), &buffer_, url.c_str(), |
406 username.empty() ? NULL : username.c_str(), | |
407 password.empty() ? NULL : password.c_str())); | |
3026 | 408 } |
409 | |
410 | |
3028 | 411 bool MemoryBuffer::HttpPost(const std::string& url, |
412 const std::string& body, | |
413 const std::string& username, | |
414 const std::string& password) | |
3026 | 415 { |
3028 | 416 Clear(); |
417 return CheckHttp(OrthancPluginHttpPost(GetGlobalContext(), &buffer_, url.c_str(), | |
418 body.c_str(), body.size(), | |
419 username.empty() ? NULL : username.c_str(), | |
420 password.empty() ? NULL : password.c_str())); | |
3026 | 421 } |
422 | |
423 | |
3028 | 424 bool MemoryBuffer::HttpPut(const std::string& url, |
425 const std::string& body, | |
426 const std::string& username, | |
427 const std::string& password) | |
3026 | 428 { |
3028 | 429 Clear(); |
430 return CheckHttp(OrthancPluginHttpPut(GetGlobalContext(), &buffer_, url.c_str(), | |
431 body.empty() ? NULL : body.c_str(), | |
432 body.size(), | |
433 username.empty() ? NULL : username.c_str(), | |
434 password.empty() ? NULL : password.c_str())); | |
3026 | 435 } |
436 | |
3028 | 437 |
438 void MemoryBuffer::GetDicomInstance(const std::string& instanceId) | |
3026 | 439 { |
3028 | 440 Clear(); |
441 Check(OrthancPluginGetDicomForInstance(GetGlobalContext(), &buffer_, instanceId.c_str())); | |
3026 | 442 } |
443 | |
444 | |
3028 | 445 bool HttpDelete(const std::string& url, |
446 const std::string& username, | |
447 const std::string& password) | |
448 { | |
449 OrthancPluginErrorCode error = OrthancPluginHttpDelete | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
450 (GetGlobalContext(), url.c_str(), |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
451 username.empty() ? NULL : username.c_str(), |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
452 password.empty() ? NULL : password.c_str()); |
3028 | 453 |
454 if (error == OrthancPluginErrorCode_Success) | |
455 { | |
456 return true; | |
457 } | |
458 else if (error == OrthancPluginErrorCode_UnknownResource || | |
459 error == OrthancPluginErrorCode_InexistentItem) | |
460 { | |
461 return false; | |
462 } | |
463 else | |
464 { | |
465 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(error); | |
466 } | |
467 } | |
3026 | 468 |
469 | |
3028 | 470 void LogError(const std::string& message) |
471 { | |
472 if (HasGlobalContext()) | |
473 { | |
474 OrthancPluginLogError(GetGlobalContext(), message.c_str()); | |
475 } | |
476 } | |
3026 | 477 |
478 | |
3028 | 479 void LogWarning(const std::string& message) |
480 { | |
481 if (HasGlobalContext()) | |
482 { | |
483 OrthancPluginLogWarning(GetGlobalContext(), message.c_str()); | |
484 } | |
485 } | |
486 | |
487 | |
488 void LogInfo(const std::string& message) | |
489 { | |
490 if (HasGlobalContext()) | |
491 { | |
492 OrthancPluginLogInfo(GetGlobalContext(), message.c_str()); | |
493 } | |
494 } | |
3026 | 495 |
496 | |
3028 | 497 OrthancConfiguration::OrthancConfiguration() |
498 { | |
499 OrthancString str; | |
500 str.Assign(OrthancPluginGetConfiguration(GetGlobalContext())); | |
3026 | 501 |
3028 | 502 if (str.GetContent() == NULL) |
503 { | |
504 LogError("Cannot access the Orthanc configuration"); | |
505 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); | |
506 } | |
3026 | 507 |
3028 | 508 str.ToJson(configuration_); |
509 | |
510 if (configuration_.type() != Json::objectValue) | |
511 { | |
512 LogError("Unable to read the Orthanc configuration"); | |
513 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); | |
514 } | |
515 } | |
3026 | 516 |
517 | |
3028 | 518 std::string OrthancConfiguration::GetPath(const std::string& key) const |
3026 | 519 { |
3028 | 520 if (path_.empty()) |
521 { | |
522 return key; | |
523 } | |
524 else | |
525 { | |
526 return path_ + "." + key; | |
527 } | |
3026 | 528 } |
3028 | 529 |
530 | |
531 bool OrthancConfiguration::IsSection(const std::string& key) const | |
3026 | 532 { |
3028 | 533 assert(configuration_.type() == Json::objectValue); |
534 | |
535 return (configuration_.isMember(key) && | |
536 configuration_[key].type() == Json::objectValue); | |
3026 | 537 } |
538 | |
539 | |
3028 | 540 void OrthancConfiguration::GetSection(OrthancConfiguration& target, |
541 const std::string& key) const | |
3026 | 542 { |
3028 | 543 assert(configuration_.type() == Json::objectValue); |
3026 | 544 |
3028 | 545 target.path_ = GetPath(key); |
3026 | 546 |
3028 | 547 if (!configuration_.isMember(key)) |
548 { | |
549 target.configuration_ = Json::objectValue; | |
550 } | |
551 else | |
552 { | |
553 if (configuration_[key].type() != Json::objectValue) | |
554 { | |
555 LogError("The configuration section \"" + target.path_ + | |
556 "\" is not an associative array as expected"); | |
557 | |
558 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); | |
559 } | |
560 | |
561 target.configuration_ = configuration_[key]; | |
562 } | |
3026 | 563 } |
564 | |
565 | |
3028 | 566 bool OrthancConfiguration::LookupStringValue(std::string& target, |
567 const std::string& key) const | |
568 { | |
569 assert(configuration_.type() == Json::objectValue); | |
570 | |
571 if (!configuration_.isMember(key)) | |
572 { | |
573 return false; | |
574 } | |
3026 | 575 |
3028 | 576 if (configuration_[key].type() != Json::stringValue) |
577 { | |
578 LogError("The configuration option \"" + GetPath(key) + | |
579 "\" is not a string as expected"); | |
580 | |
581 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); | |
582 } | |
583 | |
584 target = configuration_[key].asString(); | |
585 return true; | |
3026 | 586 } |
587 | |
588 | |
3028 | 589 bool OrthancConfiguration::LookupIntegerValue(int& target, |
590 const std::string& key) const | |
3026 | 591 { |
3028 | 592 assert(configuration_.type() == Json::objectValue); |
593 | |
594 if (!configuration_.isMember(key)) | |
595 { | |
596 return false; | |
597 } | |
598 | |
599 switch (configuration_[key].type()) | |
600 { | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
601 case Json::intValue: |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
602 target = configuration_[key].asInt(); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
603 return true; |
3028 | 604 |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
605 case Json::uintValue: |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
606 target = configuration_[key].asUInt(); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
607 return true; |
3028 | 608 |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
609 default: |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
610 LogError("The configuration option \"" + GetPath(key) + |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
611 "\" is not an integer as expected"); |
3028 | 612 |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
613 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); |
3028 | 614 } |
3026 | 615 } |
616 | |
617 | |
3028 | 618 bool OrthancConfiguration::LookupUnsignedIntegerValue(unsigned int& target, |
619 const std::string& key) const | |
620 { | |
621 int tmp; | |
622 if (!LookupIntegerValue(tmp, key)) | |
623 { | |
624 return false; | |
625 } | |
3026 | 626 |
3028 | 627 if (tmp < 0) |
628 { | |
629 LogError("The configuration option \"" + GetPath(key) + | |
630 "\" is not a positive integer as expected"); | |
631 | |
632 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); | |
633 } | |
634 else | |
635 { | |
636 target = static_cast<unsigned int>(tmp); | |
637 return true; | |
638 } | |
639 } | |
3026 | 640 |
641 | |
3028 | 642 bool OrthancConfiguration::LookupBooleanValue(bool& target, |
643 const std::string& key) const | |
3026 | 644 { |
3028 | 645 assert(configuration_.type() == Json::objectValue); |
646 | |
647 if (!configuration_.isMember(key)) | |
3026 | 648 { |
3028 | 649 return false; |
650 } | |
651 | |
652 if (configuration_[key].type() != Json::booleanValue) | |
653 { | |
654 LogError("The configuration option \"" + GetPath(key) + | |
655 "\" is not a Boolean as expected"); | |
3026 | 656 |
657 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); | |
658 } | |
659 | |
3028 | 660 target = configuration_[key].asBool(); |
661 return true; | |
3026 | 662 } |
3028 | 663 |
664 | |
665 bool OrthancConfiguration::LookupFloatValue(float& target, | |
666 const std::string& key) const | |
667 { | |
668 assert(configuration_.type() == Json::objectValue); | |
669 | |
670 if (!configuration_.isMember(key)) | |
671 { | |
672 return false; | |
673 } | |
674 | |
675 switch (configuration_[key].type()) | |
676 { | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
677 case Json::realValue: |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
678 target = configuration_[key].asFloat(); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
679 return true; |
3028 | 680 |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
681 case Json::intValue: |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
682 target = static_cast<float>(configuration_[key].asInt()); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
683 return true; |
3028 | 684 |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
685 case Json::uintValue: |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
686 target = static_cast<float>(configuration_[key].asUInt()); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
687 return true; |
3028 | 688 |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
689 default: |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
690 LogError("The configuration option \"" + GetPath(key) + |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
691 "\" is not an integer as expected"); |
3028 | 692 |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
693 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); |
3028 | 694 } |
695 } | |
3026 | 696 |
697 | |
3028 | 698 bool OrthancConfiguration::LookupListOfStrings(std::list<std::string>& target, |
699 const std::string& key, | |
700 bool allowSingleString) const | |
3026 | 701 { |
3028 | 702 assert(configuration_.type() == Json::objectValue); |
703 | |
704 target.clear(); | |
705 | |
706 if (!configuration_.isMember(key)) | |
707 { | |
708 return false; | |
709 } | |
710 | |
711 switch (configuration_[key].type()) | |
712 { | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
713 case Json::arrayValue: |
3028 | 714 { |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
715 bool ok = true; |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
716 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
717 for (Json::Value::ArrayIndex i = 0; ok && i < configuration_[key].size(); i++) |
3028 | 718 { |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
719 if (configuration_[key][i].type() == Json::stringValue) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
720 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
721 target.push_back(configuration_[key][i].asString()); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
722 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
723 else |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
724 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
725 ok = false; |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
726 } |
3028 | 727 } |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
728 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
729 if (ok) |
3028 | 730 { |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
731 return true; |
3028 | 732 } |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
733 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
734 break; |
3028 | 735 } |
736 | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
737 case Json::stringValue: |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
738 if (allowSingleString) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
739 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
740 target.push_back(configuration_[key].asString()); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
741 return true; |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
742 } |
3028 | 743 |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
744 break; |
3028 | 745 |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
746 default: |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
747 break; |
3028 | 748 } |
749 | |
3026 | 750 LogError("The configuration option \"" + GetPath(key) + |
3028 | 751 "\" is not a list of strings as expected"); |
3026 | 752 |
753 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); | |
754 } | |
755 | |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
756 |
3028 | 757 bool OrthancConfiguration::LookupSetOfStrings(std::set<std::string>& target, |
758 const std::string& key, | |
759 bool allowSingleString) const | |
760 { | |
761 std::list<std::string> lst; | |
762 | |
763 if (LookupListOfStrings(lst, key, allowSingleString)) | |
764 { | |
765 target.clear(); | |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
766 |
3028 | 767 for (std::list<std::string>::const_iterator |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
768 it = lst.begin(); it != lst.end(); ++it) |
3028 | 769 { |
770 target.insert(*it); | |
771 } | |
3026 | 772 |
3028 | 773 return true; |
774 } | |
775 else | |
776 { | |
777 return false; | |
778 } | |
3026 | 779 } |
780 | |
3028 | 781 |
782 std::string OrthancConfiguration::GetStringValue(const std::string& key, | |
783 const std::string& defaultValue) const | |
3026 | 784 { |
3028 | 785 std::string tmp; |
786 if (LookupStringValue(tmp, key)) | |
787 { | |
788 return tmp; | |
789 } | |
790 else | |
791 { | |
792 return defaultValue; | |
793 } | |
3026 | 794 } |
795 | |
796 | |
3028 | 797 int OrthancConfiguration::GetIntegerValue(const std::string& key, |
798 int defaultValue) const | |
3026 | 799 { |
3028 | 800 int tmp; |
801 if (LookupIntegerValue(tmp, key)) | |
802 { | |
803 return tmp; | |
804 } | |
805 else | |
806 { | |
807 return defaultValue; | |
808 } | |
3026 | 809 } |
810 | |
3028 | 811 |
812 unsigned int OrthancConfiguration::GetUnsignedIntegerValue(const std::string& key, | |
813 unsigned int defaultValue) const | |
3026 | 814 { |
3028 | 815 unsigned int tmp; |
816 if (LookupUnsignedIntegerValue(tmp, key)) | |
817 { | |
818 return tmp; | |
819 } | |
820 else | |
821 { | |
822 return defaultValue; | |
823 } | |
3026 | 824 } |
2792
57e2d65d37ce
OrthancPlugins::MemoryBuffer::Release(), fixing openssl link
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
825 |
3026 | 826 |
3028 | 827 bool OrthancConfiguration::GetBooleanValue(const std::string& key, |
828 bool defaultValue) const | |
3026 | 829 { |
3028 | 830 bool tmp; |
831 if (LookupBooleanValue(tmp, key)) | |
832 { | |
833 return tmp; | |
834 } | |
835 else | |
836 { | |
837 return defaultValue; | |
838 } | |
3026 | 839 } |
840 | |
3028 | 841 |
842 float OrthancConfiguration::GetFloatValue(const std::string& key, | |
843 float defaultValue) const | |
3026 | 844 { |
3028 | 845 float tmp; |
846 if (LookupFloatValue(tmp, key)) | |
847 { | |
848 return tmp; | |
849 } | |
850 else | |
851 { | |
852 return defaultValue; | |
853 } | |
3026 | 854 } |
855 | |
856 | |
3028 | 857 void OrthancConfiguration::GetDictionary(std::map<std::string, std::string>& target, |
858 const std::string& key) const | |
3026 | 859 { |
3028 | 860 assert(configuration_.type() == Json::objectValue); |
861 | |
862 target.clear(); | |
863 | |
864 if (!configuration_.isMember(key)) | |
865 { | |
866 return; | |
867 } | |
3026 | 868 |
3028 | 869 if (configuration_[key].type() != Json::objectValue) |
870 { | |
871 LogError("The configuration option \"" + GetPath(key) + | |
872 "\" is not a string as expected"); | |
873 | |
874 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); | |
875 } | |
3026 | 876 |
3028 | 877 Json::Value::Members members = configuration_[key].getMemberNames(); |
878 | |
879 for (size_t i = 0; i < members.size(); i++) | |
3026 | 880 { |
3028 | 881 const Json::Value& value = configuration_[key][members[i]]; |
882 | |
883 if (value.type() == Json::stringValue) | |
3026 | 884 { |
3028 | 885 target[members[i]] = value.asString(); |
3026 | 886 } |
887 else | |
888 { | |
3028 | 889 LogError("The configuration option \"" + GetPath(key) + |
890 "\" is not a dictionary mapping strings to strings"); | |
891 | |
892 ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); | |
3026 | 893 } |
894 } | |
3028 | 895 } |
3026 | 896 |
3028 | 897 |
898 void OrthancImage::Clear() | |
899 { | |
900 if (image_ != NULL) | |
901 { | |
902 OrthancPluginFreeImage(GetGlobalContext(), image_); | |
903 image_ = NULL; | |
904 } | |
905 } | |
906 | |
907 | |
3236 | 908 void OrthancImage::CheckImageAvailable() const |
3028 | 909 { |
910 if (image_ == NULL) | |
911 { | |
912 LogError("Trying to access a NULL image"); | |
913 ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange); | |
914 } | |
915 } | |
916 | |
917 | |
918 OrthancImage::OrthancImage() : | |
919 image_(NULL) | |
920 { | |
921 } | |
922 | |
923 | |
924 OrthancImage::OrthancImage(OrthancPluginImage* image) : | |
925 image_(image) | |
926 { | |
927 } | |
928 | |
929 | |
930 OrthancImage::OrthancImage(OrthancPluginPixelFormat format, | |
931 uint32_t width, | |
932 uint32_t height) | |
933 { | |
934 image_ = OrthancPluginCreateImage(GetGlobalContext(), format, width, height); | |
935 | |
936 if (image_ == NULL) | |
937 { | |
938 LogError("Cannot create an image"); | |
939 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); | |
940 } | |
941 } | |
942 | |
943 | |
944 OrthancImage::OrthancImage(OrthancPluginPixelFormat format, | |
945 uint32_t width, | |
946 uint32_t height, | |
947 uint32_t pitch, | |
948 void* buffer) | |
949 { | |
950 image_ = OrthancPluginCreateImageAccessor | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
951 (GetGlobalContext(), format, width, height, pitch, buffer); |
3028 | 952 |
953 if (image_ == NULL) | |
954 { | |
955 LogError("Cannot create an image accessor"); | |
956 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); | |
957 } | |
958 } | |
959 | |
960 void OrthancImage::UncompressPngImage(const void* data, | |
961 size_t size) | |
962 { | |
963 Clear(); | |
964 | |
965 image_ = OrthancPluginUncompressImage(GetGlobalContext(), data, size, OrthancPluginImageFormat_Png); | |
966 | |
967 if (image_ == NULL) | |
968 { | |
969 LogError("Cannot uncompress a PNG image"); | |
970 ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange); | |
971 } | |
972 } | |
973 | |
974 | |
975 void OrthancImage::UncompressJpegImage(const void* data, | |
976 size_t size) | |
977 { | |
978 Clear(); | |
979 image_ = OrthancPluginUncompressImage(GetGlobalContext(), data, size, OrthancPluginImageFormat_Jpeg); | |
980 if (image_ == NULL) | |
981 { | |
982 LogError("Cannot uncompress a JPEG image"); | |
983 ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange); | |
984 } | |
985 } | |
986 | |
987 | |
988 void OrthancImage::DecodeDicomImage(const void* data, | |
989 size_t size, | |
990 unsigned int frame) | |
991 { | |
992 Clear(); | |
993 image_ = OrthancPluginDecodeDicomImage(GetGlobalContext(), data, size, frame); | |
994 if (image_ == NULL) | |
995 { | |
996 LogError("Cannot uncompress a DICOM image"); | |
997 ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange); | |
998 } | |
999 } | |
1000 | |
1001 | |
3236 | 1002 OrthancPluginPixelFormat OrthancImage::GetPixelFormat() const |
3028 | 1003 { |
1004 CheckImageAvailable(); | |
1005 return OrthancPluginGetImagePixelFormat(GetGlobalContext(), image_); | |
1006 } | |
1007 | |
1008 | |
3236 | 1009 unsigned int OrthancImage::GetWidth() const |
3028 | 1010 { |
1011 CheckImageAvailable(); | |
1012 return OrthancPluginGetImageWidth(GetGlobalContext(), image_); | |
1013 } | |
1014 | |
1015 | |
3236 | 1016 unsigned int OrthancImage::GetHeight() const |
3028 | 1017 { |
1018 CheckImageAvailable(); | |
1019 return OrthancPluginGetImageHeight(GetGlobalContext(), image_); | |
1020 } | |
1021 | |
1022 | |
3236 | 1023 unsigned int OrthancImage::GetPitch() const |
3028 | 1024 { |
1025 CheckImageAvailable(); | |
1026 return OrthancPluginGetImagePitch(GetGlobalContext(), image_); | |
1027 } | |
1028 | |
1029 | |
3236 | 1030 const void* OrthancImage::GetBuffer() const |
3028 | 1031 { |
1032 CheckImageAvailable(); | |
1033 return OrthancPluginGetImageBuffer(GetGlobalContext(), image_); | |
1034 } | |
1035 | |
1036 | |
3236 | 1037 void OrthancImage::CompressPngImage(MemoryBuffer& target) const |
3028 | 1038 { |
1039 CheckImageAvailable(); | |
1040 | |
3320 | 1041 OrthancPlugins::MemoryBuffer answer; |
1042 OrthancPluginCompressPngImage(GetGlobalContext(), *answer, GetPixelFormat(), | |
3028 | 1043 GetWidth(), GetHeight(), GetPitch(), GetBuffer()); |
1044 | |
3320 | 1045 target.Swap(answer); |
3028 | 1046 } |
1047 | |
1048 | |
1049 void OrthancImage::CompressJpegImage(MemoryBuffer& target, | |
3236 | 1050 uint8_t quality) const |
3028 | 1051 { |
1052 CheckImageAvailable(); | |
1053 | |
3320 | 1054 OrthancPlugins::MemoryBuffer answer; |
1055 OrthancPluginCompressJpegImage(GetGlobalContext(), *answer, GetPixelFormat(), | |
3028 | 1056 GetWidth(), GetHeight(), GetPitch(), GetBuffer(), quality); |
1057 | |
3320 | 1058 target.Swap(answer); |
3028 | 1059 } |
1060 | |
1061 | |
3236 | 1062 void OrthancImage::AnswerPngImage(OrthancPluginRestOutput* output) const |
3028 | 1063 { |
1064 CheckImageAvailable(); | |
1065 OrthancPluginCompressAndAnswerPngImage(GetGlobalContext(), output, GetPixelFormat(), | |
1066 GetWidth(), GetHeight(), GetPitch(), GetBuffer()); | |
1067 } | |
1068 | |
1069 | |
1070 void OrthancImage::AnswerJpegImage(OrthancPluginRestOutput* output, | |
3236 | 1071 uint8_t quality) const |
3028 | 1072 { |
1073 CheckImageAvailable(); | |
1074 OrthancPluginCompressAndAnswerJpegImage(GetGlobalContext(), output, GetPixelFormat(), | |
1075 GetWidth(), GetHeight(), GetPitch(), GetBuffer(), quality); | |
1076 } | |
1077 | |
1078 | |
1079 | |
1080 #if HAS_ORTHANC_PLUGIN_FIND_MATCHER == 1 | |
1081 FindMatcher::FindMatcher(const OrthancPluginWorklistQuery* worklist) : | |
1082 matcher_(NULL), | |
1083 worklist_(worklist) | |
1084 { | |
1085 if (worklist_ == NULL) | |
1086 { | |
1087 ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange); | |
1088 } | |
1089 } | |
1090 | |
1091 | |
1092 void FindMatcher::SetupDicom(const void* query, | |
1093 uint32_t size) | |
1094 { | |
1095 worklist_ = NULL; | |
1096 | |
1097 matcher_ = OrthancPluginCreateFindMatcher(GetGlobalContext(), query, size); | |
1098 if (matcher_ == NULL) | |
1099 { | |
1100 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); | |
1101 } | |
1102 } | |
1103 | |
1104 | |
1105 FindMatcher::~FindMatcher() | |
1106 { | |
1107 // The "worklist_" field | |
1108 | |
1109 if (matcher_ != NULL) | |
1110 { | |
1111 OrthancPluginFreeFindMatcher(GetGlobalContext(), matcher_); | |
1112 } | |
1113 } | |
1114 | |
1115 | |
1116 | |
1117 bool FindMatcher::IsMatch(const void* dicom, | |
1118 uint32_t size) const | |
1119 { | |
1120 int32_t result; | |
1121 | |
1122 if (matcher_ != NULL) | |
1123 { | |
1124 result = OrthancPluginFindMatcherIsMatch(GetGlobalContext(), matcher_, dicom, size); | |
1125 } | |
1126 else if (worklist_ != NULL) | |
1127 { | |
1128 result = OrthancPluginWorklistIsMatch(GetGlobalContext(), worklist_, dicom, size); | |
1129 } | |
1130 else | |
1131 { | |
1132 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); | |
1133 } | |
1134 | |
1135 if (result == 0) | |
1136 { | |
1137 return false; | |
1138 } | |
1139 else if (result == 1) | |
1140 { | |
1141 return true; | |
1142 } | |
1143 else | |
1144 { | |
1145 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); | |
1146 } | |
1147 } | |
1148 | |
1149 #endif /* HAS_ORTHANC_PLUGIN_FIND_MATCHER == 1 */ | |
1150 | |
1151 void AnswerJson(const Json::Value& value, | |
1152 OrthancPluginRestOutput* output | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1153 ) |
3028 | 1154 { |
1155 Json::StyledWriter writer; | |
1156 std::string bodyString = writer.write(value); | |
1157 | |
1158 OrthancPluginAnswerBuffer(GetGlobalContext(), output, bodyString.c_str(), bodyString.size(), "application/json"); | |
1159 } | |
1160 | |
1161 void AnswerString(const std::string& answer, | |
1162 const char* mimeType, | |
1163 OrthancPluginRestOutput* output | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1164 ) |
3028 | 1165 { |
1166 OrthancPluginAnswerBuffer(GetGlobalContext(), output, answer.c_str(), answer.size(), mimeType); | |
1167 } | |
1168 | |
1169 void AnswerHttpError(uint16_t httpError, OrthancPluginRestOutput *output) | |
1170 { | |
1171 OrthancPluginSendHttpStatusCode(GetGlobalContext(), output, httpError); | |
1172 } | |
1173 | |
1174 void AnswerMethodNotAllowed(OrthancPluginRestOutput *output, const char* allowedMethods) | |
1175 { | |
1176 OrthancPluginSendMethodNotAllowed(GetGlobalContext(), output, allowedMethods); | |
1177 } | |
1178 | |
1179 bool RestApiGetString(std::string& result, | |
1180 const std::string& uri, | |
1181 bool applyPlugins) | |
1182 { | |
1183 MemoryBuffer answer; | |
1184 if (!answer.RestApiGet(uri, applyPlugins)) | |
1185 { | |
1186 return false; | |
1187 } | |
1188 else | |
1189 { | |
1190 answer.ToString(result); | |
1191 return true; | |
1192 } | |
1193 } | |
1194 | |
1195 bool RestApiGetString(std::string& result, | |
1196 const std::string& uri, | |
1197 const std::map<std::string, std::string>& httpHeaders, | |
1198 bool applyPlugins) | |
1199 { | |
1200 MemoryBuffer answer; | |
1201 if (!answer.RestApiGet(uri, httpHeaders, applyPlugins)) | |
1202 { | |
1203 return false; | |
1204 } | |
1205 else | |
1206 { | |
1207 answer.ToString(result); | |
1208 return true; | |
1209 } | |
1210 } | |
1211 | |
1212 | |
1213 | |
1214 bool RestApiGet(Json::Value& result, | |
1215 const std::string& uri, | |
1216 bool applyPlugins) | |
1217 { | |
1218 MemoryBuffer answer; | |
1219 | |
1220 if (!answer.RestApiGet(uri, applyPlugins)) | |
1221 { | |
1222 return false; | |
1223 } | |
1224 else | |
1225 { | |
1226 if (!answer.IsEmpty()) | |
1227 { | |
1228 answer.ToJson(result); | |
1229 } | |
1230 return true; | |
1231 } | |
1232 } | |
1233 | |
1234 | |
1235 bool RestApiPost(Json::Value& result, | |
1236 const std::string& uri, | |
3400
0faae6f6e3c5
fixed some inconsistencies with pointer types in the plugin sdk
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3399
diff
changeset
|
1237 const void* body, |
3028 | 1238 size_t bodySize, |
1239 bool applyPlugins) | |
1240 { | |
1241 MemoryBuffer answer; | |
1242 | |
1243 if (!answer.RestApiPost(uri, body, bodySize, applyPlugins)) | |
1244 { | |
1245 return false; | |
1246 } | |
1247 else | |
1248 { | |
1249 if (!answer.IsEmpty()) | |
1250 { | |
1251 answer.ToJson(result); | |
1252 } | |
1253 return true; | |
1254 } | |
1255 } | |
1256 | |
1257 | |
1258 bool RestApiPost(Json::Value& result, | |
1259 const std::string& uri, | |
1260 const Json::Value& body, | |
1261 bool applyPlugins) | |
1262 { | |
1263 Json::FastWriter writer; | |
1264 return RestApiPost(result, uri, writer.write(body), applyPlugins); | |
1265 } | |
1266 | |
1267 | |
1268 bool RestApiPut(Json::Value& result, | |
1269 const std::string& uri, | |
3400
0faae6f6e3c5
fixed some inconsistencies with pointer types in the plugin sdk
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3399
diff
changeset
|
1270 const void* body, |
3028 | 1271 size_t bodySize, |
1272 bool applyPlugins) | |
1273 { | |
1274 MemoryBuffer answer; | |
1275 | |
1276 if (!answer.RestApiPut(uri, body, bodySize, applyPlugins)) | |
1277 { | |
1278 return false; | |
1279 } | |
1280 else | |
1281 { | |
1282 if (!answer.IsEmpty()) // i.e, on a PUT to metadata/..., orthand returns an empty response | |
1283 { | |
1284 answer.ToJson(result); | |
1285 } | |
1286 return true; | |
1287 } | |
1288 } | |
1289 | |
1290 | |
1291 bool RestApiPut(Json::Value& result, | |
1292 const std::string& uri, | |
1293 const Json::Value& body, | |
1294 bool applyPlugins) | |
1295 { | |
1296 Json::FastWriter writer; | |
1297 return RestApiPut(result, uri, writer.write(body), applyPlugins); | |
1298 } | |
1299 | |
1300 | |
1301 bool RestApiDelete(const std::string& uri, | |
1302 bool applyPlugins) | |
1303 { | |
1304 OrthancPluginErrorCode error; | |
1305 | |
1306 if (applyPlugins) | |
1307 { | |
1308 error = OrthancPluginRestApiDeleteAfterPlugins(GetGlobalContext(), uri.c_str()); | |
1309 } | |
1310 else | |
1311 { | |
1312 error = OrthancPluginRestApiDelete(GetGlobalContext(), uri.c_str()); | |
1313 } | |
1314 | |
1315 if (error == OrthancPluginErrorCode_Success) | |
1316 { | |
1317 return true; | |
1318 } | |
1319 else if (error == OrthancPluginErrorCode_UnknownResource || | |
1320 error == OrthancPluginErrorCode_InexistentItem) | |
1321 { | |
1322 return false; | |
1323 } | |
1324 else | |
1325 { | |
1326 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(error); | |
1327 } | |
1328 } | |
1329 | |
1330 | |
1331 void ReportMinimalOrthancVersion(unsigned int major, | |
1332 unsigned int minor, | |
1333 unsigned int revision) | |
1334 { | |
1335 LogError("Your version of the Orthanc core (" + | |
1336 std::string(GetGlobalContext()->orthancVersion) + | |
1337 ") is too old to run this plugin (version " + | |
1338 boost::lexical_cast<std::string>(major) + "." + | |
1339 boost::lexical_cast<std::string>(minor) + "." + | |
1340 boost::lexical_cast<std::string>(revision) + | |
1341 " is required)"); | |
1342 } | |
1343 | |
1344 | |
1345 bool CheckMinimalOrthancVersion(unsigned int major, | |
1346 unsigned int minor, | |
1347 unsigned int revision) | |
1348 { | |
1349 if (!HasGlobalContext()) | |
1350 { | |
1351 LogError("Bad Orthanc context in the plugin"); | |
1352 return false; | |
1353 } | |
1354 | |
1355 if (!strcmp(GetGlobalContext()->orthancVersion, "mainline")) | |
1356 { | |
1357 // Assume compatibility with the mainline | |
1358 return true; | |
1359 } | |
1360 | |
1361 // Parse the version of the Orthanc core | |
1362 int aa, bb, cc; | |
1363 if ( | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1364 #ifdef _MSC_VER |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1365 sscanf_s |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1366 #else |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1367 sscanf |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1368 #endif |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1369 (GetGlobalContext()->orthancVersion, "%4d.%4d.%4d", &aa, &bb, &cc) != 3 || |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1370 aa < 0 || |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1371 bb < 0 || |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1372 cc < 0) |
3028 | 1373 { |
1374 return false; | |
1375 } | |
1376 | |
1377 unsigned int a = static_cast<unsigned int>(aa); | |
1378 unsigned int b = static_cast<unsigned int>(bb); | |
1379 unsigned int c = static_cast<unsigned int>(cc); | |
1380 | |
1381 // Check the major version number | |
1382 | |
1383 if (a > major) | |
3026 | 1384 { |
1385 return true; | |
1386 } | |
1387 | |
3028 | 1388 if (a < major) |
1389 { | |
1390 return false; | |
1391 } | |
1392 | |
2792
57e2d65d37ce
OrthancPlugins::MemoryBuffer::Release(), fixing openssl link
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
1393 |
3028 | 1394 // Check the minor version number |
1395 assert(a == major); | |
1396 | |
1397 if (b > minor) | |
3026 | 1398 { |
1399 return true; | |
1400 } | |
2792
57e2d65d37ce
OrthancPlugins::MemoryBuffer::Release(), fixing openssl link
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
1401 |
3028 | 1402 if (b < minor) |
3026 | 1403 { |
3028 | 1404 return false; |
3026 | 1405 } |
1406 | |
3028 | 1407 // Check the patch level version number |
1408 assert(a == major && b == minor); | |
3026 | 1409 |
3028 | 1410 if (c >= revision) |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
1411 { |
3028 | 1412 return true; |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
1413 } |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
1414 else |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
1415 { |
3028 | 1416 return false; |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
1417 } |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
1418 } |
2058
43cd2ab060c7
cont OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2048
diff
changeset
|
1419 |
43cd2ab060c7
cont OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2048
diff
changeset
|
1420 |
3028 | 1421 #if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 5, 0) |
1422 const char* AutodetectMimeType(const std::string& path) | |
3026 | 1423 { |
3028 | 1424 const char* mime = OrthancPluginAutodetectMimeType(GetGlobalContext(), path.c_str()); |
2062
40ffd0e8676a
generation of etag in ServeFolders
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2059
diff
changeset
|
1425 |
3028 | 1426 if (mime == NULL) |
1427 { | |
1428 // Should never happen, just for safety | |
1429 return "application/octet-stream"; | |
1430 } | |
1431 else | |
1432 { | |
1433 return mime; | |
1434 } | |
2848 | 1435 } |
3026 | 1436 #endif |
1437 | |
1438 | |
1439 #if HAS_ORTHANC_PLUGIN_PEERS == 1 | |
3028 | 1440 size_t OrthancPeers::GetPeerIndex(const std::string& name) const |
3026 | 1441 { |
3028 | 1442 size_t index; |
1443 if (LookupName(index, name)) | |
1444 { | |
1445 return index; | |
1446 } | |
1447 else | |
1448 { | |
1449 LogError("Inexistent peer: " + name); | |
1450 ORTHANC_PLUGINS_THROW_EXCEPTION(UnknownResource); | |
1451 } | |
3026 | 1452 } |
2059 | 1453 |
1454 | |
3028 | 1455 OrthancPeers::OrthancPeers() : |
1456 peers_(NULL), | |
1457 timeout_(0) | |
2205
395522e46b2b
refactoring of the worklist sample using OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2177
diff
changeset
|
1458 { |
3028 | 1459 peers_ = OrthancPluginGetPeers(GetGlobalContext()); |
3026 | 1460 |
3028 | 1461 if (peers_ == NULL) |
3026 | 1462 { |
1463 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_Plugin); | |
1464 } | |
1465 | |
3028 | 1466 uint32_t count = OrthancPluginGetPeersCount(GetGlobalContext(), peers_); |
1467 | |
1468 for (uint32_t i = 0; i < count; i++) | |
1469 { | |
1470 const char* name = OrthancPluginGetPeerName(GetGlobalContext(), peers_, i); | |
1471 if (name == NULL) | |
1472 { | |
1473 OrthancPluginFreePeers(GetGlobalContext(), peers_); | |
1474 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_Plugin); | |
1475 } | |
1476 | |
1477 index_[name] = i; | |
1478 } | |
1479 } | |
1480 | |
1481 | |
1482 OrthancPeers::~OrthancPeers() | |
1483 { | |
1484 if (peers_ != NULL) | |
1485 { | |
1486 OrthancPluginFreePeers(GetGlobalContext(), peers_); | |
1487 } | |
1488 } | |
1489 | |
1490 | |
1491 bool OrthancPeers::LookupName(size_t& target, | |
1492 const std::string& name) const | |
1493 { | |
1494 Index::const_iterator found = index_.find(name); | |
1495 | |
1496 if (found == index_.end()) | |
1497 { | |
1498 return false; | |
1499 } | |
1500 else | |
1501 { | |
1502 target = found->second; | |
1503 return true; | |
1504 } | |
3026 | 1505 } |
3028 | 1506 |
1507 | |
1508 std::string OrthancPeers::GetPeerName(size_t index) const | |
1509 { | |
1510 if (index >= index_.size()) | |
1511 { | |
1512 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange); | |
1513 } | |
1514 else | |
1515 { | |
1516 const char* s = OrthancPluginGetPeerName(GetGlobalContext(), peers_, static_cast<uint32_t>(index)); | |
1517 if (s == NULL) | |
1518 { | |
1519 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_Plugin); | |
1520 } | |
1521 else | |
1522 { | |
1523 return s; | |
1524 } | |
1525 } | |
1526 } | |
1527 | |
1528 | |
1529 std::string OrthancPeers::GetPeerUrl(size_t index) const | |
1530 { | |
1531 if (index >= index_.size()) | |
1532 { | |
1533 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange); | |
1534 } | |
1535 else | |
1536 { | |
1537 const char* s = OrthancPluginGetPeerUrl(GetGlobalContext(), peers_, static_cast<uint32_t>(index)); | |
1538 if (s == NULL) | |
1539 { | |
1540 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_Plugin); | |
1541 } | |
1542 else | |
1543 { | |
1544 return s; | |
1545 } | |
1546 } | |
1547 } | |
1548 | |
1549 | |
1550 std::string OrthancPeers::GetPeerUrl(const std::string& name) const | |
1551 { | |
1552 return GetPeerUrl(GetPeerIndex(name)); | |
1553 } | |
1554 | |
1555 | |
1556 bool OrthancPeers::LookupUserProperty(std::string& value, | |
1557 size_t index, | |
1558 const std::string& key) const | |
1559 { | |
1560 if (index >= index_.size()) | |
1561 { | |
1562 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange); | |
1563 } | |
1564 else | |
1565 { | |
1566 const char* s = OrthancPluginGetPeerUserProperty(GetGlobalContext(), peers_, static_cast<uint32_t>(index), key.c_str()); | |
1567 if (s == NULL) | |
1568 { | |
1569 return false; | |
1570 } | |
1571 else | |
1572 { | |
1573 value.assign(s); | |
1574 return true; | |
1575 } | |
1576 } | |
1577 } | |
1578 | |
1579 | |
1580 bool OrthancPeers::LookupUserProperty(std::string& value, | |
1581 const std::string& peer, | |
1582 const std::string& key) const | |
1583 { | |
1584 return LookupUserProperty(value, GetPeerIndex(peer), key); | |
1585 } | |
3026 | 1586 |
2205
395522e46b2b
refactoring of the worklist sample using OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2177
diff
changeset
|
1587 |
3028 | 1588 bool OrthancPeers::DoGet(MemoryBuffer& target, |
1589 size_t index, | |
1590 const std::string& uri) const | |
1591 { | |
1592 if (index >= index_.size()) | |
1593 { | |
1594 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange); | |
1595 } | |
1596 | |
3320 | 1597 OrthancPlugins::MemoryBuffer answer; |
3028 | 1598 uint16_t status; |
1599 OrthancPluginErrorCode code = OrthancPluginCallPeerApi | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1600 (GetGlobalContext(), *answer, NULL, &status, peers_, |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1601 static_cast<uint32_t>(index), OrthancPluginHttpMethod_Get, uri.c_str(), |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1602 0, NULL, NULL, NULL, 0, timeout_); |
3028 | 1603 |
1604 if (code == OrthancPluginErrorCode_Success) | |
1605 { | |
3320 | 1606 target.Swap(answer); |
3028 | 1607 return (status == 200); |
1608 } | |
1609 else | |
1610 { | |
1611 return false; | |
1612 } | |
1613 } | |
1614 | |
1615 | |
1616 bool OrthancPeers::DoGet(MemoryBuffer& target, | |
1617 const std::string& name, | |
1618 const std::string& uri) const | |
1619 { | |
1620 size_t index; | |
1621 return (LookupName(index, name) && | |
1622 DoGet(target, index, uri)); | |
1623 } | |
1624 | |
1625 | |
1626 bool OrthancPeers::DoGet(Json::Value& target, | |
1627 size_t index, | |
1628 const std::string& uri) const | |
1629 { | |
1630 MemoryBuffer buffer; | |
1631 | |
1632 if (DoGet(buffer, index, uri)) | |
1633 { | |
1634 buffer.ToJson(target); | |
1635 return true; | |
1636 } | |
1637 else | |
1638 { | |
1639 return false; | |
1640 } | |
1641 } | |
1642 | |
1643 | |
1644 bool OrthancPeers::DoGet(Json::Value& target, | |
1645 const std::string& name, | |
1646 const std::string& uri) const | |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
1647 { |
3028 | 1648 MemoryBuffer buffer; |
1649 | |
1650 if (DoGet(buffer, name, uri)) | |
1651 { | |
1652 buffer.ToJson(target); | |
1653 return true; | |
1654 } | |
1655 else | |
1656 { | |
1657 return false; | |
1658 } | |
1659 } | |
1660 | |
1661 | |
1662 bool OrthancPeers::DoPost(MemoryBuffer& target, | |
1663 const std::string& name, | |
1664 const std::string& uri, | |
1665 const std::string& body) const | |
1666 { | |
1667 size_t index; | |
1668 return (LookupName(index, name) && | |
1669 DoPost(target, index, uri, body)); | |
1670 } | |
1671 | |
1672 | |
1673 bool OrthancPeers::DoPost(Json::Value& target, | |
1674 size_t index, | |
1675 const std::string& uri, | |
1676 const std::string& body) const | |
1677 { | |
1678 MemoryBuffer buffer; | |
1679 | |
1680 if (DoPost(buffer, index, uri, body)) | |
1681 { | |
1682 buffer.ToJson(target); | |
1683 return true; | |
1684 } | |
1685 else | |
1686 { | |
1687 return false; | |
1688 } | |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
1689 } |
3028 | 1690 |
1691 | |
1692 bool OrthancPeers::DoPost(Json::Value& target, | |
1693 const std::string& name, | |
1694 const std::string& uri, | |
1695 const std::string& body) const | |
1696 { | |
1697 MemoryBuffer buffer; | |
1698 | |
1699 if (DoPost(buffer, name, uri, body)) | |
1700 { | |
1701 buffer.ToJson(target); | |
1702 return true; | |
1703 } | |
1704 else | |
1705 { | |
1706 return false; | |
1707 } | |
1708 } | |
1709 | |
1710 | |
1711 bool OrthancPeers::DoPost(MemoryBuffer& target, | |
1712 size_t index, | |
1713 const std::string& uri, | |
1714 const std::string& body) const | |
1715 { | |
1716 if (index >= index_.size()) | |
1717 { | |
1718 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange); | |
1719 } | |
1720 | |
3320 | 1721 OrthancPlugins::MemoryBuffer answer; |
3028 | 1722 uint16_t status; |
1723 OrthancPluginErrorCode code = OrthancPluginCallPeerApi | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1724 (GetGlobalContext(), *answer, NULL, &status, peers_, |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1725 static_cast<uint32_t>(index), OrthancPluginHttpMethod_Post, uri.c_str(), |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1726 0, NULL, NULL, body.empty() ? NULL : body.c_str(), body.size(), timeout_); |
3028 | 1727 |
1728 if (code == OrthancPluginErrorCode_Success) | |
1729 { | |
3320 | 1730 target.Swap(answer); |
3028 | 1731 return (status == 200); |
1732 } | |
1733 else | |
1734 { | |
1735 return false; | |
1736 } | |
1737 } | |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
1738 |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
1739 |
3028 | 1740 bool OrthancPeers::DoPut(size_t index, |
1741 const std::string& uri, | |
1742 const std::string& body) const | |
1743 { | |
1744 if (index >= index_.size()) | |
1745 { | |
1746 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange); | |
1747 } | |
1748 | |
3320 | 1749 OrthancPlugins::MemoryBuffer answer; |
3028 | 1750 uint16_t status; |
1751 OrthancPluginErrorCode code = OrthancPluginCallPeerApi | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1752 (GetGlobalContext(), *answer, NULL, &status, peers_, |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1753 static_cast<uint32_t>(index), OrthancPluginHttpMethod_Put, uri.c_str(), |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
1754 0, NULL, NULL, body.empty() ? NULL : body.c_str(), body.size(), timeout_); |
3026 | 1755 |
3028 | 1756 if (code == OrthancPluginErrorCode_Success) |
1757 { | |
1758 return (status == 200); | |
1759 } | |
1760 else | |
1761 { | |
1762 return false; | |
1763 } | |
1764 } | |
1765 | |
1766 | |
1767 bool OrthancPeers::DoPut(const std::string& name, | |
1768 const std::string& uri, | |
1769 const std::string& body) const | |
1770 { | |
1771 size_t index; | |
1772 return (LookupName(index, name) && | |
1773 DoPut(index, uri, body)); | |
1774 } | |
1775 | |
1776 | |
1777 bool OrthancPeers::DoDelete(size_t index, | |
1778 const std::string& uri) const | |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
1779 { |
3028 | 1780 if (index >= index_.size()) |
1781 { | |
1782 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange); | |
1783 } | |
1784 | |
3320 | 1785 OrthancPlugins::MemoryBuffer answer; |
3028 | 1786 uint16_t status; |
1787 OrthancPluginErrorCode code = OrthancPluginCallPeerApi | |
3320 | 1788 (GetGlobalContext(), *answer, NULL, &status, peers_, |
1789 static_cast<uint32_t>(index), OrthancPluginHttpMethod_Delete, uri.c_str(), | |
1790 0, NULL, NULL, NULL, 0, timeout_); | |
3028 | 1791 |
1792 if (code == OrthancPluginErrorCode_Success) | |
1793 { | |
1794 return (status == 200); | |
1795 } | |
1796 else | |
1797 { | |
1798 return false; | |
1799 } | |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
1800 } |
3028 | 1801 |
1802 | |
1803 bool OrthancPeers::DoDelete(const std::string& name, | |
1804 const std::string& uri) const | |
3026 | 1805 { |
3028 | 1806 size_t index; |
1807 return (LookupName(index, name) && | |
1808 DoDelete(index, uri)); | |
1809 } | |
1810 #endif | |
1811 | |
1812 | |
1813 | |
3397
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
1814 |
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
1815 |
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
1816 /****************************************************************** |
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
1817 ** JOBS |
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
1818 ******************************************************************/ |
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
1819 |
3028 | 1820 #if HAS_ORTHANC_PLUGIN_JOB == 1 |
1821 void OrthancJob::CallbackFinalize(void* job) | |
1822 { | |
1823 if (job != NULL) | |
1824 { | |
1825 delete reinterpret_cast<OrthancJob*>(job); | |
1826 } | |
3026 | 1827 } |
3028 | 1828 |
1829 | |
1830 float OrthancJob::CallbackGetProgress(void* job) | |
1831 { | |
1832 assert(job != NULL); | |
1833 | |
1834 try | |
1835 { | |
1836 return reinterpret_cast<OrthancJob*>(job)->progress_; | |
1837 } | |
1838 catch (...) | |
1839 { | |
1840 return 0; | |
1841 } | |
1842 } | |
1843 | |
1844 | |
1845 const char* OrthancJob::CallbackGetContent(void* job) | |
1846 { | |
1847 assert(job != NULL); | |
1848 | |
1849 try | |
1850 { | |
1851 return reinterpret_cast<OrthancJob*>(job)->content_.c_str(); | |
1852 } | |
1853 catch (...) | |
1854 { | |
1855 return 0; | |
1856 } | |
1857 } | |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
1858 |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
1859 |
3028 | 1860 const char* OrthancJob::CallbackGetSerialized(void* job) |
1861 { | |
1862 assert(job != NULL); | |
1863 | |
1864 try | |
1865 { | |
1866 const OrthancJob& tmp = *reinterpret_cast<OrthancJob*>(job); | |
1867 | |
1868 if (tmp.hasSerialized_) | |
1869 { | |
1870 return tmp.serialized_.c_str(); | |
1871 } | |
1872 else | |
1873 { | |
1874 return NULL; | |
1875 } | |
1876 } | |
1877 catch (...) | |
1878 { | |
1879 return 0; | |
1880 } | |
1881 } | |
1882 | |
1883 | |
1884 OrthancPluginJobStepStatus OrthancJob::CallbackStep(void* job) | |
1885 { | |
1886 assert(job != NULL); | |
1887 | |
1888 try | |
1889 { | |
1890 return reinterpret_cast<OrthancJob*>(job)->Step(); | |
1891 } | |
1892 catch (ORTHANC_PLUGINS_EXCEPTION_CLASS&) | |
1893 { | |
1894 return OrthancPluginJobStepStatus_Failure; | |
1895 } | |
1896 catch (...) | |
1897 { | |
1898 return OrthancPluginJobStepStatus_Failure; | |
1899 } | |
1900 } | |
1901 | |
1902 | |
1903 OrthancPluginErrorCode OrthancJob::CallbackStop(void* job, | |
1904 OrthancPluginJobStopReason reason) | |
1905 { | |
1906 assert(job != NULL); | |
1907 | |
1908 try | |
1909 { | |
1910 reinterpret_cast<OrthancJob*>(job)->Stop(reason); | |
1911 return OrthancPluginErrorCode_Success; | |
1912 } | |
1913 catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) | |
1914 { | |
1915 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); | |
1916 } | |
1917 catch (...) | |
1918 { | |
1919 return OrthancPluginErrorCode_Plugin; | |
1920 } | |
1921 } | |
1922 | |
1923 | |
1924 OrthancPluginErrorCode OrthancJob::CallbackReset(void* job) | |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
1925 { |
3028 | 1926 assert(job != NULL); |
1927 | |
1928 try | |
1929 { | |
1930 reinterpret_cast<OrthancJob*>(job)->Reset(); | |
1931 return OrthancPluginErrorCode_Success; | |
1932 } | |
1933 catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) | |
1934 { | |
1935 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); | |
1936 } | |
1937 catch (...) | |
1938 { | |
1939 return OrthancPluginErrorCode_Plugin; | |
1940 } | |
1941 } | |
1942 | |
1943 | |
1944 void OrthancJob::ClearContent() | |
1945 { | |
1946 Json::Value empty = Json::objectValue; | |
1947 UpdateContent(empty); | |
1948 } | |
1949 | |
1950 | |
1951 void OrthancJob::UpdateContent(const Json::Value& content) | |
1952 { | |
1953 if (content.type() != Json::objectValue) | |
1954 { | |
1955 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_BadFileFormat); | |
1956 } | |
1957 else | |
1958 { | |
1959 Json::FastWriter writer; | |
1960 content_ = writer.write(content); | |
1961 } | |
1962 } | |
1963 | |
1964 | |
1965 void OrthancJob::ClearSerialized() | |
1966 { | |
1967 hasSerialized_ = false; | |
1968 serialized_.clear(); | |
3026 | 1969 } |
3028 | 1970 |
1971 | |
1972 void OrthancJob::UpdateSerialized(const Json::Value& serialized) | |
1973 { | |
1974 if (serialized.type() != Json::objectValue) | |
1975 { | |
1976 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_BadFileFormat); | |
1977 } | |
1978 else | |
1979 { | |
1980 Json::FastWriter writer; | |
1981 serialized_ = writer.write(serialized); | |
1982 hasSerialized_ = true; | |
1983 } | |
1984 } | |
1985 | |
1986 | |
1987 void OrthancJob::UpdateProgress(float progress) | |
3026 | 1988 { |
3028 | 1989 if (progress < 0 || |
1990 progress > 1) | |
1991 { | |
1992 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange); | |
1993 } | |
1994 | |
1995 progress_ = progress; | |
1996 } | |
1997 | |
1998 | |
1999 OrthancJob::OrthancJob(const std::string& jobType) : | |
2000 jobType_(jobType), | |
2001 progress_(0) | |
2002 { | |
2003 ClearContent(); | |
2004 ClearSerialized(); | |
2005 } | |
2006 | |
2007 | |
2008 OrthancPluginJob* OrthancJob::Create(OrthancJob* job) | |
2009 { | |
2010 if (job == NULL) | |
2011 { | |
2012 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_NullPointer); | |
2013 } | |
2014 | |
2015 OrthancPluginJob* orthanc = OrthancPluginCreateJob( | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2016 GetGlobalContext(), job, CallbackFinalize, job->jobType_.c_str(), |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2017 CallbackGetProgress, CallbackGetContent, CallbackGetSerialized, |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2018 CallbackStep, CallbackStop, CallbackReset); |
3028 | 2019 |
2020 if (orthanc == NULL) | |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
2021 { |
3026 | 2022 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_Plugin); |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
2023 } |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
2024 else |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
2025 { |
3028 | 2026 return orthanc; |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
2027 } |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
2028 } |
2205
395522e46b2b
refactoring of the worklist sample using OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2177
diff
changeset
|
2029 |
2264
8e5e0de75839
primitives for HTTP client in plugin C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2263
diff
changeset
|
2030 |
3028 | 2031 std::string OrthancJob::Submit(OrthancJob* job, |
2032 int priority) | |
2264
8e5e0de75839
primitives for HTTP client in plugin C++ wrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2263
diff
changeset
|
2033 { |
3028 | 2034 OrthancPluginJob* orthanc = Create(job); |
2035 | |
2036 char* id = OrthancPluginSubmitJob(GetGlobalContext(), orthanc, priority); | |
2037 | |
2038 if (id == NULL) | |
3026 | 2039 { |
3028 | 2040 LogError("Plugin cannot submit job"); |
2041 OrthancPluginFreeJob(GetGlobalContext(), orthanc); | |
3026 | 2042 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_Plugin); |
2043 } | |
2044 else | |
2045 { | |
3028 | 2046 std::string tmp(id); |
2047 tmp.assign(id); | |
2048 OrthancPluginFreeString(GetGlobalContext(), id); | |
3026 | 2049 |
3028 | 2050 return tmp; |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
2051 } |
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
2052 } |
2817
473bf302d629
C++ wrappers around OrthancPluginJob and OrthancPluginPeers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2803
diff
changeset
|
2053 #endif |
3179
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2054 |
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2055 |
3397
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
2056 |
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
2057 |
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
2058 /****************************************************************** |
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
2059 ** METRICS |
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
2060 ******************************************************************/ |
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
2061 |
3179
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2062 #if HAS_ORTHANC_PLUGIN_METRICS == 1 |
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2063 MetricsTimer::MetricsTimer(const char* name) : |
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2064 name_(name) |
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2065 { |
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2066 start_ = boost::posix_time::microsec_clock::universal_time(); |
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2067 } |
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2068 |
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2069 MetricsTimer::~MetricsTimer() |
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2070 { |
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2071 const boost::posix_time::ptime stop = boost::posix_time::microsec_clock::universal_time(); |
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2072 const boost::posix_time::time_duration diff = stop - start_; |
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2073 OrthancPluginSetMetricsValue(GetGlobalContext(), name_.c_str(), diff.total_milliseconds(), |
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2074 OrthancPluginMetricsType_Timer); |
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2075 } |
fca730c267d7
New primitives to set and refresh metrics
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
2076 #endif |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2077 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2078 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2079 |
3397
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
2080 |
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
2081 /****************************************************************** |
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
2082 ** HTTP CLIENT |
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
2083 ******************************************************************/ |
9019279dbfd7
new plugin c++ wrapper: MultipartRestCallback
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3394
diff
changeset
|
2084 |
3388 | 2085 #if HAS_ORTHANC_PLUGIN_HTTP_CLIENT == 1 |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2086 class HttpClient::RequestBodyWrapper : public boost::noncopyable |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2087 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2088 private: |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2089 static RequestBodyWrapper& GetObject(void* body) |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2090 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2091 assert(body != NULL); |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2092 return *reinterpret_cast<RequestBodyWrapper*>(body); |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2093 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2094 |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2095 IRequestBody& body_; |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2096 bool done_; |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2097 std::string chunk_; |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2098 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2099 public: |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2100 RequestBodyWrapper(IRequestBody& body) : |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2101 body_(body), |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2102 done_(false) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2103 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2104 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2105 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2106 static uint8_t IsDone(void* body) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2107 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2108 return GetObject(body).done_; |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2109 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2110 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2111 static const void* GetChunkData(void* body) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2112 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2113 return GetObject(body).chunk_.c_str(); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2114 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2115 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2116 static uint32_t GetChunkSize(void* body) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2117 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2118 return static_cast<uint32_t>(GetObject(body).chunk_.size()); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2119 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2120 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2121 static OrthancPluginErrorCode Next(void* body) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2122 { |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2123 RequestBodyWrapper& that = GetObject(body); |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2124 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2125 if (that.done_) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2126 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2127 return OrthancPluginErrorCode_BadSequenceOfCalls; |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2128 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2129 else |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2130 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2131 try |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2132 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2133 that.done_ = !that.body_.ReadNextChunk(that.chunk_); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2134 return OrthancPluginErrorCode_Success; |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2135 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2136 catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2137 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2138 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2139 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2140 catch (...) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2141 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2142 return OrthancPluginErrorCode_InternalError; |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2143 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2144 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2145 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2146 }; |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2147 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2148 |
3413 | 2149 #if HAS_ORTHANC_PLUGIN_CHUNKED_HTTP_CLIENT == 1 |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2150 static OrthancPluginErrorCode AnswerAddHeaderCallback(void* answer, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2151 const char* key, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2152 const char* value) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2153 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2154 assert(answer != NULL && key != NULL && value != NULL); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2155 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2156 try |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2157 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2158 reinterpret_cast<HttpClient::IAnswer*>(answer)->AddHeader(key, value); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2159 return OrthancPluginErrorCode_Success; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2160 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2161 catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2162 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2163 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2164 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2165 catch (...) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2166 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2167 return OrthancPluginErrorCode_Plugin; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2168 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2169 } |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2170 #endif |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2171 |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2172 |
3413 | 2173 #if HAS_ORTHANC_PLUGIN_CHUNKED_HTTP_CLIENT == 1 |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2174 static OrthancPluginErrorCode AnswerAddChunkCallback(void* answer, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2175 const void* data, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2176 uint32_t size) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2177 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2178 assert(answer != NULL); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2179 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2180 try |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2181 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2182 reinterpret_cast<HttpClient::IAnswer*>(answer)->AddChunk(data, size); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2183 return OrthancPluginErrorCode_Success; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2184 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2185 catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2186 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2187 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2188 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2189 catch (...) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2190 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2191 return OrthancPluginErrorCode_Plugin; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2192 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2193 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2194 #endif |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2195 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2196 |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2197 HttpClient::HttpClient() : |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2198 httpStatus_(0), |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2199 method_(OrthancPluginHttpMethod_Get), |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2200 timeout_(0), |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2201 pkcs11_(false), |
3413 | 2202 chunkedBody_(NULL) |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2203 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2204 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2205 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2206 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2207 void HttpClient::SetCredentials(const std::string& username, |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2208 const std::string& password) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2209 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2210 username_ = username; |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2211 password_ = password; |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2212 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2213 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2214 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2215 void HttpClient::ClearCredentials() |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2216 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2217 username_.empty(); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2218 password_.empty(); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2219 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2220 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2221 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2222 void HttpClient::SetCertificate(const std::string& certificateFile, |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2223 const std::string& keyFile, |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2224 const std::string& keyPassword) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2225 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2226 certificateFile_ = certificateFile; |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2227 certificateKeyFile_ = keyFile; |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2228 certificateKeyPassword_ = keyPassword; |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2229 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2230 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2231 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2232 void HttpClient::ClearCertificate() |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2233 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2234 certificateFile_.clear(); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2235 certificateKeyFile_.clear(); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2236 certificateKeyPassword_.clear(); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2237 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2238 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2239 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2240 void HttpClient::ClearBody() |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2241 { |
3413 | 2242 fullBody_.clear(); |
2243 chunkedBody_ = NULL; | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2244 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2245 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2246 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2247 void HttpClient::SwapBody(std::string& body) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2248 { |
3413 | 2249 fullBody_.swap(body); |
2250 chunkedBody_ = NULL; | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2251 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2252 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2253 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2254 void HttpClient::SetBody(const std::string& body) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2255 { |
3413 | 2256 fullBody_ = body; |
2257 chunkedBody_ = NULL; | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2258 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2259 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2260 |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2261 void HttpClient::SetBody(IRequestBody& body) |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2262 { |
3413 | 2263 fullBody_.clear(); |
2264 chunkedBody_ = &body; | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2265 } |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2266 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2267 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2268 namespace |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2269 { |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2270 class HeadersWrapper : public boost::noncopyable |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2271 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2272 private: |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2273 std::vector<const char*> headersKeys_; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2274 std::vector<const char*> headersValues_; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2275 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2276 public: |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2277 HeadersWrapper(const HttpClient::HttpHeaders& headers) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2278 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2279 headersKeys_.reserve(headers.size()); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2280 headersValues_.reserve(headers.size()); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2281 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2282 for (HttpClient::HttpHeaders::const_iterator it = headers.begin(); it != headers.end(); ++it) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2283 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2284 headersKeys_.push_back(it->first.c_str()); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2285 headersValues_.push_back(it->second.c_str()); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2286 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2287 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2288 |
3394 | 2289 void AddStaticString(const char* key, |
2290 const char* value) | |
2291 { | |
2292 headersKeys_.push_back(key); | |
2293 headersValues_.push_back(value); | |
2294 } | |
2295 | |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2296 uint32_t GetCount() const |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2297 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2298 return headersKeys_.size(); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2299 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2300 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2301 const char* const* GetKeys() const |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2302 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2303 return headersKeys_.empty() ? NULL : &headersKeys_[0]; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2304 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2305 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2306 const char* const* GetValues() const |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2307 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2308 return headersValues_.empty() ? NULL : &headersValues_[0]; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2309 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2310 }; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2311 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2312 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2313 class MemoryRequestBody : public HttpClient::IRequestBody |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2314 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2315 private: |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2316 std::string body_; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2317 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2318 public: |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2319 MemoryRequestBody(const std::string& body) : |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2320 body_(body) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2321 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2322 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2323 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2324 virtual bool ReadNextChunk(std::string& chunk) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2325 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2326 chunk.swap(body_); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2327 return true; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2328 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2329 }; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2330 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2331 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2332 // This class mimics Orthanc::ChunkedBuffer |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2333 class ChunkedBuffer : public boost::noncopyable |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2334 { |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2335 private: |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2336 typedef std::list<std::string*> Content; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2337 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2338 Content content_; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2339 size_t size_; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2340 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2341 public: |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2342 ChunkedBuffer() : |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2343 size_(0) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2344 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2345 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2346 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2347 ~ChunkedBuffer() |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2348 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2349 Clear(); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2350 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2351 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2352 void Clear() |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2353 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2354 for (Content::iterator it = content_.begin(); it != content_.end(); ++it) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2355 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2356 assert(*it != NULL); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2357 delete *it; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2358 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2359 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2360 content_.clear(); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2361 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2362 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2363 void Flatten(std::string& target) const |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2364 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2365 target.resize(size_); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2366 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2367 size_t pos = 0; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2368 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2369 for (Content::const_iterator it = content_.begin(); it != content_.end(); ++it) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2370 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2371 assert(*it != NULL); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2372 size_t s = (*it)->size(); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2373 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2374 if (s != 0) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2375 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2376 memcpy(&target[pos], (*it)->c_str(), s); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2377 pos += s; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2378 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2379 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2380 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2381 assert(size_ == 0 || |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2382 pos == target.size()); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2383 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2384 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2385 void AddChunk(const void* data, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2386 size_t size) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2387 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2388 content_.push_back(new std::string(reinterpret_cast<const char*>(data), size)); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2389 size_ += size; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2390 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2391 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2392 void AddChunk(const std::string& chunk) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2393 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2394 content_.push_back(new std::string(chunk)); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2395 size_ += chunk.size(); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2396 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2397 }; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2398 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2399 |
3413 | 2400 #if HAS_ORTHANC_PLUGIN_CHUNKED_HTTP_CLIENT == 1 |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2401 class MemoryAnswer : public HttpClient::IAnswer |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2402 { |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2403 private: |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2404 HttpClient::HttpHeaders headers_; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2405 ChunkedBuffer body_; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2406 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2407 public: |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2408 const HttpClient::HttpHeaders& GetHeaders() const |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2409 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2410 return headers_; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2411 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2412 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2413 const ChunkedBuffer& GetBody() const |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2414 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2415 return body_; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2416 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2417 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2418 virtual void AddHeader(const std::string& key, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2419 const std::string& value) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2420 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2421 headers_[key] = value; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2422 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2423 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2424 virtual void AddChunk(const void* data, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2425 size_t size) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2426 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2427 body_.AddChunk(data, size); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2428 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2429 }; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2430 #endif |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2431 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2432 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2433 |
3413 | 2434 #if HAS_ORTHANC_PLUGIN_CHUNKED_HTTP_CLIENT == 1 |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2435 void HttpClient::ExecuteWithStream(uint16_t& httpStatus, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2436 IAnswer& answer, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2437 IRequestBody& body) const |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2438 { |
3394 | 2439 HeadersWrapper h(headers_); |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2440 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2441 // Automatically set the "Transfer-Encoding" header if absent |
3394 | 2442 bool found = false; |
2443 | |
2444 for (HttpHeaders::const_iterator it = headers_.begin(); it != headers_.end(); ++it) | |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2445 { |
3394 | 2446 if (boost::iequals(it->first, "Transfer-Encoding")) |
2447 { | |
2448 found = true; | |
2449 break; | |
2450 } | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2451 } |
3394 | 2452 |
2453 if (!found) | |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2454 { |
3394 | 2455 h.AddStaticString("Transfer-Encoding", "chunked"); |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2456 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2457 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2458 RequestBodyWrapper request(body); |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2459 |
3413 | 2460 OrthancPluginErrorCode error = OrthancPluginChunkedHttpClient( |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2461 GetGlobalContext(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2462 &answer, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2463 AnswerAddChunkCallback, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2464 AnswerAddHeaderCallback, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2465 &httpStatus, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2466 method_, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2467 url_.c_str(), |
3394 | 2468 h.GetCount(), |
2469 h.GetKeys(), | |
2470 h.GetValues(), | |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2471 &request, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2472 RequestBodyWrapper::IsDone, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2473 RequestBodyWrapper::GetChunkData, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2474 RequestBodyWrapper::GetChunkSize, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2475 RequestBodyWrapper::Next, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2476 username_.empty() ? NULL : username_.c_str(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2477 password_.empty() ? NULL : password_.c_str(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2478 timeout_, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2479 certificateFile_.empty() ? NULL : certificateFile_.c_str(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2480 certificateFile_.empty() ? NULL : certificateKeyFile_.c_str(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2481 certificateFile_.empty() ? NULL : certificateKeyPassword_.c_str(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2482 pkcs11_ ? 1 : 0); |
3387
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2483 |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2484 if (error != OrthancPluginErrorCode_Success) |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2485 { |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2486 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(error); |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2487 } |
a48d652f1500
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3320
diff
changeset
|
2488 } |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2489 #endif |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2490 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2491 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2492 void HttpClient::ExecuteWithoutStream(uint16_t& httpStatus, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2493 HttpHeaders& answerHeaders, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2494 std::string& answerBody, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2495 const std::string& body) const |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2496 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2497 HeadersWrapper headers(headers_); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2498 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2499 MemoryBuffer answerBodyBuffer, answerHeadersBuffer; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2500 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2501 OrthancPluginErrorCode error = OrthancPluginHttpClient( |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2502 GetGlobalContext(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2503 *answerBodyBuffer, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2504 *answerHeadersBuffer, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2505 &httpStatus, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2506 method_, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2507 url_.c_str(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2508 headers.GetCount(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2509 headers.GetKeys(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2510 headers.GetValues(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2511 body.empty() ? NULL : body.c_str(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2512 body.size(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2513 username_.empty() ? NULL : username_.c_str(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2514 password_.empty() ? NULL : password_.c_str(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2515 timeout_, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2516 certificateFile_.empty() ? NULL : certificateFile_.c_str(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2517 certificateFile_.empty() ? NULL : certificateKeyFile_.c_str(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2518 certificateFile_.empty() ? NULL : certificateKeyPassword_.c_str(), |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2519 pkcs11_ ? 1 : 0); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2520 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2521 if (error != OrthancPluginErrorCode_Success) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2522 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2523 ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(error); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2524 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2525 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2526 Json::Value v; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2527 answerHeadersBuffer.ToJson(v); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2528 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2529 if (v.type() != Json::objectValue) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2530 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2531 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2532 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2533 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2534 Json::Value::Members members = v.getMemberNames(); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2535 answerHeaders.clear(); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2536 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2537 for (size_t i = 0; i < members.size(); i++) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2538 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2539 const Json::Value& h = v[members[i]]; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2540 if (h.type() != Json::stringValue) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2541 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2542 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2543 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2544 else |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2545 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2546 answerHeaders[members[i]] = h.asString(); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2547 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2548 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2549 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2550 answerBodyBuffer.ToString(answerBody); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2551 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2552 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2553 |
3413 | 2554 #if HAS_ORTHANC_PLUGIN_CHUNKED_HTTP_CLIENT == 1 |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2555 void HttpClient::Execute(IAnswer& answer) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2556 { |
3413 | 2557 if (chunkedBody_ != NULL) |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2558 { |
3413 | 2559 ExecuteWithStream(httpStatus_, answer, *chunkedBody_); |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2560 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2561 else |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2562 { |
3413 | 2563 MemoryRequestBody wrapper(fullBody_); |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2564 ExecuteWithStream(httpStatus_, answer, wrapper); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2565 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2566 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2567 #endif |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2568 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2569 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2570 void HttpClient::Execute(HttpHeaders& answerHeaders /* out */, |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2571 std::string& answerBody /* out */) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2572 { |
3413 | 2573 #if HAS_ORTHANC_PLUGIN_CHUNKED_HTTP_CLIENT == 1 |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2574 MemoryAnswer answer; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2575 Execute(answer); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2576 answerHeaders = answer.GetHeaders(); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2577 answer.GetBody().Flatten(answerBody); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2578 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2579 #else |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2580 // Compatibility mode for Orthanc SDK <= 1.5.6. This results in |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2581 // higher memory usage (all chunks from the body request are sent |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2582 // at once) |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2583 |
3413 | 2584 if (chunkedBody_ != NULL) |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2585 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2586 ChunkedBuffer buffer; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2587 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2588 std::string chunk; |
3413 | 2589 while (chunkedBody_->ReadNextChunk(chunk)) |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2590 { |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2591 buffer.AddChunk(chunk); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2592 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2593 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2594 std::string body; |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2595 buffer.Flatten(body); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2596 |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2597 ExecuteWithoutStream(httpStatus_, answerHeaders, answerBody, body); |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2598 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2599 else |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2600 { |
3413 | 2601 ExecuteWithoutStream(httpStatus_, answerHeaders, answerBody, fullBody_); |
3393
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2602 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2603 #endif |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2604 } |
2cd0369a156f
support of chunked answers in HttpClient and in SDK
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3392
diff
changeset
|
2605 |
3388 | 2606 #endif /* HAS_ORTHANC_PLUGIN_HTTP_CLIENT == 1 */ |
3416 | 2607 |
2608 | |
2609 | |
2610 | |
2611 | |
2612 /****************************************************************** | |
2613 ** CHUNKED HTTP SERVER | |
2614 ******************************************************************/ | |
2615 | |
2616 namespace Internals | |
2617 { | |
2618 void NullRestCallback(OrthancPluginRestOutput* output, | |
2619 const char* url, | |
2620 const OrthancPluginHttpRequest* request) | |
2621 { | |
2622 } | |
2623 | |
2624 IChunkedRequestReader *NullChunkedRestCallback(const char* url, | |
2625 const OrthancPluginHttpRequest* request) | |
2626 { | |
2627 return NULL; | |
2628 } | |
2629 | |
2630 | |
2631 #if HAS_ORTHANC_PLUGIN_CHUNKED_HTTP_SERVER == 1 | |
2632 | |
2633 OrthancPluginErrorCode ChunkedRequestReaderAddChunk( | |
2634 OrthancPluginServerChunkedRequestReader* reader, | |
2635 const void* data, | |
2636 uint32_t size) | |
2637 { | |
2638 try | |
2639 { | |
2640 if (reader == NULL) | |
2641 { | |
2642 return OrthancPluginErrorCode_InternalError; | |
2643 } | |
2644 | |
2645 reinterpret_cast<IChunkedRequestReader*>(reader)->AddChunk(data, size); | |
2646 return OrthancPluginErrorCode_Success; | |
2647 } | |
2648 catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) | |
2649 { | |
2650 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); | |
2651 } | |
2652 catch (boost::bad_lexical_cast&) | |
2653 { | |
2654 return OrthancPluginErrorCode_BadFileFormat; | |
2655 } | |
2656 catch (...) | |
2657 { | |
2658 return OrthancPluginErrorCode_Plugin; | |
2659 } | |
2660 } | |
2661 | |
2662 | |
2663 OrthancPluginErrorCode ChunkedRequestReaderExecute( | |
2664 OrthancPluginServerChunkedRequestReader* reader, | |
2665 OrthancPluginRestOutput* output) | |
2666 { | |
2667 try | |
2668 { | |
2669 if (reader == NULL) | |
2670 { | |
2671 return OrthancPluginErrorCode_InternalError; | |
2672 } | |
2673 | |
2674 reinterpret_cast<IChunkedRequestReader*>(reader)->Execute(output); | |
2675 return OrthancPluginErrorCode_Success; | |
2676 } | |
2677 catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) | |
2678 { | |
2679 return static_cast<OrthancPluginErrorCode>(e.GetErrorCode()); | |
2680 } | |
2681 catch (boost::bad_lexical_cast&) | |
2682 { | |
2683 return OrthancPluginErrorCode_BadFileFormat; | |
2684 } | |
2685 catch (...) | |
2686 { | |
2687 return OrthancPluginErrorCode_Plugin; | |
2688 } | |
2689 } | |
2690 | |
2691 | |
2692 void ChunkedRequestReaderFinalize( | |
2693 OrthancPluginServerChunkedRequestReader* reader) | |
2694 { | |
2695 if (reader != NULL) | |
2696 { | |
2697 delete reinterpret_cast<IChunkedRequestReader*>(reader); | |
2698 } | |
2699 } | |
2700 | |
2701 #else | |
2702 | |
2703 void ChunkedRestCompatibility(OrthancPluginRestOutput* output, | |
2704 const char* url, | |
2705 const OrthancPluginHttpRequest* request, | |
2706 RestCallback GetHandler, | |
2707 ChunkedRestCallback PostHandler, | |
2708 RestCallback DeleteHandler, | |
2709 ChunkedRestCallback PutHandler) | |
2710 { | |
2711 std::string allowed; | |
2712 | |
2713 if (GetHandler != Internals::NullRestCallback) | |
2714 { | |
2715 allowed += "GET"; | |
2716 } | |
2717 | |
2718 if (PostHandler != Internals::NullChunkedRestCallback) | |
2719 { | |
2720 if (!allowed.empty()) | |
2721 { | |
2722 allowed += ","; | |
2723 } | |
2724 | |
2725 allowed += "POST"; | |
2726 } | |
2727 | |
2728 if (DeleteHandler != Internals::NullRestCallback) | |
2729 { | |
2730 if (!allowed.empty()) | |
2731 { | |
2732 allowed += ","; | |
2733 } | |
2734 | |
2735 allowed += "DELETE"; | |
2736 } | |
2737 | |
2738 if (PutHandler != Internals::NullChunkedRestCallback) | |
2739 { | |
2740 if (!allowed.empty()) | |
2741 { | |
2742 allowed += ","; | |
2743 } | |
2744 | |
2745 allowed += "PUT"; | |
2746 } | |
2747 | |
2748 switch (request->method) | |
2749 { | |
2750 case OrthancPluginHttpMethod_Get: | |
2751 { | |
2752 if (GetHandler == Internals::NullRestCallback) | |
2753 { | |
2754 OrthancPluginSendMethodNotAllowed(GetGlobalContext(), output, allowed.c_str()); | |
2755 } | |
2756 else | |
2757 { | |
2758 GetHandler(output, url, request); | |
2759 } | |
2760 return; | |
2761 } | |
2762 | |
2763 case OrthancPluginHttpMethod_Post: | |
2764 { | |
2765 if (PostHandler == Internals::NullChunkedRestCallback) | |
2766 { | |
2767 OrthancPluginSendMethodNotAllowed(GetGlobalContext(), output, allowed.c_str()); | |
2768 } | |
2769 else | |
2770 { | |
2771 std::auto_ptr<IChunkedRequestReader> reader(PostHandler(url, request)); | |
2772 if (reader.get() == NULL) | |
2773 { | |
2774 ORTHANC_PLUGINS_THROW_EXCEPTION(Plugin); | |
2775 } | |
2776 else | |
2777 { | |
2778 reader->AddChunk(request->body, request->bodySize); | |
2779 reader->Execute(output); | |
2780 } | |
2781 } | |
2782 return; | |
2783 } | |
2784 | |
2785 case OrthancPluginHttpMethod_Delete: | |
2786 { | |
2787 if (DeleteHandler == Internals::NullRestCallback) | |
2788 { | |
2789 OrthancPluginSendMethodNotAllowed(GetGlobalContext(), output, allowed.c_str()); | |
2790 } | |
2791 else | |
2792 { | |
2793 DeleteHandler(output, url, request); | |
2794 } | |
2795 return; | |
2796 } | |
2797 | |
2798 case OrthancPluginHttpMethod_Put: | |
2799 { | |
2800 if (PutHandler == Internals::NullChunkedRestCallback) | |
2801 { | |
2802 OrthancPluginSendMethodNotAllowed(GetGlobalContext(), output, allowed.c_str()); | |
2803 } | |
2804 else | |
2805 { | |
2806 std::auto_ptr<IChunkedRequestReader> reader(PutHandler(url, request)); | |
2807 if (reader.get() == NULL) | |
2808 { | |
2809 ORTHANC_PLUGINS_THROW_EXCEPTION(Plugin); | |
2810 } | |
2811 else | |
2812 { | |
2813 reader->AddChunk(request->body, request->bodySize); | |
2814 reader->Execute(output); | |
2815 } | |
2816 } | |
2817 return; | |
2818 } | |
2819 | |
2820 default: | |
2821 ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); | |
2822 } | |
2823 } | |
2824 #endif | |
2825 } | |
2047
438f86ee19fc
toolbox shared by all plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
diff
changeset
|
2826 } |