Mercurial > hg > orthanc

comparison Plugins/Engine/OrthancPlugins.cpp @ 1133:382e162c074c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
rename
author Sebastien Jodogne <s.jodogne@gmail.com>
date Tue, 09 Sep 2014 10:45:14 +0200
parents f739d3f6cfcf
children 67c3c1e4a6e0
comparison
equal deleted inserted replaced
1132:f739d3f6cfcf 1133:382e162c074c
28 * You should have received a copy of the GNU General Public License 28 * You should have received a copy of the GNU General Public License
29 * along with this program. If not, see <http://www.gnu.org/licenses/>. 29 * along with this program. If not, see <http://www.gnu.org/licenses/>.
30 **/ 30 **/
31 31
32 32
33 #include "PluginsHttpHandler.h" 33 #include "OrthancPlugins.h"
34 34
35 #include "../../Core/ChunkedBuffer.h" 35 #include "../../Core/ChunkedBuffer.h"
36 #include "../../Core/OrthancException.h" 36 #include "../../Core/OrthancException.h"
37 #include "../../Core/Toolbox.h" 37 #include "../../Core/Toolbox.h"
38 #include "../../Core/HttpServer/HttpOutput.h" 38 #include "../../Core/HttpServer/HttpOutput.h"
76 }; 76 };
77 } 77 }
78 78
79 79
80 80
81 struct PluginsHttpHandler::PImpl 81 struct OrthancPlugins::PImpl
82 { 82 {
83 typedef std::pair<boost::regex*, OrthancPluginRestCallback> RestCallback; 83 typedef std::pair<boost::regex*, OrthancPluginRestCallback> RestCallback;
84 typedef std::list<RestCallback> RestCallbacks; 84 typedef std::list<RestCallback> RestCallbacks;
85 typedef std::list<OrthancPluginOnStoredInstanceCallback> OnStoredCallbacks; 85 typedef std::list<OrthancPluginOnStoredInstanceCallback> OnStoredCallbacks;
86 86
114 114
115 return result; 115 return result;
116 } 116 }
117 117
118 118
119 PluginsHttpHandler::PluginsHttpHandler(ServerContext& context) 119 OrthancPlugins::OrthancPlugins(ServerContext& context)
120 { 120 {
121 pimpl_.reset(new PImpl(context)); 121 pimpl_.reset(new PImpl(context));
122 } 122 }
123 123
124 124
125 PluginsHttpHandler::~PluginsHttpHandler() 125 OrthancPlugins::~OrthancPlugins()
126 { 126 {
127 for (PImpl::RestCallbacks::iterator it = pimpl_->restCallbacks_.begin(); 127 for (PImpl::RestCallbacks::iterator it = pimpl_->restCallbacks_.begin();
128 it != pimpl_->restCallbacks_.end(); ++it) 128 it != pimpl_->restCallbacks_.end(); ++it)
129 { 129 {
130 // Delete the regular expression associated with this callback 130 // Delete the regular expression associated with this callback
149 pos++; 149 pos++;
150 } 150 }
151 } 151 }
152 152
153 153
154 bool PluginsHttpHandler::Handle(HttpOutput& output, 154 bool OrthancPlugins::Handle(HttpOutput& output,
155 HttpMethod method, 155 HttpMethod method,
156 const UriComponents& uri, 156 const UriComponents& uri,
157 const Arguments& headers, 157 const Arguments& headers,
158 const Arguments& getArguments, 158 const Arguments& getArguments,
159 const std::string& postData) 159 const std::string& postData)
269 return true; 269 return true;
270 } 270 }
271 } 271 }
272 272
273 273
274 void PluginsHttpHandler::SignalStoredInstance(DicomInstanceToStore& instance, 274 void OrthancPlugins::SignalStoredInstance(DicomInstanceToStore& instance,
275 const std::string& instanceId) 275 const std::string& instanceId)
276 { 276 {
277 for (PImpl::OnStoredCallbacks::const_iterator 277 for (PImpl::OnStoredCallbacks::const_iterator
278 callback = pimpl_->onStoredCallbacks_.begin(); 278 callback = pimpl_->onStoredCallbacks_.begin();
279 callback != pimpl_->onStoredCallbacks_.end(); ++callback) 279 callback != pimpl_->onStoredCallbacks_.end(); ++callback)
323 CopyToMemoryBuffer(target, str.c_str(), str.size()); 323 CopyToMemoryBuffer(target, str.c_str(), str.size());
324 } 324 }
325 } 325 }
326 326
327 327
328 void PluginsHttpHandler::RegisterRestCallback(const void* parameters) 328 void OrthancPlugins::RegisterRestCallback(const void* parameters)
329 { 329 {
330 const _OrthancPluginRestCallback& p = 330 const _OrthancPluginRestCallback& p =
331 *reinterpret_cast<const _OrthancPluginRestCallback*>(parameters); 331 *reinterpret_cast<const _OrthancPluginRestCallback*>(parameters);
332 332
333 LOG(INFO) << "Plugin has registered a REST callback on: " << p.pathRegularExpression; 333 LOG(INFO) << "Plugin has registered a REST callback on: " << p.pathRegularExpression;
334 pimpl_->restCallbacks_.push_back(std::make_pair(new boost::regex(p.pathRegularExpression), p.callback)); 334 pimpl_->restCallbacks_.push_back(std::make_pair(new boost::regex(p.pathRegularExpression), p.callback));
335 } 335 }
336 336
337 337
338 338
339 void PluginsHttpHandler::RegisterOnStoredInstanceCallback(const void* parameters) 339 void OrthancPlugins::RegisterOnStoredInstanceCallback(const void* parameters)
340 { 340 {
341 const _OrthancPluginOnStoredInstanceCallback& p = 341 const _OrthancPluginOnStoredInstanceCallback& p =
342 *reinterpret_cast<const _OrthancPluginOnStoredInstanceCallback*>(parameters); 342 *reinterpret_cast<const _OrthancPluginOnStoredInstanceCallback*>(parameters);
343 343
344 LOG(INFO) << "Plugin has registered an OnStoredInstance callback"; 344 LOG(INFO) << "Plugin has registered an OnStoredInstance callback";
345 pimpl_->onStoredCallbacks_.push_back(p.callback); 345 pimpl_->onStoredCallbacks_.push_back(p.callback);
346 } 346 }
347 347
348 348
349 349
350 void PluginsHttpHandler::AnswerBuffer(const void* parameters) 350 void OrthancPlugins::AnswerBuffer(const void* parameters)
351 { 351 {
352 const _OrthancPluginAnswerBuffer& p = 352 const _OrthancPluginAnswerBuffer& p =
353 *reinterpret_cast<const _OrthancPluginAnswerBuffer*>(parameters); 353 *reinterpret_cast<const _OrthancPluginAnswerBuffer*>(parameters);
354 354
355 HttpOutput* translatedOutput = reinterpret_cast<HttpOutput*>(p.output); 355 HttpOutput* translatedOutput = reinterpret_cast<HttpOutput*>(p.output);
356 translatedOutput->SetContentType(p.mimeType); 356 translatedOutput->SetContentType(p.mimeType);
357 translatedOutput->SendBody(p.answer, p.answerSize); 357 translatedOutput->SendBody(p.answer, p.answerSize);
358 } 358 }
359 359
360 360
361 void PluginsHttpHandler::Redirect(const void* parameters) 361 void OrthancPlugins::Redirect(const void* parameters)
362 { 362 {
363 const _OrthancPluginOutputPlusArgument& p = 363 const _OrthancPluginOutputPlusArgument& p =
364 *reinterpret_cast<const _OrthancPluginOutputPlusArgument*>(parameters); 364 *reinterpret_cast<const _OrthancPluginOutputPlusArgument*>(parameters);
365 365
366 HttpOutput* translatedOutput = reinterpret_cast<HttpOutput*>(p.output); 366 HttpOutput* translatedOutput = reinterpret_cast<HttpOutput*>(p.output);
367 translatedOutput->Redirect(p.argument); 367 translatedOutput->Redirect(p.argument);
368 } 368 }
369 369
370 370
371 void PluginsHttpHandler::SendHttpStatusCode(const void* parameters) 371 void OrthancPlugins::SendHttpStatusCode(const void* parameters)
372 { 372 {
373 const _OrthancPluginSendHttpStatusCode& p = 373 const _OrthancPluginSendHttpStatusCode& p =
374 *reinterpret_cast<const _OrthancPluginSendHttpStatusCode*>(parameters); 374 *reinterpret_cast<const _OrthancPluginSendHttpStatusCode*>(parameters);
375 375
376 HttpOutput* translatedOutput = reinterpret_cast<HttpOutput*>(p.output); 376 HttpOutput* translatedOutput = reinterpret_cast<HttpOutput*>(p.output);
377 translatedOutput->SendStatus(static_cast<HttpStatus>(p.status)); 377 translatedOutput->SendStatus(static_cast<HttpStatus>(p.status));
378 } 378 }
379 379
380 380
381 void PluginsHttpHandler::SendUnauthorized(const void* parameters) 381 void OrthancPlugins::SendUnauthorized(const void* parameters)
382 { 382 {
383 const _OrthancPluginOutputPlusArgument& p = 383 const _OrthancPluginOutputPlusArgument& p =
384 *reinterpret_cast<const _OrthancPluginOutputPlusArgument*>(parameters); 384 *reinterpret_cast<const _OrthancPluginOutputPlusArgument*>(parameters);
385 385
386 HttpOutput* translatedOutput = reinterpret_cast<HttpOutput*>(p.output); 386 HttpOutput* translatedOutput = reinterpret_cast<HttpOutput*>(p.output);
387 translatedOutput->SendUnauthorized(p.argument); 387 translatedOutput->SendUnauthorized(p.argument);
388 } 388 }
389 389
390 390
391 void PluginsHttpHandler::SendMethodNotAllowed(const void* parameters) 391 void OrthancPlugins::SendMethodNotAllowed(const void* parameters)
392 { 392 {
393 const _OrthancPluginOutputPlusArgument& p = 393 const _OrthancPluginOutputPlusArgument& p =
394 *reinterpret_cast<const _OrthancPluginOutputPlusArgument*>(parameters); 394 *reinterpret_cast<const _OrthancPluginOutputPlusArgument*>(parameters);
395 395
396 HttpOutput* translatedOutput = reinterpret_cast<HttpOutput*>(p.output); 396 HttpOutput* translatedOutput = reinterpret_cast<HttpOutput*>(p.output);
397 translatedOutput->SendMethodNotAllowed(p.argument); 397 translatedOutput->SendMethodNotAllowed(p.argument);
398 } 398 }
399 399
400 400
401 void PluginsHttpHandler::SetCookie(const void* parameters) 401 void OrthancPlugins::SetCookie(const void* parameters)
402 { 402 {
403 const _OrthancPluginSetCookie& p = 403 const _OrthancPluginSetCookie& p =
404 *reinterpret_cast<const _OrthancPluginSetCookie*>(parameters); 404 *reinterpret_cast<const _OrthancPluginSetCookie*>(parameters);
405 405
406 HttpOutput* translatedOutput = reinterpret_cast<HttpOutput*>(p.output); 406 HttpOutput* translatedOutput = reinterpret_cast<HttpOutput*>(p.output);
407 translatedOutput->SetCookie(p.cookie, p.value); 407 translatedOutput->SetCookie(p.cookie, p.value);
408 } 408 }
409 409
410 410
411 void PluginsHttpHandler::CompressAndAnswerPngImage(const void* parameters) 411 void OrthancPlugins::CompressAndAnswerPngImage(const void* parameters)
412 { 412 {
413 const _OrthancPluginCompressAndAnswerPngImage& p = 413 const _OrthancPluginCompressAndAnswerPngImage& p =
414 *reinterpret_cast<const _OrthancPluginCompressAndAnswerPngImage*>(parameters); 414 *reinterpret_cast<const _OrthancPluginCompressAndAnswerPngImage*>(parameters);
415 415
416 HttpOutput* translatedOutput = reinterpret_cast<HttpOutput*>(p.output); 416 HttpOutput* translatedOutput = reinterpret_cast<HttpOutput*>(p.output);
452 translatedOutput->SetContentType("image/png"); 452 translatedOutput->SetContentType("image/png");
453 translatedOutput->SendBody(png); 453 translatedOutput->SendBody(png);
454 } 454 }
455 455
456 456
457 void PluginsHttpHandler::GetDicomForInstance(const void* parameters) 457 void OrthancPlugins::GetDicomForInstance(const void* parameters)
458 { 458 {
459 const _OrthancPluginGetDicomForInstance& p = 459 const _OrthancPluginGetDicomForInstance& p =
460 *reinterpret_cast<const _OrthancPluginGetDicomForInstance*>(parameters); 460 *reinterpret_cast<const _OrthancPluginGetDicomForInstance*>(parameters);
461 461
462 std::string dicom; 462 std::string dicom;
463 pimpl_->context_.ReadFile(dicom, p.instanceId, FileContentType_Dicom); 463 pimpl_->context_.ReadFile(dicom, p.instanceId, FileContentType_Dicom);
464 CopyToMemoryBuffer(*p.target, dicom); 464 CopyToMemoryBuffer(*p.target, dicom);
465 } 465 }
466 466
467 467
468 void PluginsHttpHandler::RestApiGet(const void* parameters) 468 void OrthancPlugins::RestApiGet(const void* parameters)
469 { 469 {
470 const _OrthancPluginRestApiGet& p = 470 const _OrthancPluginRestApiGet& p =
471 *reinterpret_cast<const _OrthancPluginRestApiGet*>(parameters); 471 *reinterpret_cast<const _OrthancPluginRestApiGet*>(parameters);
472 472
473 HttpHandler::Arguments headers; // No HTTP header 473 HttpHandler::Arguments headers; // No HTTP header
494 throw OrthancException(ErrorCode_BadRequest); 494 throw OrthancException(ErrorCode_BadRequest);
495 } 495 }
496 } 496 }
497 497
498 498
499 void PluginsHttpHandler::RestApiPostPut(bool isPost, const void* parameters) 499 void OrthancPlugins::RestApiPostPut(bool isPost, const void* parameters)
500 { 500 {
501 const _OrthancPluginRestApiPostPut& p = 501 const _OrthancPluginRestApiPostPut& p =
502 *reinterpret_cast<const _OrthancPluginRestApiPostPut*>(parameters); 502 *reinterpret_cast<const _OrthancPluginRestApiPostPut*>(parameters);
503 503
504 HttpHandler::Arguments headers; // No HTTP header 504 HttpHandler::Arguments headers; // No HTTP header
528 throw OrthancException(ErrorCode_BadRequest); 528 throw OrthancException(ErrorCode_BadRequest);
529 } 529 }
530 } 530 }
531 531
532 532
533 void PluginsHttpHandler::RestApiDelete(const void* parameters) 533 void OrthancPlugins::RestApiDelete(const void* parameters)
534 { 534 {
535 // The "parameters" point to the URI 535 // The "parameters" point to the URI
536 UriComponents uri; 536 UriComponents uri;
537 Toolbox::SplitUriComponents(uri, reinterpret_cast<const char*>(parameters)); 537 Toolbox::SplitUriComponents(uri, reinterpret_cast<const char*>(parameters));
538 538
552 throw OrthancException(ErrorCode_BadRequest); 552 throw OrthancException(ErrorCode_BadRequest);
553 } 553 }
554 } 554 }
555 555
556 556
557 void PluginsHttpHandler::LookupResource(_OrthancPluginService service, 557 void OrthancPlugins::LookupResource(_OrthancPluginService service,
558 const void* parameters) 558 const void* parameters)
559 { 559 {
560 const _OrthancPluginLookupResource& p = 560 const _OrthancPluginLookupResource& p =
561 *reinterpret_cast<const _OrthancPluginLookupResource*>(parameters); 561 *reinterpret_cast<const _OrthancPluginLookupResource*>(parameters);
562 562
724 throw OrthancException(ErrorCode_InternalError); 724 throw OrthancException(ErrorCode_InternalError);
725 } 725 }
726 } 726 }
727 727
728 728
729 bool PluginsHttpHandler::InvokeService(_OrthancPluginService service, 729 bool OrthancPlugins::InvokeService(_OrthancPluginService service,
730 const void* parameters) 730 const void* parameters)
731 { 731 {
732 switch (service) 732 switch (service)
733 { 733 {
734 case _OrthancPluginService_RegisterRestCallback: 734 case _OrthancPluginService_RegisterRestCallback:
809 return false; 809 return false;
810 } 810 }
811 } 811 }
812 812
813 813
814 void PluginsHttpHandler::SetOrthancRestApi(OrthancRestApi& restApi) 814 void OrthancPlugins::SetOrthancRestApi(OrthancRestApi& restApi)
815 { 815 {
816 pimpl_->restApi_ = &restApi; 816 pimpl_->restApi_ = &restApi;
817 } 817 }
818 818
819 } 819 }