commit 3e63ff2a3767fd9ceddc14ef95676506ad02dbf3 Author: Aljaž Gerečnik Date: Sat Feb 15 10:13:20 2025 +0100 Added mammography plugin button on instance level diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..310c943 --- /dev/null +++ b/.gitignore @@ -0,0 +1,9 @@ +WebApplication/node_modules +WebApplication/dist/ +ThirdPartyDownloads/ +.DS_Store +dist-ssr +*.local +.vscode/ +*~ +build \ No newline at end of file diff --git a/AUTHORS b/AUTHORS new file mode 100644 index 0000000..7a7a95f --- /dev/null +++ b/AUTHORS @@ -0,0 +1,27 @@ +Orthanc Explorer 2 +================== + + +Authors +------- + +* Orthanc Team SRL + Rue Joseph Marchal 14 + 4910 Theux + Belgium + https://orthanc.team/ + +* Sebastien Jodogne + +* Osimis S.A. + Quai Banning 6 + 4000 Liege + Belgium + +* ICTEAM, UCLouvain + Place de l'Universite 1 + 1348 Ottignies-Louvain-la-Neuve + Belgium + https://uclouvain.be/icteam + +* Luc Billaud diff --git a/CITATION.cff b/CITATION.cff new file mode 100644 index 0000000..f871c69 --- /dev/null +++ b/CITATION.cff @@ -0,0 +1,14 @@ +cff-version: "1.1.0" +message: "If you use this software, please cite it using these metadata." +title: Orthanc +abstract: "Orthanc is a lightweight open-source DICOM server for medical imaging supporting representational state transfer (REST)." +authors: + - + affiliation: UCLouvain + family-names: Jodogne + given-names: "Sébastien" +doi: "10.1007/s10278-018-0082-y" +license: "GPL-3.0-or-later" +repository-code: "https://orthanc.uclouvain.be/hg/orthanc/" +version: 1.12.3 +date-released: 2024-01-31 diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..5a3f5dc --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,237 @@ +# Orthanc - A Lightweight, RESTful DICOM Store +# Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics +# Department, University Hospital of Liege, Belgium +# Copyright (C) 2017-2024 Osimis S.A., Belgium +# Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium +# Copyright (C) 2024-2024 Orthanc Team SRL, Belgium +# +# This program is free software: you can redistribute it and/or +# modify it under the terms of the GNU Affero General Public License +# as published by the Free Software Foundation, either version 3 of +# the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with this program. If not, see . + + +cmake_minimum_required(VERSION 3.1) + +if (APPLE) + set(CMAKE_OSX_ARCHITECTURES "x86_64;arm64" CACHE STRING "Build architectures for Mac OS X" FORCE) + set(CMAKE_CXX_STANDARD 11) +endif(APPLE) + +project(OrthancExplorer2) + +set(PLUGIN_VERSION "mainline" CACHE STRING "plugin version 'mainline' or '1.2.3'") + +if (PLUGIN_VERSION MATCHES "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$") + set(ORTHANC_FRAMEWORK_DEFAULT_VERSION "1.12.2") + set(ORTHANC_FRAMEWORK_DEFAULT_SOURCE "web") + set(ORTHANC_OE2_VERSION ${PLUGIN_VERSION}) +else() + set(ORTHANC_FRAMEWORK_DEFAULT_VERSION "mainline") + set(ORTHANC_FRAMEWORK_DEFAULT_SOURCE "hg") + set(ORTHANC_OE2_VERSION "mainline") +endif() + + +# Parameters of the build +set(STATIC_BUILD OFF CACHE BOOL "Static build of the third-party libraries (necessary for Windows)") +set(STANDALONE_BUILD ON CACHE BOOL "Standalone build (all the resources are embedded, necessary for releases)") +set(ALLOW_DOWNLOADS ON CACHE BOOL "Allow CMake to download packages") +set(ORTHANC_FRAMEWORK_SOURCE "${ORTHANC_FRAMEWORK_DEFAULT_SOURCE}" CACHE STRING "Source of the Orthanc framework (can be \"system\", \"hg\", \"archive\", \"web\" or \"path\")") +set(ORTHANC_FRAMEWORK_VERSION "${ORTHANC_FRAMEWORK_DEFAULT_VERSION}" CACHE STRING "Version of the Orthanc framework") +set(ORTHANC_FRAMEWORK_ARCHIVE "" CACHE STRING "Path to the Orthanc archive, if ORTHANC_FRAMEWORK_SOURCE is \"archive\"") +set(ORTHANC_FRAMEWORK_ROOT "" CACHE STRING "Path to the Orthanc source directory, if ORTHANC_FRAMEWORK_SOURCE is \"path\"") +set(WEBAPP_DIST_PATH "${CMAKE_SOURCE_DIR}/WebApplication/dist" CACHE STRING "Path to the WebApplication/dist folder (the output of 'npm run build')") +set(WEBAPP_DIST_SOURCE "LOCAL" CACHE STRING "Source for the WebApplication/dist folder ('LOCAL' = assume it is build localy, 'WEB' = download it from web)") +set(WEBAPP_DIST_VERSION "${PLUGIN_VERSION}" CACHE STRING "Version of WebApplication/dist folder to download") +file(TO_CMAKE_PATH "${WEBAPP_DIST_PATH}" WEBAPP_DIST_PATH) + +# Advanced parameters to fine-tune linking against system libraries +set(USE_SYSTEM_ORTHANC_SDK ON CACHE BOOL "Use the system version of the Orthanc plugin SDK") +set(ORTHANC_SDK_VERSION "1.11.2" CACHE STRING "Version of the Orthanc plugin SDK to use, if not using the system version (can be \"1.11.2\")") +set(ORTHANC_FRAMEWORK_STATIC OFF CACHE BOOL "If linking against the Orthanc framework system library, indicates whether this library was statically linked") +mark_as_advanced(ORTHANC_FRAMEWORK_STATIC) + + +# Download and setup the Orthanc framework +include(${CMAKE_SOURCE_DIR}/Resources/Orthanc/CMake/DownloadOrthancFramework.cmake) + +if (ORTHANC_FRAMEWORK_SOURCE STREQUAL "system") + if (ORTHANC_FRAMEWORK_USE_SHARED) + include(FindBoost) + find_package(Boost COMPONENTS regex thread) + + if (NOT Boost_FOUND) + message(FATAL_ERROR "Unable to locate Boost on this system") + endif() + + link_libraries(${Boost_LIBRARIES} jsoncpp) + endif() + + link_libraries(${ORTHANC_FRAMEWORK_LIBRARIES}) + + set(USE_SYSTEM_GOOGLE_TEST ON CACHE BOOL "Use the system version of Google Test") + set(USE_GOOGLE_TEST_DEBIAN_PACKAGE OFF CACHE BOOL "Use the sources of Google Test shipped with libgtest-dev (Debian only)") + mark_as_advanced(USE_GOOGLE_TEST_DEBIAN_PACKAGE) + include(${CMAKE_SOURCE_DIR}/Resources/Orthanc/CMake/GoogleTestConfiguration.cmake) + +else() + include(${ORTHANC_FRAMEWORK_ROOT}/../Resources/CMake/OrthancFrameworkParameters.cmake) + + set(ENABLE_LOCALE OFF) # Enable support for locales (notably in Boost) + #set(ENABLE_GOOGLE_TEST ON) + #set(ENABLE_WEB_CLIENT ON) + + # Those modules of the Orthanc framework are not needed + set(ENABLE_MODULE_IMAGES OFF) + set(ENABLE_MODULE_JOBS OFF) + set(ENABLE_MODULE_DICOM OFF) + + include(${ORTHANC_FRAMEWORK_ROOT}/../Resources/CMake/OrthancFrameworkConfiguration.cmake) + include_directories(${ORTHANC_FRAMEWORK_ROOT}) +endif() + + +include(${CMAKE_SOURCE_DIR}/Resources/Orthanc/Plugins/OrthancPluginsExports.cmake) + + +if (STATIC_BUILD OR NOT USE_SYSTEM_ORTHANC_SDK) + if (ORTHANC_SDK_VERSION STREQUAL "1.11.2") + include_directories(${CMAKE_SOURCE_DIR}/Resources/Orthanc/Sdk-1.11.2) + else() + message(FATAL_ERROR "Unsupported version of the Orthanc plugin SDK: ${ORTHANC_SDK_VERSION}") + endif() +else () + CHECK_INCLUDE_FILE_CXX(orthanc/OrthancCPlugin.h HAVE_ORTHANC_H) + if (NOT HAVE_ORTHANC_H) + message(FATAL_ERROR "Please install the headers of the Orthanc plugins SDK") + endif() +endif() + + +if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux" OR + ${CMAKE_SYSTEM_NAME} STREQUAL "kFreeBSD" OR + ${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD") + link_libraries(rt) +elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Windows") + SET(CMAKE_CXX_STANDARD_LIBRARIES "${CMAKE_CXX_STANDARD_LIBRARIES} -lws2_32") + + execute_process( + COMMAND + ${PYTHON_EXECUTABLE} ${ORTHANC_FRAMEWORK_ROOT}/../Resources/WindowsResources.py + ${ORTHANC_OE2_VERSION} "Orthanc Explorer 2 plugin" OrthancExplorer2.dll + "Advanced User Interface Plugin for Orthanc" + ERROR_VARIABLE Failure + OUTPUT_FILE ${CMAKE_CURRENT_BINARY_DIR}/Version.rc + ) + + if (Failure) + message(FATAL_ERROR "Error while computing the version information: ${Failure}") + endif() + + list(APPEND AUTOGENERATED_SOURCES ${CMAKE_CURRENT_BINARY_DIR}/Version.rc) +endif() + + +if (APPLE) + SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -framework CoreFoundation") + SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -framework CoreFoundation") +endif() + +if (${WEBAPP_DIST_SOURCE} STREQUAL "WEB") + SET(WEBAPP_DIST_PATH "${CMAKE_BINARY_DIR}/dist") # downloading the WEB version -> don't modify source folder + if (${WEBAPP_DIST_VERSION} STREQUAL "mainline") + set(WEBAPP_DIST_VERSION "master") # the branch is named master, not mainline + endif() + DownloadPackage(no-check "https://public-files.orthanc.team/oe2-dist-files/${WEBAPP_DIST_VERSION}.zip" ${WEBAPP_DIST_PATH}) +endif() + +if (STANDALONE_BUILD) + add_definitions(-DORTHANC_STANDALONE=1) + set(ADDITIONAL_RESOURCES + DEFAULT_CONFIGURATION ${CMAKE_SOURCE_DIR}/Plugin/DefaultConfiguration.json + WEB_APPLICATION_ASSETS ${WEBAPP_DIST_PATH}/assets + WEB_APPLICATION_FAVICON ${WEBAPP_DIST_PATH}/favicon.ico + WEB_APPLICATION_INDEX ${WEBAPP_DIST_PATH}/index.html + WEB_APPLICATION_INDEX_LANDING ${WEBAPP_DIST_PATH}/token-landing.html + WEB_APPLICATION_INDEX_RETRIEVE_AND_VIEW ${WEBAPP_DIST_PATH}/retrieve-and-view.html + DEFAULT_CSS_LIGHT ${CMAKE_SOURCE_DIR}/WebApplication/src/assets/css/defaults-light.css + DEFAULT_CSS_DARK ${CMAKE_SOURCE_DIR}/WebApplication/src/assets/css/defaults-dark.css + ) +else() + add_definitions(-DORTHANC_STANDALONE=0) +endif() + +EmbedResources( + --no-upcase-check + ${ADDITIONAL_RESOURCES} + ORTHANC_EXPLORER ${CMAKE_SOURCE_DIR}/Plugin/OrthancExplorer.js + ) + + +# As the embedded resources are shared by both the "UnitTests" and the +# "OrthancExplorer2" targets, avoid race conditions in the code +# generation by adding a target between them +add_custom_target( + AutogeneratedTarget + DEPENDS + ${AUTOGENERATED_SOURCES} + ) + + +add_definitions( + -DHAS_ORTHANC_EXCEPTION=1 + -DORTHANC_ENABLE_LOGGING_PLUGIN=1 + ) + +set(CORE_SOURCES +# Plugin/Configuration.cpp + + ${CMAKE_SOURCE_DIR}/Resources/Orthanc/Plugins/OrthancPluginCppWrapper.cpp + ${ORTHANC_CORE_SOURCES} + ) + +add_library(OrthancExplorer2 SHARED ${CORE_SOURCES} + ${CMAKE_SOURCE_DIR}/Plugin/Plugin.cpp + ${AUTOGENERATED_SOURCES} + ) + +add_dependencies(OrthancExplorer2 AutogeneratedTarget) + +DefineSourceBasenameForTarget(OrthancExplorer2) + +message("Setting the version of the library to ${ORTHANC_OE2_VERSION}") + +add_definitions(-DORTHANC_OE2_VERSION="${ORTHANC_OE2_VERSION}") + +set_target_properties(OrthancExplorer2 PROPERTIES + VERSION ${ORTHANC_OE2_VERSION} + SOVERSION ${ORTHANC_OE2_VERSION} + ) + +install( + TARGETS OrthancExplorer2 + RUNTIME DESTINATION lib # Destination for Windows + LIBRARY DESTINATION share/orthanc/plugins # Destination for Linux + ) + +# add_executable(UnitTests +# ${AUTOGENERATED_SOURCES} +# ${CORE_SOURCES} +# ${GOOGLE_TEST_SOURCES} +# # UnitTestsSources/UnitTestsMain.cpp +# ) + +# add_dependencies(UnitTests AutogeneratedTarget) + +# target_link_libraries(UnitTests +# ${GOOGLE_TEST_LIBRARIES} +# ) diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..0ad25db --- /dev/null +++ b/LICENSE @@ -0,0 +1,661 @@ + GNU AFFERO GENERAL PUBLIC LICENSE + Version 3, 19 November 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU Affero General Public License is a free, copyleft license for +software and other kinds of works, specifically designed to ensure +cooperation with the community in the case of network server software. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +our General Public Licenses are intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + Developers that use our General Public Licenses protect your rights +with two steps: (1) assert copyright on the software, and (2) offer +you this License which gives you legal permission to copy, distribute +and/or modify the software. + + A secondary benefit of defending all users' freedom is that +improvements made in alternate versions of the program, if they +receive widespread use, become available for other developers to +incorporate. Many developers of free software are heartened and +encouraged by the resulting cooperation. However, in the case of +software used on network servers, this result may fail to come about. +The GNU General Public License permits making a modified version and +letting the public access it on a server without ever releasing its +source code to the public. + + The GNU Affero General Public License is designed specifically to +ensure that, in such cases, the modified source code becomes available +to the community. It requires the operator of a network server to +provide the source code of the modified version running there to the +users of that server. Therefore, public use of a modified version, on +a publicly accessible server, gives the public access to the source +code of the modified version. + + An older license, called the Affero General Public License and +published by Affero, was designed to accomplish similar goals. This is +a different license, not a version of the Affero GPL, but Affero has +released a new version of the Affero GPL which permits relicensing under +this license. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU Affero General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Remote Network Interaction; Use with the GNU General Public License. + + Notwithstanding any other provision of this License, if you modify the +Program, your modified version must prominently offer all users +interacting with it remotely through a computer network (if your version +supports such interaction) an opportunity to receive the Corresponding +Source of your version by providing access to the Corresponding Source +from a network server at no charge, through some standard or customary +means of facilitating copying of software. This Corresponding Source +shall include the Corresponding Source for any work covered by version 3 +of the GNU General Public License that is incorporated pursuant to the +following paragraph. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the work with which it is combined will remain governed by version +3 of the GNU General Public License. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU Affero General Public License from time to time. Such new versions +will be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU Affero General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU Affero General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU Affero General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published + by the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If your software can interact with users remotely through a computer +network, you should also make sure that it provides a way for users to +get its source. For example, if your program is a web application, its +interface could display a "Source" link that leads users to an archive +of the code. There are many ways you could offer source, and different +solutions will be better for different programs; see section 13 for the +specific requirements. + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU AGPL, see +. diff --git a/Plugin/DefaultConfiguration.json b/Plugin/DefaultConfiguration.json new file mode 100644 index 0000000..6139329 --- /dev/null +++ b/Plugin/DefaultConfiguration.json @@ -0,0 +1,297 @@ +{ + "OrthancExplorer2" : { + // enables or disables the plugin completely + "Enable": true, + + // Prefix URL of the OE2 application (and API) + // A value of '/my-ui' means that the app will be available under /my-ui/app/ + // and the api will be available under /my-ui/api/... + // Should start and end with a '/' + "Root" : "/ui/", + + // Whether OE2 shall replace the default Orthanc Explorer interface ('/' URL will redirect to OE2) + "IsDefaultOrthancUI": true, + + // Base theme for the UI (before custom CSS are applied). + // Allowed values: "light", "dark" + "Theme": "light", + + // Path to custom CSS file or logo. + // The custom CSS are applied after these default files and they are loaded after all other CSS. + // You may actually override any CSS value or variable from the application. + // - https://github.com/orthanc-server/orthanc-explorer-2/blob/master/WebApplication/src/assets/css/defaults-dark.css + // - https://github.com/orthanc-server/orthanc-explorer-2/blob/master/WebApplication/src/assets/css/defaults-light.css + // "CustomCssPath": "/home/my/path/to/custom.css", + // "CustomLogoUrl": "https://my.company/logo.png", + // "CustomLogoPath": "/home/my/path/to/logo.png", + // "CustomFavIconPath": "/home/my/path/to/favicon.ico", // note: this can be a .png, .svg or .ico file + + // Custom Window/Tab Title + // "CustomTitle": "Orthanc Explorer 2", + + // This block of configuration is transmitted as is to the frontend application. + // Make sure not to store any secret here + "UiOptions" : { + // note: all the "Enable..." variables can be set to false by the user-profile (if using the authorization plugin) + + "EnableStudyList": true, // Enables the access to the study list (TODO) + "EnableUpload": true, // Enables the upload menu/interface + "EnableDicomModalities": true, // Enables the 'DICOM Modalities' interface in the side menu + "EnableDeleteResources": true, // Enables the delete button for Studies/Series/Instances + "EnableDownloadZip": true, // Enables the download zip button for Studies/Series + "EnableDownloadDicomDir": false, // Enables the download DICOM DIR button for Studies/Series + "EnableDownloadDicomFile": true, // Enables the download DICOM file button for Instances + "EnableAnonymization": true, // Enables the anonymize button + "EnableModification": true, // Enables the modify button + "EnableSendTo": true, // Enables the 'SendTo' button for Studies/Series/Instances + "EnableApiViewMenu": false, // Enables the API button to open API routes for Studies/Series/Instances (developer mode) + "EnableSettings": true, // Enables the settings menu/interface + "EnableLinkToLegacyUi": true, // Enables a link to the legacy Orthanc UI + "EnableChangePassword": true, // Enables the 'change password' button in the side bar. Only applicable if Keycloak is enabled + "EnableViewerQuickButton": true, // Enables a button in the study list to directly open a viewer + "EnableReportQuickButton": false, // Enables a button in the study list to directly open a PDF report if available in the study + + "EnableEditLabels": true, // Enables labels management (create/delete/assign/unassign) + "AvailableLabels": [], // If not empty, this list prevents the creation of new labels and only allows add/remove of the listed labels. + // This configuration may be overriden when you use Keycloak and an auth-service that implements roles/permissions API. + "EnableLabelsCount": true, // Enables display of study count next to the each label (this might slow down the UI) + + "EnableShares": false, // Enables sharing studies. See "Tokens" section below. + "DefaultShareDuration": 0, // [in days]. 0 means no expiration date, + "ShareDurations": [0, 7, 15, 30, 90, 365], // The share durations proposed in the UI + + "EnableAddSeries": true, // Enables the "Add series" button + "AddSeriesDefaultTags": { // Default tag values when adding a new series of each type ("pdf", "image" or "stl") + "pdf" : { + "SeriesDescription": "Report", + "Modality": "DOC", + "SeriesDate": "$TODAY$" // Allowed keywords: $TODAY$, $STUDY_DATE$, $FILE_DATE$ + }, + "image" : { + "SeriesDescription": "Picture", + "Modality": "XC", + "SeriesDate": "$TODAY$" + }, + "stl" : { + "SeriesDescription": "Model", + "Modality": "M3D", + "SeriesDate": "$TODAY$" + } + }, + + "EnabledMammographyPlugin": false, + + // If both OHIF viewer configurations are enabled, only the v3 is taken into account + "EnableOpenInOhifViewer": false, // Enables a "open in OHIF viewer" button. Note: OHIF can not be used together with KeyCloak (https://community.ohif.org/t/ohif-orthanc-token-to-access-a-single-study/727) + "OhifViewerPublicRoot" : "http://to-be-defined/", // must end with a '/'. e.g: "http://ohif.my.site/" means that link to OHIF will look like http://ohif.my.site/Viewer/1.2.3.444.5555.... + "EnableOpenInOhifViewer3": false, // Enables a "open in OHIF viewer" button. If the OHIF plugin is loaded, the default value is 'true' + "OhifViewer3PublicRoot" : "/ohif/", // must end with a '/'. e.g: "http://ohif.my.site/" means that link to OHIF will look like http://ohif.my.site/viewer?StudyInstanceUIDs=1.2.3.444.5555.... + + "EnableOpenInMedDreamViewer": false, // Enables a "open in MedDream viewer" button + "MedDreamViewerPublicRoot" : "http://to-be-defined/", // must end with a '/'. e.g: "http://meddream.my.site/Viewer/" means that link to MedDream will look like http://meddream.my.site/?study=1.2.3.444.5555.... + + // Defines which icons is used by which enabled viewer. + // Allowed keys: "meddream", "osimis-web-viewer", "stone-webviewer", "ohif", "ohif-vr", "ohif-tmtv" + // Allowed values: CSS class that defines the viewer icons (only from bootstrap icons) + "ViewersIcons" : { + "osimis-web-viewer": "bi bi-eye", + "stone-webviewer": "bi bi-eye-fill", + "ohif": "bi bi-grid", + "ohif-vr": "bi bi-grid-1x2", + "ohif-tmtv": "bi bi-grid-3x3-gap", + "ohif-seg": "fa-solid fa-shapes fa-button", + "ohif-micro": "fa-solid fa-microscope fa-button", + "meddream": "bi bi-columns-gap", + "volview": "bi bi-box", + "wsi": "fa-solid fa-microscope fa-button" + }, + // Defines the order in which the viewer icons should appear in the interface + // OHIF viewers modes that are not listed here, won't appear in the interface. + "ViewersOrdering" : [ + // "osimis-web-viewer", // now deprecated + "stone-webviewer", + "ohif", + "ohif-vr", + "ohif-tmtv", + "ohif-seg", + // "ohif-micro", // currently disabled, this is still experimental in OHIF + "meddream", + "volview", + "wsi" + ], + + "MaxStudiesDisplayed": 100, // The maximum number of studies displayed in the study list. + // From v 1.7.0, this option is not used anymore in the local study list when using + // a DB backend that supports ExtendedFind (SQLite and PostgreSQL) + // but is still used in the DicomWeb queries. + "PageLoadSize": 50, // The number of items that are loaded when scrolling the study or instance list. + // Only applicable with a DB backend that supports ExtendedFind. + + "MaxMyJobsHistorySize": 5, // The maximum number of jobs appearing under 'my jobs' in side bar (0 = unlimited) + + "StudyListSearchMode": "search-as-you-type",// mode to trigger a search in the StudyList. Accepted values: 'search-as-you-type' or 'search-button' + "StudyListSearchAsYouTypeMinChars": 3, // minimum number of characters to enter in a text search field before it starts searching the DB + "StudyListSearchAsYouTypeDelay": 400, // Delay [ms] between the last key stroke and the trigger of the search + "StudyListContentIfNoSearch": "most-recents", // Defines what to show if no search criteria has been entered + // Allowed values: "empty", "most-recents" + // From v 1.7.0, this option is always considered as "most-recents" when using + // a DB backend that supports ExtendedFind (SQLite and PostgreSQL) + + // Default settings are ok for "small" Orthanc Databases. For large databases, it is recommended to use these settings: + // "StudyListSearchMode": "search-button" + // "StudyListContentIfNoSearch": "empty" + + "ShowOrthancName": true, // display the Orthanc Name in the side menu + + // The list of tags to be displayed in the upload dialog result list + // (the first N defined tags in the list are displayed on the UI) + // Allowed values are: "StudyDate", "AccessionNumber", "PatientID", + // "PatientName", "PatientBirthDate", "StudyDescription" + "UploadReportTags" : [ + "PatientName", + "StudyDescription", + "PatientID", + "AccessionNumber", + "StudyDate" + ], + "UploadReportMaxTags" : 2, // See above, the max number of tags displayed in the upload report + + // The ordered list of columns to display in the study list. + // Allowed values are: + // - Dicom Tags: "StudyDate", "AccessionNumber", "PatientID" + // "PatientName", "PatientBirthDate", "StudyDescription" + // - special columns: + // - "modalities": the list of modalities in the study + // - "seriesCount": the number of series in the study + // - "instancesCount": the number of instances in the study + // - "seriesAndInstancesCount": a combined value with the number of series/instances in the study + "StudyListColumns" : [ + "PatientBirthDate", + "PatientName", + "PatientID", + "StudyDescription", + "StudyDate", + "modalities", + "AccessionNumber", + "seriesAndInstancesCount" + ], + + // The list of patient level tags that are displayed in the study details and in the modification dialog. + // Note that these tags must be defined in the Orthanc main dicom tags (https://orthanc.uclouvain.be/book/faq/main-dicom-tags.html) + "PatientMainTags" : [ + "PatientID", + "PatientName", + "PatientBirthDate", + "PatientSex", + "OtherPatientIDs" + ], + + // The list of study level tags that are displayed in the study details and in the modification dialog. + // Note that these tags must be defined in the Orthanc main dicom tags (https://orthanc.uclouvain.be/book/faq/main-dicom-tags.html) + "StudyMainTags" : [ + "StudyDate", + "StudyTime", + "StudyDescription", + "AccessionNumber", + "StudyID", + "StudyInstanceUID", + "RequestingPhysician", + "ReferringPhysicianName", + "InstitutionName" + ], + + // The list of series level tags that are displayed in the study details and in the modification dialog. + // Note that these tags must be defined in the Orthanc main dicom tags (https://orthanc.uclouvain.be/book/faq/main-dicom-tags.html) + "SeriesMainTags" : [ + "SeriesDate", + "SeriesTime", + "SeriesDescription", + "SeriesNumber", + "BodyPartExamined", + "ProtocolName", + "SeriesInstanceUID" + ], + + // The modalities to display in the Modalities filter dropdown in the Study List + "ModalitiesFilter": [ + "CR", "CT", "DOC", "DR", "DX", "KO", "MG", "MR", "NM", "OT", "PR", "PT", "PX", "RTDOSE", "RTSTRUCT", "RTPLAN", "SEG", "SR", "US", "XA", "XC" + ], + + // Defines the list of languages available in the language picker + // ex: "AvailableLanguages" : ["en", "fr"], + // ex: "AvailableLanguages" : [] -> this won't show the language picker at all and force usage of the DefaultLanguage + "AvailableLanguages": ["en", "de", "es", "fr", "it", "ka", "ru", "si", "uk", "zh"], + + // Force the default language. If null (default), the language is the language from the visitor's browser. + // ex: "DefaultLanguage" : "en" + "DefaultLanguage" : null, + + // Should DicomTags be translated (true) or shall we use the English symbolic name whatever the selected language (false) + // if true: "PatientID" is displayed as e.g "ID Patient" in french + // if false: "PatientID" is displayed as "PatientID" in all languages + "TranslateDicomTags" : true, + + // Display format for dates in the study list based on these definitions: https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table + // example: "dd/MM/yyyy" for European Format, + // "yyyyMMdd" for DICOM format + "DateFormat": "yyyyMMdd", + + // PatientName transformation for display. This requires a Regex for capturing and one expression for formatting. + // If PatientNameFormatting is not defined, no transformation occurs (this is the default behaviour). + // The Regex is a Javascript regex and is applied this way: + // FormattedName = PatientName.replace(new RegExp(PatientNameCapture), PatientNameFormatting); + // in example, to capture carets separated names and re-order them, one would use: + // FormattedName = PatientName.replace(new RegExp("([^\\^]+)\\^?([^\\^]+)?\\^?([^\\^]+)?\\^?([^\\^]+)?\\^?([^\\^]+)?"), '$1 $3 $2'); + "PatientNameCapture" : "([^\\^]+)\\^?([^\\^]+)?\\^?([^\\^]+)?\\^?([^\\^]+)?\\^?([^\\^]+)?", + // "PatientNameFormatting": "$1 $3 $2" + + // modifications dialog options + "Modifications": { + // Modes define options to the /modify route: + // "modify-keep-uids" is equivalent to KeepSource=True and Keep=["StudyInstanceUID", "SeriesInstanceUID", "SOPInstanceUID"] + // "modify-new-uids" is equivalent to KeepSource=False + // "duplicate" is equivalent to KeepSource=True + // "AllowedModes" and "DefaultMode" apply to studies modification + "AllowedModes": ["modify-new-uids", "modify-keep-uids", "duplicate"], + "DefaultMode": "modify-new-uids", + + // same configurations for Series (introduced in 1.2.0) + "SeriesAllowedModes": ["modify-new-uids", "modify-keep-uids", "duplicate"], + "SeriesDefaultMode": "modify-new-uids" + + }, + + // List of tags that are used to identify studies belonging to the same patient. + // This appears as "This patient has {count} studies in total" in the study details. + // ex: "ShowSamePatientStudiesFilter" : ["PatientID", "PatientBirthDate", "PatientSex"] + "ShowSamePatientStudiesFilter" : [ + "PatientID" + ] + }, + + "Shares" : { + "TokenService" : { + "Url": "http://change-me:8000/shares", + "Username": "change-me", + "Password": "change-me" + }, + "Type": "osimis-viewer-publication" // allowed values: "osimis-viewer-publication", "meddream-viewer-publication", "stone-viewer-publication" + }, + + // When using Keycloak for user management + "Keycloak" : { + "Enable": false, + "Url": "http://change-me:8080/", + "Realm": "change-me", + "ClientId": "change-me" + }, + + + // this section is only relevant if the authorization plugin is enabled and user-profile based permissions are implemented + "Tokens" : { + "InstantLinksValidity": 200, // the duration, in seconds an 'instant' token is valid (e.g. used to download a study, open a study in a viewer) + "ShareType": "stone-viewer-publication" // allowed values: "stone-viewer-publication", "osimis-viewer-publication", "meddream-viewer-publication" + //"RequiredForLinks": false // experimental, set it to false when using basic-auth together with the auth-plugin (https://discourse.orthanc-server.org/t/user-based-access-control-with-label-based-resource-access/5454) + } + } +} \ No newline at end of file diff --git a/Plugin/OrthancExplorer.js b/Plugin/OrthancExplorer.js new file mode 100644 index 0000000..17971a1 --- /dev/null +++ b/Plugin/OrthancExplorer.js @@ -0,0 +1,23 @@ +$('#lookup').live('pagebeforeshow', function() { + $('#open-oe2').remove(); + + var b = $('
') + .attr('id', 'open-oe2') + .addClass('ui-grid-b') + .append($('
') + .addClass('ui-block-a')) + .append($('
') + .addClass('ui-block-b') + .append($('') + .attr('data-role', 'button') + .attr('href', '#') + .attr('data-icon', 'forward') + .attr('data-theme', 'a') + .text('Open Orthanc Explorer 2') + .button() + .click(function(e) { + window.open('../${OE2_BASE_URL}/app/index.html'); + }))); + + b.insertAfter($('#lookup-result')); +}); diff --git a/Plugin/Plugin.cpp b/Plugin/Plugin.cpp new file mode 100644 index 0000000..a631e9a --- /dev/null +++ b/Plugin/Plugin.cpp @@ -0,0 +1,933 @@ +/** + * Orthanc - A Lightweight, RESTful DICOM Store + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2024 Osimis S.A., Belgium + * Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium + * Copyright (C) 2024-2024 Orthanc Team SRL, Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + **/ + +#include "../Resources/Orthanc/Plugins/OrthancPluginCppWrapper.h" + +#include +#include +#include +#include + +#include + +#define ORTHANC_PLUGIN_NAME "orthanc-explorer-2" + +// we are using Orthanc 1.11.0 API (RequestedTags in tools/find) +#define ORTHANC_CORE_MINIMAL_MAJOR 1 +#define ORTHANC_CORE_MINIMAL_MINOR 11 +#define ORTHANC_CORE_MINIMAL_REVISION 0 + + +std::unique_ptr orthancFullConfiguration_; +Json::Value pluginJsonConfiguration_; +std::string oe2BaseUrl_; + +Json::Value pluginsConfiguration_; +bool hasUserProfile_ = false; +bool openInOhifV3IsExplicitelyDisabled = false; +bool enableShares_ = false; +bool isReadOnly_ = false; +std::string customCssPath_; +std::string theme_ = "light"; +std::string customLogoPath_; +std::string customLogoUrl_; +std::string customFavIconPath_; +std::string customTitle_; + +enum CustomFilesPath +{ + CustomFilesPath_Logo, + CustomFilesPath_FavIcon +}; + + +template +void ServeEmbeddedFolder(OrthancPluginRestOutput* output, + const char* url, + const OrthancPluginHttpRequest* request) +{ + OrthancPluginContext* context = OrthancPlugins::GetGlobalContext(); + + if (request->method != OrthancPluginHttpMethod_Get) + { + OrthancPluginSendMethodNotAllowed(context, output, "GET"); + } + else + { + std::string path = "/" + std::string(request->groups[0]); + Orthanc::MimeType mimeType = Orthanc::SystemToolbox::AutodetectMimeType(path); + const char* mime = Orthanc::EnumerationToString(mimeType); + + std::string fileContent; + Orthanc::EmbeddedResources::GetDirectoryResource(fileContent, folder, path.c_str()); + + const char* resource = fileContent.size() ? fileContent.c_str() : NULL; + OrthancPluginAnswerBuffer(context, output, resource, fileContent.size(), mime); + } +} + +template +void ServeEmbeddedFile(OrthancPluginRestOutput* output, + const char* url, + const OrthancPluginHttpRequest* request) +{ + OrthancPluginContext* context = OrthancPlugins::GetGlobalContext(); + + if (request->method != OrthancPluginHttpMethod_Get) + { + OrthancPluginSendMethodNotAllowed(context, output, "GET"); + } + else + { + std::string s; + Orthanc::EmbeddedResources::GetFileResource(s, file); + + if (file == Orthanc::EmbeddedResources::WEB_APPLICATION_INDEX && theme_ != "light") + { + boost::replace_all(s, "data-bs-theme=\"light\"", "data-bs-theme=\"" + theme_ + "\""); + } + + const char* resource = s.size() ? s.c_str() : NULL; + OrthancPluginAnswerBuffer(context, output, resource, s.size(), Orthanc::EnumerationToString(mime)); + } +} + +template +void ServeCustomFile(OrthancPluginRestOutput* output, + const char* url, + const OrthancPluginHttpRequest* request) +{ + OrthancPluginContext* context = OrthancPlugins::GetGlobalContext(); + + if (request->method != OrthancPluginHttpMethod_Get) + { + OrthancPluginSendMethodNotAllowed(context, output, "GET"); + } + else + { + std::string fileContent; + std::string customFileContent; + std::string customFilePath; + if (customFile == CustomFilesPath_FavIcon) + { + customFilePath = customFavIconPath_; + } + else if (customFile == CustomFilesPath_Logo) + { + customFilePath = customLogoPath_; + } + else + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); + } + + Orthanc::SystemToolbox::ReadFile(fileContent, customFilePath); + Orthanc::MimeType mimeType = Orthanc::SystemToolbox::AutodetectMimeType(customFilePath); + + // include an ETag for correct cache handling + OrthancPlugins::OrthancString md5; + size_t size = fileContent.size(); + md5.Assign(OrthancPluginComputeMd5(OrthancPlugins::GetGlobalContext(), fileContent.c_str(), size)); + + std::string etag = "\"" + std::string(md5.GetContent()) + "\""; + OrthancPluginSetHttpHeader(OrthancPlugins::GetGlobalContext(), output, "ETag", etag.c_str()); + OrthancPluginSetHttpHeader(OrthancPlugins::GetGlobalContext(), output, "Cache-Control", "no-cache"); + + OrthancPluginAnswerBuffer(context, output, fileContent.c_str(), size, Orthanc::EnumerationToString(mimeType)); + } +} + +// serves either the default CSS or a custom file CSS +void ServeCustomCss(OrthancPluginRestOutput* output, + const char* url, + const OrthancPluginHttpRequest* request) +{ + OrthancPluginContext* context = OrthancPlugins::GetGlobalContext(); + + if (request->method != OrthancPluginHttpMethod_Get) + { + OrthancPluginSendMethodNotAllowed(context, output, "GET"); + } + else + { + std::string cssFileContent; + + if (strstr(url, "custom.css") != NULL) + { + if (theme_ == "dark") + { + Orthanc::EmbeddedResources::GetFileResource(cssFileContent, Orthanc::EmbeddedResources::DEFAULT_CSS_DARK); + } + else + { + Orthanc::EmbeddedResources::GetFileResource(cssFileContent, Orthanc::EmbeddedResources::DEFAULT_CSS_LIGHT); + } + + if (!customCssPath_.empty()) + { // append the custom CSS + std::string customCssFileContent; + Orthanc::SystemToolbox::ReadFile(customCssFileContent, customCssPath_); + cssFileContent += "\n/* Appending the custom CSS */\n" + customCssFileContent; + } + } + + const char* resource = cssFileContent.size() ? cssFileContent.c_str() : NULL; + size_t size = cssFileContent.size(); + + // include an ETag for correct cache handling + OrthancPlugins::OrthancString md5; + md5.Assign(OrthancPluginComputeMd5(OrthancPlugins::GetGlobalContext(), resource, size)); + + std::string etag = "\"" + std::string(md5.GetContent()) + "\""; + OrthancPluginSetHttpHeader(OrthancPlugins::GetGlobalContext(), output, "ETag", etag.c_str()); + OrthancPluginSetHttpHeader(OrthancPlugins::GetGlobalContext(), output, "Cache-Control", "no-cache"); + + OrthancPluginAnswerBuffer(context, output, resource, size, Orthanc::EnumerationToString(Orthanc::MimeType_Css)); + } +} + + +void RedirectRoot(OrthancPluginRestOutput* output, + const char* url, + const OrthancPluginHttpRequest* request) +{ + OrthancPluginContext* context = OrthancPlugins::GetGlobalContext(); + + if (request->method != OrthancPluginHttpMethod_Get) + { + OrthancPluginSendMethodNotAllowed(context, output, "GET"); + } + else + { + for (uint32_t i = 0; i < request->headersCount; ++i) + { + OrthancPlugins::LogError(std::string(request->headersKeys[i]) + " : " + request->headersValues[i]); + } + + std::string oe2BaseApp = oe2BaseUrl_ + "app/"; + OrthancPluginRedirect(context, output, &(oe2BaseApp.c_str()[1])); // remove the first '/' to make a relative redirect ! + } +} + +void MergeJson(Json::Value &a, const Json::Value &b) { + + if (!a.isObject() || !b.isObject()) + { + return; + } + + Json::Value::Members members = b.getMemberNames(); + + for (size_t i = 0; i < members.size(); i++) + { + std::string key = members[i]; + + if (!a[key].isNull() && a[key].type() == Json::objectValue && b[key].type() == Json::objectValue) + { + MergeJson(a[key], b[key]); + } + else + { + // const std::string& val = b[key].asString(); + a[key] = b[key]; + } + } +} + + +void ReadConfiguration() +{ + orthancFullConfiguration_.reset(new OrthancPlugins::OrthancConfiguration); + + // read default configuration + std::string defaultConfigurationFileContent; + Orthanc::EmbeddedResources::GetFileResource(defaultConfigurationFileContent, Orthanc::EmbeddedResources::DEFAULT_CONFIGURATION); + + Json::Value defaultConfiguration; + OrthancPlugins::ReadJsonWithoutComments(defaultConfiguration, defaultConfigurationFileContent); + pluginJsonConfiguration_ = defaultConfiguration["OrthancExplorer2"]; + + if (orthancFullConfiguration_->IsSection("OrthancExplorer2")) + { + OrthancPlugins::OrthancConfiguration pluginConfiguration(false); + orthancFullConfiguration_->GetSection(pluginConfiguration, "OrthancExplorer2"); + + Json::Value jsonConfig = pluginConfiguration.GetJson(); + + // backward compatibility + if (jsonConfig.isMember("UiOptions")) + { + // fix typo from version 0.7.0 + if (jsonConfig["UiOptions"].isMember("EnableAnonimization") && !jsonConfig["UiOptions"].isMember("EnableAnonymization")) + { + LOG(WARNING) << "You are still using the 'UiOptions.EnableAnonimization' configuration that has a typo. You should use 'UiOptions.EnableAnonymization' instead."; + jsonConfig["UiOptions"]["EnableAnonymization"] = jsonConfig["UiOptions"]["EnableAnonimization"]; + } + + if (jsonConfig["UiOptions"].isMember("StudyListEmptyIfNoSearch") && !jsonConfig["UiOptions"].isMember("StudyListContentIfNoSearch")) + { + if (jsonConfig["UiOptions"]["StudyListEmptyIfNoSearch"].asBool() == true) + { + LOG(WARNING) << "You are still using the 'UiOptions.StudyListEmptyIfNoSearch' configuration that is now deprecated a typo. You should use 'UiOptions.StudyListContentIfNoSearch' instead."; + jsonConfig["UiOptions"]["StudyListContentIfNoSearch"] = "empty"; + } + } + + openInOhifV3IsExplicitelyDisabled = jsonConfig["UiOptions"].isMember("EnableOpenInOhifViewer3") && jsonConfig["UiOptions"]["EnableOpenInOhifViewer3"].asBool() == false; + } + + MergeJson(pluginJsonConfiguration_, jsonConfig); + + if (jsonConfig.isMember("CustomCssPath") && jsonConfig["CustomCssPath"].isString()) + { + customCssPath_ = jsonConfig["CustomCssPath"].asString(); + if (!Orthanc::SystemToolbox::IsExistingFile(customCssPath_)) + { + LOG(ERROR) << "Unable to accesss the 'CustomCssPath': " << customCssPath_; + throw Orthanc::OrthancException(Orthanc::ErrorCode_InexistentFile); + } + } + + if (jsonConfig.isMember("CustomLogoPath") && jsonConfig["CustomLogoPath"].isString()) + { + customLogoPath_ = jsonConfig["CustomLogoPath"].asString(); + if (!Orthanc::SystemToolbox::IsExistingFile(customLogoPath_)) + { + LOG(ERROR) << "Unable to accesss the 'CustomLogoPath': " << customLogoPath_; + throw Orthanc::OrthancException(Orthanc::ErrorCode_InexistentFile); + } + } + + if (jsonConfig.isMember("CustomLogoUrl") && jsonConfig["CustomLogoUrl"].isString()) + { + customLogoUrl_ = jsonConfig["CustomLogoUrl"].asString(); + } + + if (jsonConfig.isMember("Theme") && jsonConfig["Theme"].isString() && jsonConfig["Theme"].asString() == "dark") + { + theme_ = "dark"; + } + + if (jsonConfig.isMember("CustomFavIconPath") && jsonConfig["CustomFavIconPath"].isString()) + { + customFavIconPath_ = jsonConfig["CustomFavIconPath"].asString(); + if (!Orthanc::SystemToolbox::IsExistingFile(customFavIconPath_)) + { + LOG(ERROR) << "Unable to accesss the 'CustomFavIconPath': " << customFavIconPath_; + throw Orthanc::OrthancException(Orthanc::ErrorCode_InexistentFile); + } + } + + if (jsonConfig.isMember("CustomTitle") && jsonConfig["CustomTitle"].isString()) + { + customTitle_ = jsonConfig["CustomTitle"].asString(); + } + } + + enableShares_ = pluginJsonConfiguration_["UiOptions"]["EnableShares"].asBool(); // we are sure that the value exists since it is in the default configuration file + + isReadOnly_ = orthancFullConfiguration_->GetBooleanValue("ReadOnly", false); +} + +bool GetPluginConfiguration(Json::Value& jsonPluginConfiguration, const std::string& sectionName) +{ + if (orthancFullConfiguration_->IsSection(sectionName)) + { + OrthancPlugins::OrthancConfiguration pluginConfiguration(false); + orthancFullConfiguration_->GetSection(pluginConfiguration, sectionName); + + jsonPluginConfiguration = pluginConfiguration.GetJson(); + return true; + } + + return false; +} + + +bool IsPluginEnabledInConfiguration(const std::string& sectionName, const std::string& enableValueName, bool defaultValue) +{ + if (orthancFullConfiguration_->IsSection(sectionName)) + { + OrthancPlugins::OrthancConfiguration pluginConfiguration(false); + orthancFullConfiguration_->GetSection(pluginConfiguration, sectionName); + + return pluginConfiguration.GetBooleanValue(enableValueName, defaultValue); + } + + return defaultValue; +} + +Json::Value GetPluginInfo(const std::string& pluginName) +{ + Json::Value pluginInfo; + + OrthancPlugins::RestApiGet(pluginInfo, "/plugins/" + pluginName, false); + + return pluginInfo; +} + +Json::Value GetKeycloakConfiguration() +{ + if (pluginJsonConfiguration_.isMember("Keycloak")) + { + const Json::Value& keyCloakSection = pluginJsonConfiguration_["Keycloak"]; + if (keyCloakSection.isMember("Enable") && keyCloakSection["Enable"].asBool() == true) + { + return pluginJsonConfiguration_["Keycloak"]; + } + } + + return Json::nullValue; +} + +Json::Value GetPluginsConfiguration(bool& hasUserProfile) +{ + Json::Value pluginsConfiguration; + Json::Value pluginList; + + Orthanc::UriComponents components; + Orthanc::Toolbox::SplitUriComponents(components, oe2BaseUrl_); + std::string pluginUriPrefix = ""; // the RootUri is provided relative to Orthanc Explorer /app/explorer.html -> we need to correct this ! + for (size_t i = 0; i < components.size(); i++) + { + pluginUriPrefix += "../"; + } + + OrthancPlugins::RestApiGet(pluginList, "/plugins", false); + + for (Json::Value::ArrayIndex i = 0; i < pluginList.size(); i++) + { + Json::Value pluginConfiguration; + std::string pluginName = pluginList[i].asString(); + + if (pluginName == "explorer.js") + { + continue; + } + + Json::Value pluginInfo = GetPluginInfo(pluginName); + + if (pluginInfo.isMember("RootUri") && pluginInfo["RootUri"].asString().size() > 0) + { + pluginInfo["RootUri"] = pluginUriPrefix + pluginInfo["RootUri"].asString(); + } + + pluginsConfiguration[pluginName] = pluginInfo; + pluginsConfiguration[pluginName]["Enabled"] = true; // we assume that unknown plugins are enabled (if they are loaded by Orthanc) + + if (pluginName == "authorization") + { + pluginConfiguration = Json::nullValue; + pluginsConfiguration[pluginName]["Enabled"] = GetPluginConfiguration(pluginConfiguration, "Authorization") + && (pluginConfiguration.isMember("WebService") + || pluginConfiguration.isMember("WebServiceRootUrl") + || pluginConfiguration.isMember("WebServiceUserProfileUrl") + || pluginConfiguration.isMember("WebServiceTokenValidationUrl") + || pluginConfiguration.isMember("WebServiceTokenCreationBaseUrl") + || pluginConfiguration.isMember("WebServiceTokenDecoderUrl")); + hasUserProfile = GetPluginConfiguration(pluginConfiguration, "Authorization") && (pluginConfiguration.isMember("WebServiceUserProfileUrl") || pluginConfiguration.isMember("WebServiceRootUrl")); + + if (!pluginConfiguration.isMember("CheckedLevel") || pluginConfiguration["CheckedLevel"].asString() != "studies") + { + LOG(WARNING) << "When using OE2 and the authorization plugin together, you must set 'Authorization.CheckedLevel' to 'studies'. Unless you are using this orthanc only to generate tokens."; + } + } + else if (pluginName == "AWS S3 Storage") + { + pluginsConfiguration[pluginName]["Enabled"] = GetPluginConfiguration(pluginConfiguration, "AwsS3Storage"); + } + else if (pluginName == "Azure Blob Storage") + { + pluginsConfiguration[pluginName]["Enabled"] = GetPluginConfiguration(pluginConfiguration, "AzureBlobStorage"); + } + else if (pluginName == "connectivity-checks") + { + pluginsConfiguration[pluginName]["Enabled"] = true; + } + else if (pluginName == "ohif") + { + pluginsConfiguration[pluginName]["Enabled"] = true; + std::string ohifDataSource = "dicom-web"; + if (GetPluginConfiguration(pluginConfiguration, "OHIF")) + { + if (pluginConfiguration.isMember("DataSource") && pluginConfiguration["DataSource"].asString() == "dicom-json") + { + ohifDataSource = "dicom-json"; + } + } + pluginsConfiguration[pluginName]["DataSource"] = ohifDataSource; + } + else if (pluginName == "delayed-deletion") + { + pluginsConfiguration[pluginName]["Enabled"] = IsPluginEnabledInConfiguration("DelayedDeletion", "Enable", false); + } + else if (pluginName == "dicom-web") + { + pluginsConfiguration[pluginName]["Enabled"] = IsPluginEnabledInConfiguration("DicomWeb", "Enable", false); + } + else if (pluginName == "gdcm") + { + pluginsConfiguration[pluginName]["Enabled"] = IsPluginEnabledInConfiguration("Gdcm", "Enable", true); + } + else if (pluginName == "Google Cloud Storage") + { + pluginsConfiguration[pluginName]["Enabled"] = GetPluginConfiguration(pluginConfiguration, "GoogleCloudStorage"); + } + else if (pluginName == "mysql-index") + { + pluginsConfiguration[pluginName]["Enabled"] = IsPluginEnabledInConfiguration("MySQL", "EnableIndex", false); + } + else if (pluginName == "mysql-storage") + { + pluginsConfiguration[pluginName]["Enabled"] = IsPluginEnabledInConfiguration("MySQL", "EnableStorage", false); + } + else if (pluginName == "odbc-index") + { + pluginsConfiguration[pluginName]["Enabled"] = IsPluginEnabledInConfiguration("Odbc", "EnableIndex", false); + } + else if (pluginName == "odbc-storage") + { + pluginsConfiguration[pluginName]["Enabled"] = IsPluginEnabledInConfiguration("Odbc", "EnableStorage", false); + } + else if (pluginName == "postgresql-index") + { + pluginsConfiguration[pluginName]["Enabled"] = IsPluginEnabledInConfiguration("PostgreSQL", "EnableIndex", false); + } + else if (pluginName == "postgresql-storage") + { + pluginsConfiguration[pluginName]["Enabled"] = IsPluginEnabledInConfiguration("PostgreSQL", "EnableStorage", false); + } + else if (pluginName == "osimis-web-viewer") + { + pluginsConfiguration[pluginName]["Enabled"] = GetPluginConfiguration(pluginConfiguration, "WebViewer"); + } + else if (pluginName == "python") + { + std::string notUsed; + pluginsConfiguration[pluginName]["Enabled"] = orthancFullConfiguration_->LookupStringValue(notUsed, "PythonScript"); + } + else if (pluginName == "serve-folders") + { + pluginsConfiguration[pluginName]["Enabled"] = GetPluginConfiguration(pluginConfiguration, "ServeFolders"); + } + else if (pluginName == "stone-webviewer") + { + pluginsConfiguration[pluginName]["Enabled"] = true; + } + else if (pluginName == "volview") + { + pluginsConfiguration[pluginName]["Enabled"] = true; + } + else if (pluginName == "tcia") + { + pluginsConfiguration[pluginName]["Enabled"] = IsPluginEnabledInConfiguration("Tcia", "Enable", false); + } + else if (pluginName == "transfers") + { + pluginsConfiguration[pluginName]["Enabled"] = true; + } + else if (pluginName == "web-viewer") + { + pluginsConfiguration[pluginName]["Enabled"] = true; + } + else if (pluginName == "worklists") + { + pluginsConfiguration[pluginName]["Enabled"] = IsPluginEnabledInConfiguration("Worklists", "Enable", false); + } + else if (pluginName == "wsi") + { + pluginsConfiguration[pluginName]["Enabled"] = true; + } + else if (pluginName == "multitenant-dicom") + { + pluginsConfiguration[pluginName]["Enabled"] = false; + Json::Value pluginConfiguration; + if (GetPluginConfiguration(pluginConfiguration, "MultitenantDicom")) + { + pluginsConfiguration[pluginName]["Enabled"] = pluginConfiguration.isMember("Servers") && pluginConfiguration["Servers"].isArray() && pluginConfiguration["Servers"].size() > 0; + } + } + + } + + return pluginsConfiguration; +} + +void UpdateUiOptions(Json::Value& uiOption, const std::list& permissions, const std::string& anyOfPermissions) +{ + std::vector permissionsVector; + Orthanc::Toolbox::TokenizeString(permissionsVector, anyOfPermissions, '|'); + + bool hasPermission = false; + + for (size_t i = 0; i < permissionsVector.size(); ++i) + { + hasPermission |= std::find(permissions.begin(), permissions.end(), permissionsVector[i]) != permissions.end(); + } + + uiOption = uiOption.asBool() && hasPermission; +} + +void GetOE2Configuration(OrthancPluginRestOutput* output, + const char* /*url*/, + const OrthancPluginHttpRequest* request) +{ + OrthancPluginContext* context = OrthancPlugins::GetGlobalContext(); + + if (request->method != OrthancPluginHttpMethod_Get) + { + OrthancPluginSendMethodNotAllowed(context, output, "GET"); + } + else + { + Json::Value oe2Configuration; + + oe2Configuration["Plugins"] = pluginsConfiguration_; + oe2Configuration["UiOptions"] = pluginJsonConfiguration_["UiOptions"]; + + // if OHIF has not been explicitely disabled in the config and if the plugin is loaded, enable it + if (!openInOhifV3IsExplicitelyDisabled && pluginsConfiguration_.isMember("ohif")) + { + oe2Configuration["UiOptions"]["EnableOpenInOhifViewer3"] = true; + } + + Json::Value tokens = pluginJsonConfiguration_["Tokens"]; + if (!tokens.isMember("RequiredForLinks")) + { + tokens["RequiredForLinks"] = hasUserProfile_; + } + + oe2Configuration["Tokens"] = tokens; + + oe2Configuration["HasCustomLogo"] = !customLogoPath_.empty() || !customLogoUrl_.empty(); + if (!customLogoUrl_.empty()) + { + oe2Configuration["CustomLogoUrl"] = customLogoUrl_; + } + + if (!customTitle_.empty()) + { + oe2Configuration["CustomTitle"] = customTitle_; + } + + Json::Value& uiOptions = oe2Configuration["UiOptions"]; + + if (hasUserProfile_) + { + {// get the available-labels from the auth plugin (and the auth-service) + std::map headers; + OrthancPlugins::GetHttpHeaders(headers, request); + + uiOptions["EnablePermissionsEdition"] = false; + + Json::Value rolesConfig; + if (OrthancPlugins::RestApiGet(rolesConfig, "/auth/settings/roles", headers, true)) + { + if (rolesConfig.isObject() && rolesConfig.isMember("available-labels")) + { + LOG(INFO) << "Overriding \"AvailableLabels\" in UiOptions with the values from the auth-service"; + uiOptions["AvailableLabels"] = rolesConfig["available-labels"]; + } + + LOG(INFO) << rolesConfig.toStyledString(); + + // if the auth-service is not fully configured, disable permissions edition + if (rolesConfig.isObject() && rolesConfig.isMember("roles") && rolesConfig["roles"].isObject() && rolesConfig["roles"].size() > 0) + { + uiOptions["EnablePermissionsEdition"] = true; + } + } + } + + {// get the user profile from the auth plugin (and the auth-service) + std::map headers; + OrthancPlugins::GetHttpHeaders(headers, request); + + Json::Value userProfile; + OrthancPlugins::RestApiGet(userProfile, "/auth/user/profile", headers, true); + + // modify the UiOptions based on the user profile + std::list permissions; + Orthanc::SerializationToolbox::ReadListOfStrings(permissions, userProfile, "permissions"); + + LOG(INFO) << "Overriding \"Enable...\" in UiOptions with the permissions from the auth-service for this user-profile"; + + UpdateUiOptions(uiOptions["EnableStudyList"], permissions, "all|view"); + UpdateUiOptions(uiOptions["EnableViewerQuickButton"], permissions, "all|view"); + UpdateUiOptions(uiOptions["EnableReportQuickButton"], permissions, "all|view"); + UpdateUiOptions(uiOptions["EnableUpload"], permissions, "all|upload"); + UpdateUiOptions(uiOptions["EnableAddSeries"], permissions, "all|upload"); + UpdateUiOptions(uiOptions["EnableDicomModalities"], permissions, "all|q-r-remote-modalities"); + UpdateUiOptions(uiOptions["EnableDeleteResources"], permissions, "all|delete"); + UpdateUiOptions(uiOptions["EnableDownloadZip"], permissions, "all|download"); + UpdateUiOptions(uiOptions["EnableDownloadDicomDir"], permissions, "all|download"); + UpdateUiOptions(uiOptions["EnableDownloadDicomFile"], permissions, "all|download"); + UpdateUiOptions(uiOptions["EnableModification"], permissions, "all|modify"); + UpdateUiOptions(uiOptions["EnableAnonymization"], permissions, "all|anonymize"); + UpdateUiOptions(uiOptions["EnableSendTo"], permissions, "all|send"); + UpdateUiOptions(uiOptions["EnableApiViewMenu"], permissions, "all|api-view"); + UpdateUiOptions(uiOptions["EnableSettings"], permissions, "all|settings"); + UpdateUiOptions(uiOptions["EnableShares"], permissions, "all|share"); + UpdateUiOptions(uiOptions["EnableEditLabels"], permissions, "all|edit-labels"); + UpdateUiOptions(uiOptions["EnablePermissionsEdition"], permissions, "admin-permissions"); + + // the Legacy UI is not available with user profile since it would not refresh the tokens + uiOptions["EnableLinkToLegacyUi"] = false; + + oe2Configuration["Profile"] = userProfile; + } + + } + + // disable operations on read only systems + if (isReadOnly_) + { + uiOptions["EnableUpload"] = false; + uiOptions["EnableAddSeries"] = false; + uiOptions["EnableDeleteResources"] = false; + uiOptions["EnableModification"] = false; + uiOptions["EnableAnonymization"] = false; + uiOptions["EnableEditLabels"] = false; + uiOptions["EnablePermissionsEdition"] = false; + } + + + oe2Configuration["Keycloak"] = GetKeycloakConfiguration(); + std::string answer = oe2Configuration.toStyledString(); + OrthancPluginAnswerBuffer(context, output, answer.c_str(), answer.size(), "application/json"); + } +} + +void GetOE2PreLoginConfiguration(OrthancPluginRestOutput* output, + const char* /*url*/, + const OrthancPluginHttpRequest* request) +{ + OrthancPluginContext* context = OrthancPlugins::GetGlobalContext(); + + if (request->method != OrthancPluginHttpMethod_Get) + { + OrthancPluginSendMethodNotAllowed(context, output, "GET"); + } + else + { + Json::Value oe2Configuration; + oe2Configuration["Keycloak"] = GetKeycloakConfiguration(); + + std::string answer = oe2Configuration.toStyledString(); + OrthancPluginAnswerBuffer(context, output, answer.c_str(), answer.size(), "application/json"); + } +} + + +static bool DisplayPerformanceWarning(OrthancPluginContext* context) +{ + (void) DisplayPerformanceWarning; // Disable warning about unused function + OrthancPluginLogWarning(context, "Performance warning in Orthanc Explorer 2: " + "Non-release build, runtime debug assertions are turned on"); + return true; +} + + +static void CheckRootUrlIsValid(const std::string& value, const std::string& name, bool allowEmpty) +{ + if (allowEmpty && value.size() == 0) + { + return; + } + + if (value.size() < 1 || + value[0] != '/' || + value[value.size() - 1] != '/') + { + OrthancPlugins::LogError("Orthanc-Explorer 2: '" + name + "' configuration shall start with a '/' and end with a '/': " + value); + throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); + } +} + +OrthancPluginErrorCode OnChangeCallback(OrthancPluginChangeType changeType, + OrthancPluginResourceType resourceType, + const char* resourceId) +{ + try + { + if (changeType == OrthancPluginChangeType_OrthancStarted) + { + // this can not be performed during plugin initialization because it is accessing the DB -> must be done when Orthanc has just started + pluginsConfiguration_ = GetPluginsConfiguration(hasUserProfile_); + } + } + catch (Orthanc::OrthancException& e) + { + LOG(ERROR) << "Exception: " << e.What(); + return static_cast(e.GetErrorCode()); + } + + return OrthancPluginErrorCode_Success; +} + + +extern "C" +{ + ORTHANC_PLUGINS_API int32_t OrthancPluginInitialize(OrthancPluginContext* context) + { + assert(DisplayPerformanceWarning(context)); + + OrthancPlugins::SetGlobalContext(context); + + Orthanc::Logging::InitializePluginContext(context); + + Orthanc::Logging::EnableInfoLevel(true); + + + /* Check the version of the Orthanc core */ + if (!OrthancPlugins::CheckMinimalOrthancVersion(ORTHANC_CORE_MINIMAL_MAJOR, + ORTHANC_CORE_MINIMAL_MINOR, + ORTHANC_CORE_MINIMAL_REVISION)) + { + OrthancPlugins::ReportMinimalOrthancVersion(ORTHANC_CORE_MINIMAL_MAJOR, + ORTHANC_CORE_MINIMAL_MINOR, + ORTHANC_CORE_MINIMAL_REVISION); + return -1; + } + + OrthancPlugins::SetDescription(ORTHANC_PLUGIN_NAME, "Advanced User Interface for Orthanc"); + + try + { + ReadConfiguration(); + + if (pluginJsonConfiguration_["Enable"].asBool()) + { + oe2BaseUrl_ = pluginJsonConfiguration_["Root"].asString(); + + CheckRootUrlIsValid(oe2BaseUrl_, "Root", false); + + OrthancPlugins::LogWarning("Root URI to the Orthanc-Explorer 2 application: " + oe2BaseUrl_); + + + OrthancPlugins::RegisterRestCallback + + (oe2BaseUrl_ + "app/customizable/custom.css", true); + + if (!customLogoPath_.empty()) + { + OrthancPlugins::RegisterRestCallback + > + (oe2BaseUrl_ + "app/customizable/custom-logo", true); + } + + // we need to mix the "routing" between the server and the frontend (vue-router) + // first part are the files that are 'static files' that must be served by the backend + OrthancPlugins::RegisterRestCallback + > + (oe2BaseUrl_ + "app/assets/(.*)", true); + OrthancPlugins::RegisterRestCallback + > + (oe2BaseUrl_ + "app/index.html", true); + OrthancPlugins::RegisterRestCallback + > + (oe2BaseUrl_ + "app/token-landing.html", true); + OrthancPlugins::RegisterRestCallback + > + (oe2BaseUrl_ + "app/retrieve-and-view.html", true); + + if (customFavIconPath_.empty()) + { + OrthancPlugins::RegisterRestCallback + > + (oe2BaseUrl_ + "app/favicon.ico", true); + } + else + { + OrthancPlugins::RegisterRestCallback + > + (oe2BaseUrl_ + "app/favicon.ico", true); + } + // second part are all the routes that are actually handled by vue-router and that are actually returning the same file (index.html) + OrthancPlugins::RegisterRestCallback + > + (oe2BaseUrl_ + "app/(.*)", true); + OrthancPlugins::RegisterRestCallback + > + (oe2BaseUrl_ + "app", true); + + OrthancPlugins::RegisterRestCallback(oe2BaseUrl_ + "api/configuration", true); + OrthancPlugins::RegisterRestCallback(oe2BaseUrl_ + "api/pre-login-configuration", true); + + std::string pluginRootUri = oe2BaseUrl_ + "app/"; + OrthancPlugins::SetRootUri(ORTHANC_PLUGIN_NAME, pluginRootUri.c_str()); + + if (pluginJsonConfiguration_["IsDefaultOrthancUI"].asBool()) + { + OrthancPlugins::RegisterRestCallback("/", true); + } + + OrthancPluginRegisterOnChangeCallback(context, OnChangeCallback); + + { + std::string explorer; + Orthanc::EmbeddedResources::GetFileResource(explorer, Orthanc::EmbeddedResources::ORTHANC_EXPLORER); + + std::map dictionary; + dictionary["OE2_BASE_URL"] = oe2BaseUrl_.substr(1, oe2BaseUrl_.size() - 2); // Remove heading and trailing slashes + std::string explorerConfigured = Orthanc::Toolbox::SubstituteVariables(explorer, dictionary); + + OrthancPluginExtendOrthancExplorer(OrthancPlugins::GetGlobalContext(), explorerConfigured.c_str()); + } + } + else + { + OrthancPlugins::LogWarning("Orthanc Explorer 2 plugin is disabled"); + } + } + catch (Orthanc::OrthancException& e) + { + OrthancPlugins::LogError("Exception while initializing the Orthanc-Explorer 2 plugin: " + + std::string(e.What())); + return -1; + } + catch (...) + { + OrthancPlugins::LogError("Exception while initializing the Orthanc-Explorer 2 plugin"); + return -1; + } + + return 0; + } + + + ORTHANC_PLUGINS_API void OrthancPluginFinalize() + { + } + + + ORTHANC_PLUGINS_API const char* OrthancPluginGetName() + { + return ORTHANC_PLUGIN_NAME; + } + + + ORTHANC_PLUGINS_API const char* OrthancPluginGetVersion() + { + return ORTHANC_OE2_VERSION; + } +} diff --git a/README.md b/README.md new file mode 100644 index 0000000..560f782 --- /dev/null +++ b/README.md @@ -0,0 +1,148 @@ +# Orthanc Explorer 2 + +This [Orthanc](https://www.orthanc-server.com) plugin implements a new +user interface for Orthanc to replace the Orthanc Explorer. + +## Installation + +Binaries are available: +- [here on Github](https://github.com/orthanc-server/orthanc-explorer-2/releases), you'll find the plugin for + - Windows 64bits + - Ubuntu 20.04 + - MacOS (Universal binary) +- in the [Windows Installers](https://orthanc.uclouvain.be/downloads/windows-64/installers/index.html) (64bits version only), + the plugin is enabled but, right now, the legacy Orthanc Explorer + remains the default UI. Note that, in a future release, OE2 will become the default UI for Orthanc in the Windows Installers. +- in the [orthancteam/orthanc](https://hub.docker.com/r/orthancteam/orthanc) Docker images, + the plugin is enabled but, right now, the legacy Orthanc Explorer + remains the default UI. Note that, in a future release, OE2 will become the default UI for Orthanc in the Windows Installers. + +The binaries must be copied next to other Orthanc plugins (Windows: `C:\\Program Files\\Orthanc Server\\Plugins`, ubuntu: `/usr/share/orthanc/plugins/`). You should also possible make sure that the plugin is listed in the `"Plugins"` Orthanc configuration. + +## Configuration + +Like any other Orthanc plugins, Orthanc Explorer 2 is configured through +a json [configuration file](Plugin/DefaultConfiguration.json) that is provided to Orthanc at startup. + +At minimum, you should provide this configuration file: +```json +{ + "Plugins": [ "." ], + "OrthancExplorer2": { + "Enable": true, + "IsDefaultOrthancUI": false + } +} +``` + +Using this minimal configuration file, Orthanc Explorer 2 is +accessible at http://localhost:8042/ui/app/ . If `IsDefaultOrthancUI` +is set to `true`, Orthanc Explorer 2 will replace the built-in Orthanc +Explorer. + +If you are using Docker, the easiest way to try the new Orthanc Explorer 2 is to run this command and then open a browser in http://localhost:8042/ui/app/ (login: orthanc, pwd: orthanc) + +```shell +docker pull orthancteam/orthanc:latest +docker run -p 8042:8042 orthancteam/orthanc:latest +``` + + +## Front-end development + +Prerequisites: + +- install `nodejs` version 14 or higher and `npm` version 6 or higher +- install nginx + +Then, to continuously build and serve the front-end code on your machine, in a shell, type: + +```shell +cd WebApplication +npm install +npm run dev +``` +Npm will then serve the `/ui/app/` static code (HTML/JS). + +Then, launch an Orthanc with the OE2 plugin already enabled and listening on localhost:8043. This can be achieved with by typing this command in another shell: + +```shell +docker run -p 8043:8042 -e ORTHANC__AUTHENTICATION_ENABLED=false orthancteam/orthanc:24.6.2 +``` +This Orthanc will serve the `/ui/api/` routes. + +In third shell, type: + +```shell +sudo ./scripts/start-nginx.sh +``` +This will launch an nginx server that will implement reverse proxies to serve both the static code and the Orthanc Rest API on a single endpoind. +You may then open http://localhost:9999/ui/app/ to view and debug your current front-end code. As soon as you modify a `WebApplication` source file, the UI shall reload automatically in the browser. + +Edit scripts/nginx-dev.conf if needed. + + +## Compilation + +Prerequisites to build the frontend: you need `nodejs` version 14 or higher and `npm` version 6 or higher. + +To build the frontend: + +```shell +cd WebApplication +npm install +npm run build +``` + +And then, to build the C++ plugin: +``` +cd /build +cmake -DWEBAPP_DIST_SOURCE=LOCAL -DALLOW_DOWNLOADS=ON -DCMAKE_BUILD_TYPE:STRING=Release -DUSE_SYSTEM_ORTHANC_SDK=OFF /sources/orthanc-explorer-2/ +make -j 4 +``` + +### LSB (Linux Standard Base) + +Here are the build instructions for LSB: + +``` +cd WebApplication +npm install +npm run build +cd .. +mkdir build-lsb +cd build-lsb +LSB_CC=gcc-4.8 LSB_CXX=g++-4.8 cmake -DCMAKE_TOOLCHAIN_FILE=../Resources/Orthanc/Toolchains/LinuxStandardBaseToolchain.cmake -DALLOW_DOWNLOADS=ON -DSTATIC_BUILD=ON -DUSE_LEGACY_JSONCPP=ON -DWEBAPP_DIST_SOURCE=WEB .. +make -j4 +``` + +Pre-compiled LSB binaries can be found at: https://orthanc.uclouvain.be/downloads/linux-standard-base/orthanc-explorer-2/index.html + +### Linking against system-wide Orthanc Framework + +Here are the build instructions to dynamic link against the +system-wide Orthanc Framework: + +``` +cd WebApplication +npm install +npm run build +cd .. +mkdir build-system +cd build-system +cmake .. -DCMAKE_BUILD_TYPE=Debug -DORTHANC_FRAMEWORK_SOURCE=system -DUSE_SYSTEM_GOOGLE_TEST=OFF -DALLOW_DOWNLOADS=ON -DUSE_SYSTEM_ORTHANC_SDK=OFF -DWEBAPP_DIST_SOURCE=LOCAL +make -j4 +``` + + +## Releasing + +``` +git tag -a 0.2.0 -m 0.2.0 +git push --tags +git push +``` + +### Contributions + +Feel free to fork this project, modify it and submit pull requests. diff --git a/Resources/CreateDistPackage.sh b/Resources/CreateDistPackage.sh new file mode 100644 index 0000000..08077b2 --- /dev/null +++ b/Resources/CreateDistPackage.sh @@ -0,0 +1,55 @@ +#!/bin/bash + +# Orthanc - A Lightweight, RESTful DICOM Store +# Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics +# Department, University Hospital of Liege, Belgium +# Copyright (C) 2017-2024 Osimis S.A., Belgium +# Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium +# +# This program is free software: you can redistribute it and/or +# modify it under the terms of the GNU Affero General Public License +# as published by the Free Software Foundation, either version 3 of +# the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with this program. If not, see . + + +# This command-line script uses the "npm" tool to populate the "dist" +# folder of Orthanc Explorer 2. It uses Docker to this end, in order +# to be usable on our CIS. + +set -ex + +if [ -t 1 ]; then + # TTY is available => use interactive mode + DOCKER_FLAGS='-i' +fi + +ROOT_DIR=`dirname $(readlink -f $0)`/.. +IMAGE=orthanc-explorer-2-npm + +echo "Creating the distribution of Orthanc Explorer 2" + +if [ -e "${ROOT_DIR}/WebApplication/dist/" ]; then + echo "Target folder is already existing, aborting" + exit -1 +fi + +mkdir -p ${ROOT_DIR}/WebApplication/dist/ + +( cd ${ROOT_DIR}/Resources/CreateDistPackage && \ + docker build --no-cache -t ${IMAGE} . ) + +docker run -t ${DOCKER_FLAGS} --rm \ + --user $(id -u):$(id -g) \ + -v ${ROOT_DIR}/Resources/CreateDistPackage/build.sh:/source/build.sh:ro \ + -v ${ROOT_DIR}/WebApplication:/source/WebApplication:ro \ + -v ${ROOT_DIR}/WebApplication/dist/:/target:rw \ + ${IMAGE} \ + bash /source/build.sh diff --git a/Resources/CreateDistPackage/Dockerfile b/Resources/CreateDistPackage/Dockerfile new file mode 100644 index 0000000..b437bfb --- /dev/null +++ b/Resources/CreateDistPackage/Dockerfile @@ -0,0 +1,28 @@ +# Orthanc - A Lightweight, RESTful DICOM Store +# Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics +# Department, University Hospital of Liege, Belgium +# Copyright (C) 2017-2022 Osimis S.A., Belgium +# Copyright (C) 2021-2022 Sebastien Jodogne, ICTEAM UCLouvain, Belgium +# +# This program is free software: you can redistribute it and/or +# modify it under the terms of the GNU Affero General Public License +# as published by the Free Software Foundation, either version 3 of +# the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with this program. If not, see . + + +FROM node:19.7.0-bullseye-slim + +MAINTAINER Sebastien Jodogne +LABEL Description="Orthanc, free DICOM server" Vendor="The Orthanc project" + +RUN apt-get -y clean && apt-get -y update && \ + DEBIAN_FRONTEND=noninteractive apt-get -y install patch && \ + apt-get clean && rm -rf /var/lib/apt/lists/* diff --git a/Resources/CreateDistPackage/build.sh b/Resources/CreateDistPackage/build.sh new file mode 100644 index 0000000..9361c96 --- /dev/null +++ b/Resources/CreateDistPackage/build.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +# Orthanc - A Lightweight, RESTful DICOM Store +# Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics +# Department, University Hospital of Liege, Belgium +# Copyright (C) 2017-2024 Osimis S.A., Belgium +# Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium +# +# This program is free software: you can redistribute it and/or +# modify it under the terms of the GNU Affero General Public License +# as published by the Free Software Foundation, either version 3 of +# the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with this program. If not, see . + +set -ex + +cp -r /source/WebApplication /tmp/ + +cd /tmp/WebApplication +npm install --cache /tmp/npm-cache +npm run build --cache /tmp/npm-cache + +cp -r /tmp/WebApplication/dist/* /target diff --git a/Resources/MoveTranslations.py b/Resources/MoveTranslations.py new file mode 100644 index 0000000..8d16817 --- /dev/null +++ b/Resources/MoveTranslations.py @@ -0,0 +1,38 @@ +import json +import os +import shutil +import pathlib + +here = pathlib.Path(__file__).parent.resolve() / "../WebApplication/src/locales/" + +for p in here.glob("*.json"): + with open(p, "r", encoding="utf-8") as f: + translations = json.load(f) + + if "settings" in translations and isinstance(translations["settings"], str): + title = translations["settings"] + del translations["settings"] + translations["settings"] = {} + + for i in ["dicom_AET", + "dicom_port", + "ingest_transcoding", + "installed_plugins", + "orthanc_name", + "orthanc_system_info", + "orthanc_version", + "overwrite_instances", + "plugins_not_enabled", + "striked_through", + "ingest_transcoding", + "verbosity_level", + "storage_compression", + "storage_size", + "statistics" + ]: + if i in translations: + translations["settings"][i] = translations[i] + del translations[i] + + with open(p, "w", encoding="utf-8") as f: + data = json.dump(translations, f, ensure_ascii=False, indent=4, sort_keys=True) diff --git a/Resources/Orthanc/CMake/AutoGeneratedCode.cmake b/Resources/Orthanc/CMake/AutoGeneratedCode.cmake new file mode 100644 index 0000000..d5fcd8e --- /dev/null +++ b/Resources/Orthanc/CMake/AutoGeneratedCode.cmake @@ -0,0 +1,80 @@ +# Orthanc - A Lightweight, RESTful DICOM Store +# Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics +# Department, University Hospital of Liege, Belgium +# Copyright (C) 2017-2023 Osimis S.A., Belgium +# Copyright (C) 2024-2024 Orthanc Team SRL, Belgium +# Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium +# +# This program is free software: you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public License +# as published by the Free Software Foundation, either version 3 of +# the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this program. If not, see +# . + + +set(EMBED_RESOURCES_PYTHON "${CMAKE_CURRENT_LIST_DIR}/../EmbedResources.py" + CACHE INTERNAL "Path to the EmbedResources.py script from Orthanc") +set(AUTOGENERATED_DIR "${CMAKE_CURRENT_BINARY_DIR}/AUTOGENERATED") +set(AUTOGENERATED_SOURCES) + +file(MAKE_DIRECTORY ${AUTOGENERATED_DIR}) +include_directories(${AUTOGENERATED_DIR}) + +macro(EmbedResources) + # Convert a semicolon separated list to a whitespace separated string + set(SCRIPT_OPTIONS) + set(SCRIPT_ARGUMENTS) + set(DEPENDENCIES) + set(IS_PATH_NAME false) + + set(TARGET_BASE "${AUTOGENERATED_DIR}/EmbeddedResources") + + # Loop over the arguments of the function + foreach(arg ${ARGN}) + # Extract the first character of the argument + string(SUBSTRING "${arg}" 0 1 FIRST_CHAR) + if (${FIRST_CHAR} STREQUAL "-") + # If the argument starts with a dash "-", this is an option to + # EmbedResources.py + if (${arg} MATCHES "--target=.*") + # Does the argument starts with "--target="? + string(SUBSTRING "${arg}" 9 -1 TARGET) # 9 is the length of "--target=" + set(TARGET_BASE "${AUTOGENERATED_DIR}/${TARGET}") + else() + list(APPEND SCRIPT_OPTIONS ${arg}) + endif() + else() + if (${IS_PATH_NAME}) + list(APPEND SCRIPT_ARGUMENTS "${arg}") + list(APPEND DEPENDENCIES "${arg}") + set(IS_PATH_NAME false) + else() + list(APPEND SCRIPT_ARGUMENTS "${arg}") + set(IS_PATH_NAME true) + endif() + endif() + endforeach() + + add_custom_command( + OUTPUT + "${TARGET_BASE}.h" + "${TARGET_BASE}.cpp" + COMMAND ${PYTHON_EXECUTABLE} ${EMBED_RESOURCES_PYTHON} + ${SCRIPT_OPTIONS} "${TARGET_BASE}" ${SCRIPT_ARGUMENTS} + DEPENDS + ${EMBED_RESOURCES_PYTHON} + ${DEPENDENCIES} + ) + + list(APPEND AUTOGENERATED_SOURCES + "${TARGET_BASE}.cpp" + ) +endmacro() diff --git a/Resources/Orthanc/CMake/Compiler.cmake b/Resources/Orthanc/CMake/Compiler.cmake new file mode 100644 index 0000000..d03f739 --- /dev/null +++ b/Resources/Orthanc/CMake/Compiler.cmake @@ -0,0 +1,303 @@ +# Orthanc - A Lightweight, RESTful DICOM Store +# Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics +# Department, University Hospital of Liege, Belgium +# Copyright (C) 2017-2023 Osimis S.A., Belgium +# Copyright (C) 2024-2024 Orthanc Team SRL, Belgium +# Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium +# +# This program is free software: you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public License +# as published by the Free Software Foundation, either version 3 of +# the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this program. If not, see +# . + + +# This file sets all the compiler-related flags + + +# Save the current compiler flags to the cache every time cmake configures the project +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}" CACHE STRING "compiler flags" FORCE) +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" CACHE STRING "compiler flags" FORCE) + + +include(CheckLibraryExists) + +if ((CMAKE_CROSSCOMPILING AND NOT + "${CMAKE_SYSTEM_VERSION}" STREQUAL "CrossToolNg") OR + "${CMAKE_SYSTEM_VERSION}" STREQUAL "LinuxStandardBase") + # Cross-compilation necessarily implies standalone and static build + SET(STATIC_BUILD ON) + SET(STANDALONE_BUILD ON) +endif() + + +if ("${CMAKE_SYSTEM_VERSION}" STREQUAL "LinuxStandardBase") + # Cache the environment variables "LSB_CC" and "LSB_CXX" for further + # use by "ExternalProject" in CMake + SET(CMAKE_LSB_CC $ENV{LSB_CC} CACHE STRING "") + SET(CMAKE_LSB_CXX $ENV{LSB_CXX} CACHE STRING "") + + # This is necessary to build "Orthanc mainline - Framework LSB + # Release" on "buildbot-worker-debian11" + set(LSB_PTHREAD_NONSHARED "${LSB_PATH}/lib64-${LSB_TARGET_VERSION}/libpthread_nonshared.a") + if (EXISTS ${LSB_PTHREAD_NONSHARED}) + set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${LSB_PTHREAD_NONSHARED}") + endif() +endif() + + +if (CMAKE_COMPILER_IS_GNUCXX) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wno-long-long") + + # --std=c99 makes libcurl not to compile + # -pedantic gives a lot of warnings on OpenSSL + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wno-long-long -Wno-variadic-macros") + + if (CMAKE_CROSSCOMPILING) + # http://stackoverflow.com/a/3543845/881731 + set(CMAKE_RC_COMPILE_OBJECT " -O coff -I ") + endif() + +elseif (MSVC) + # Use static runtime under Visual Studio + # http://www.cmake.org/Wiki/CMake_FAQ#Dynamic_Replace + # http://stackoverflow.com/a/6510446 + foreach(flag_var + CMAKE_C_FLAGS_DEBUG + CMAKE_CXX_FLAGS_DEBUG + CMAKE_C_FLAGS_RELEASE + CMAKE_CXX_FLAGS_RELEASE + CMAKE_C_FLAGS_MINSIZEREL + CMAKE_CXX_FLAGS_MINSIZEREL + CMAKE_C_FLAGS_RELWITHDEBINFO + CMAKE_CXX_FLAGS_RELWITHDEBINFO) + string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}") + string(REGEX REPLACE "/MDd" "/MTd" ${flag_var} "${${flag_var}}") + endforeach(flag_var) + + # Add /Zm256 compiler option to Visual Studio to fix PCH errors + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Zm256") + + # New in Orthanc 1.5.5 + if (MSVC_MULTIPLE_PROCESSES) + # "If you omit the processMax argument in the /MP option, the + # compiler obtains the number of effective processors from the + # operating system, and then creates one process per effective + # processor" + # https://blog.kitware.com/cmake-building-with-all-your-cores/ + # https://docs.microsoft.com/en-us/cpp/build/reference/mp-build-with-multiple-processes + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /MP") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP") + endif() + + add_definitions( + -D_CRT_SECURE_NO_WARNINGS=1 + -D_CRT_SECURE_NO_DEPRECATE=1 + ) + + if (MSVC_VERSION LESS 1600) + # Starting with Visual Studio >= 2010 (i.e. macro _MSC_VER >= + # 1600), Microsoft ships a standard-compliant + # header. For earlier versions of Visual Studio, give access to a + # compatibility header. + # http://stackoverflow.com/a/70630/881731 + # https://en.wikibooks.org/wiki/C_Programming/C_Reference/stdint.h#External_links + include_directories(${CMAKE_CURRENT_LIST_DIR}/../../Resources/ThirdParty/VisualStudio) + endif() + + link_libraries(netapi32) +endif() + + +if (${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD" OR + ${CMAKE_SYSTEM_NAME} STREQUAL "OpenBSD") + # In FreeBSD/OpenBSD, the "/usr/local/" folder contains the ports and need to be imported + SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -I/usr/local/include") + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I/usr/local/include") + SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -L/usr/local/lib") + SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -L/usr/local/lib") +endif() + + +if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux" OR + ${CMAKE_SYSTEM_NAME} STREQUAL "kFreeBSD" OR + ${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD" OR + ${CMAKE_SYSTEM_NAME} STREQUAL "OpenBSD") + + if (# NOT ${CMAKE_SYSTEM_VERSION} STREQUAL "LinuxStandardBase" AND + NOT ${CMAKE_SYSTEM_NAME} STREQUAL "OpenBSD" AND + NOT ${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD") + # The "--no-undefined" linker flag makes the shared libraries + # (plugins ModalityWorklists and ServeFolders) fail to compile on + # OpenBSD, and make the PostgreSQL plugin complain about missing + # "environ" global variable in FreeBSD. + # + # TODO - Furthermore, on Linux Standard Base running on Debian 12, + # the "-Wl,--no-undefined" seems to break the compilation (added + # after Orthanc 1.12.2). This is disabled for now. + set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Wl,--no-undefined") + set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--no-undefined") + endif() + + # Remove the "-rdynamic" option + # http://www.mail-archive.com/cmake@cmake.org/msg08837.html + set(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS "") + link_libraries(pthread) + + if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "OpenBSD") + link_libraries(rt) + endif() + + if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD" AND + NOT ${CMAKE_SYSTEM_NAME} STREQUAL "OpenBSD") + link_libraries(dl) + endif() + + if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD" AND + NOT ${CMAKE_SYSTEM_NAME} STREQUAL "OpenBSD") + # The "--as-needed" linker flag is not available on FreeBSD and OpenBSD + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--as-needed") + set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Wl,--as-needed") + set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--as-needed") + endif() + + if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD" AND + NOT ${CMAKE_SYSTEM_NAME} STREQUAL "OpenBSD") + # FreeBSD/OpenBSD have just one single interface for file + # handling, which is 64bit clean, so there is no need to define macro + # for LFS (Large File Support). + # https://ohse.de/uwe/articles/lfs.html + add_definitions( + -D_LARGEFILE64_SOURCE=1 + -D_FILE_OFFSET_BITS=64 + ) + endif() + +elseif(${CMAKE_SYSTEM_NAME} STREQUAL "Windows") + if (MSVC) + message("MSVC compiler version = " ${MSVC_VERSION} "\n") + # Starting Visual Studio 2013 (version 1800), it is not possible + # to target Windows XP anymore + if (MSVC_VERSION LESS 1800) + add_definitions( + -DWINVER=0x0501 + -D_WIN32_WINNT=0x0501 + ) + endif() + else() + add_definitions( + -DWINVER=0x0501 + -D_WIN32_WINNT=0x0501 + ) + endif() + + add_definitions( + -D_CRT_SECURE_NO_WARNINGS=1 + ) + link_libraries(rpcrt4 ws2_32 iphlpapi) # "iphlpapi" is for "SystemToolbox::GetMacAddresses()" + + if (CMAKE_COMPILER_IS_GNUCXX) + # Some additional C/C++ compiler flags for MinGW + SET(MINGW_NO_WARNINGS "-Wno-unused-function -Wno-unused-variable") + SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${MINGW_NO_WARNINGS} -Wno-pointer-to-int-cast -Wno-int-to-pointer-cast") + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${MINGW_NO_WARNINGS}") + + if (DYNAMIC_MINGW_STDLIB) + else() + # This is a patch for MinGW64 + SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--allow-multiple-definition -static-libgcc -static-libstdc++") + SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--allow-multiple-definition -static-libgcc -static-libstdc++") + endif() + + CHECK_LIBRARY_EXISTS(winpthread pthread_create "" HAVE_WIN_PTHREAD) + if (HAVE_WIN_PTHREAD) + if (DYNAMIC_MINGW_STDLIB) + else() + # This line is necessary to compile with recent versions of MinGW, + # otherwise "libwinpthread-1.dll" is not statically linked. + SET(CMAKE_CXX_STANDARD_LIBRARIES "${CMAKE_CXX_STANDARD_LIBRARIES} -Wl,-Bstatic -lstdc++ -lpthread -Wl,-Bdynamic") + endif() + add_definitions(-DHAVE_WIN_PTHREAD=1) + else() + add_definitions(-DHAVE_WIN_PTHREAD=0) + endif() + endif() + +elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Darwin") + + # fix this error that appears with recent compilers on MacOS: boost/mpl/aux_/integral_wrapper.hpp:73:31: error: integer value -1 is outside the valid range of values [0, 3] for this enumeration type [-Wenum-constexpr-conversion] + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-enum-constexpr-conversion") + + add_definitions( + -D_XOPEN_SOURCE=1 + ) + link_libraries(iconv) + +elseif (CMAKE_SYSTEM_NAME STREQUAL "Emscripten") + message("Building using Emscripten (for WebAssembly or asm.js targets)") + include(${CMAKE_CURRENT_LIST_DIR}/EmscriptenParameters.cmake) + +elseif (CMAKE_SYSTEM_NAME STREQUAL "Android") + +else() + message("Unknown target platform: ${CMAKE_SYSTEM_NAME}") + message(FATAL_ERROR "Support your platform here") +endif() + + +if (DEFINED ENABLE_PROFILING AND ENABLE_PROFILING) + if (CMAKE_COMPILER_IS_GNUCXX OR + CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pg") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pg") + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -pg") + set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -pg") + set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -pg") + else() + message(FATAL_ERROR "Don't know how to enable profiling on your configuration") + endif() +endif() + + +if (CMAKE_COMPILER_IS_GNUCXX) + # "When creating a static library using binutils (ar) and there + # exist a duplicate object name (e.g. a/Foo.cpp.o, b/Foo.cpp.o), the + # resulting static library can end up having only one of the + # duplicate objects. [...] This bug only happens if there are many + # objects." The trick consists in replacing the "r" argument + # ("replace") provided to "ar" (as used in CMake < 3.1) by the "q" + # argument ("quick append"). This is because of the fact that CMake + # will invoke "ar" several times with several batches of ".o" + # objects, and using "r" would overwrite symbols defined in + # preceding batches. https://cmake.org/Bug/view.php?id=14874 + set(CMAKE_CXX_ARCHIVE_APPEND " q ") +endif() + + +# This function defines macro "__ORTHANC_FILE__" as a replacement to +# macro "__FILE__", as the latter leaks the full path of the source +# files in the binaries +# https://stackoverflow.com/questions/8487986/file-macro-shows-full-path +# https://twitter.com/wget42/status/1676877802375634944?s=20 +function(DefineSourceBasenameForTarget targetname) + # Microsoft Visual Studio is extremely slow if using + # "set_property()", we only enable this feature for gcc and clang + if (CMAKE_COMPILER_IS_GNUCXX OR + CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + get_target_property(source_files "${targetname}" SOURCES) + foreach(sourcefile ${source_files}) + get_filename_component(basename "${sourcefile}" NAME) + set_property( + SOURCE "${sourcefile}" APPEND + PROPERTY COMPILE_DEFINITIONS "__ORTHANC_FILE__=\"${basename}\"") + endforeach() + endif() +endfunction() diff --git a/Resources/Orthanc/CMake/DownloadOrthancFramework.cmake b/Resources/Orthanc/CMake/DownloadOrthancFramework.cmake new file mode 100644 index 0000000..088baa4 --- /dev/null +++ b/Resources/Orthanc/CMake/DownloadOrthancFramework.cmake @@ -0,0 +1,578 @@ +# Orthanc - A Lightweight, RESTful DICOM Store +# Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics +# Department, University Hospital of Liege, Belgium +# Copyright (C) 2017-2023 Osimis S.A., Belgium +# Copyright (C) 2024-2024 Orthanc Team SRL, Belgium +# Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium +# +# This program is free software: you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public License +# as published by the Free Software Foundation, either version 3 of +# the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this program. If not, see +# . + + + +## +## Check whether the parent script sets the mandatory variables +## + +if (NOT DEFINED ORTHANC_FRAMEWORK_SOURCE OR + (NOT ORTHANC_FRAMEWORK_SOURCE STREQUAL "system" AND + NOT ORTHANC_FRAMEWORK_SOURCE STREQUAL "hg" AND + NOT ORTHANC_FRAMEWORK_SOURCE STREQUAL "web" AND + NOT ORTHANC_FRAMEWORK_SOURCE STREQUAL "archive" AND + NOT ORTHANC_FRAMEWORK_SOURCE STREQUAL "path")) + message(FATAL_ERROR "The variable ORTHANC_FRAMEWORK_SOURCE must be set to \"system\", \"hg\", \"web\", \"archive\" or \"path\"") +endif() + + +## +## Detection of the requested version +## + +if (ORTHANC_FRAMEWORK_SOURCE STREQUAL "hg" OR + ORTHANC_FRAMEWORK_SOURCE STREQUAL "archive" OR + ORTHANC_FRAMEWORK_SOURCE STREQUAL "web") + if (NOT DEFINED ORTHANC_FRAMEWORK_VERSION) + message(FATAL_ERROR "The variable ORTHANC_FRAMEWORK_VERSION must be set") + endif() + + if (DEFINED ORTHANC_FRAMEWORK_MAJOR OR + DEFINED ORTHANC_FRAMEWORK_MINOR OR + DEFINED ORTHANC_FRAMEWORK_REVISION OR + DEFINED ORTHANC_FRAMEWORK_MD5) + message(FATAL_ERROR "Some internal variable has been set") + endif() + + set(ORTHANC_FRAMEWORK_MD5 "") + + if (NOT DEFINED ORTHANC_FRAMEWORK_BRANCH) + if (ORTHANC_FRAMEWORK_VERSION STREQUAL "mainline") + set(ORTHANC_FRAMEWORK_BRANCH "default") + set(ORTHANC_FRAMEWORK_MAJOR 999) + set(ORTHANC_FRAMEWORK_MINOR 999) + set(ORTHANC_FRAMEWORK_REVISION 999) + + else() + set(ORTHANC_FRAMEWORK_BRANCH "Orthanc-${ORTHANC_FRAMEWORK_VERSION}") + + set(RE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$") + string(REGEX REPLACE ${RE} "\\1" ORTHANC_FRAMEWORK_MAJOR ${ORTHANC_FRAMEWORK_VERSION}) + string(REGEX REPLACE ${RE} "\\2" ORTHANC_FRAMEWORK_MINOR ${ORTHANC_FRAMEWORK_VERSION}) + string(REGEX REPLACE ${RE} "\\3" ORTHANC_FRAMEWORK_REVISION ${ORTHANC_FRAMEWORK_VERSION}) + + if (NOT ORTHANC_FRAMEWORK_MAJOR MATCHES "^[0-9]+$" OR + NOT ORTHANC_FRAMEWORK_MINOR MATCHES "^[0-9]+$" OR + NOT ORTHANC_FRAMEWORK_REVISION MATCHES "^[0-9]+$") + message("Bad version of the Orthanc framework, assuming a pre-release: ${ORTHANC_FRAMEWORK_VERSION}") + set(ORTHANC_FRAMEWORK_MAJOR 999) + set(ORTHANC_FRAMEWORK_MINOR 999) + set(ORTHANC_FRAMEWORK_REVISION 999) + endif() + + if (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.3.1") + set(ORTHANC_FRAMEWORK_MD5 "dac95bd6cf86fb19deaf4e612961f378") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.3.2") + set(ORTHANC_FRAMEWORK_MD5 "d0ccdf68e855d8224331f13774992750") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.4.0") + set(ORTHANC_FRAMEWORK_MD5 "81e15f34d97ac32bbd7d26e85698835a") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.4.1") + set(ORTHANC_FRAMEWORK_MD5 "9b6f6114264b17ed421b574cd6476127") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.4.2") + set(ORTHANC_FRAMEWORK_MD5 "d1ee84927dcf668e60eb5868d24b9394") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.5.0") + set(ORTHANC_FRAMEWORK_MD5 "4429d8d9dea4ff6648df80ec3c64d79e") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.5.1") + set(ORTHANC_FRAMEWORK_MD5 "099671538865e5da96208b37494d6718") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.5.2") + set(ORTHANC_FRAMEWORK_MD5 "8867050f3e9a1ce6157c1ea7a9433b1b") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.5.3") + set(ORTHANC_FRAMEWORK_MD5 "bf2f5ed1adb8b0fc5f10d278e68e1dfe") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.5.4") + set(ORTHANC_FRAMEWORK_MD5 "404baef5d4c43e7c5d9410edda8ef5a5") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.5.5") + set(ORTHANC_FRAMEWORK_MD5 "cfc437e0687ae4bd725fd93dc1f08bc4") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.5.6") + set(ORTHANC_FRAMEWORK_MD5 "3c29de1e289b5472342947168f0105c0") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.5.7") + set(ORTHANC_FRAMEWORK_MD5 "e1b76f01116d9b5d4ac8cc39980560e3") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.5.8") + set(ORTHANC_FRAMEWORK_MD5 "82323e8c49a667f658a3639ea4dbc336") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.6.0") + set(ORTHANC_FRAMEWORK_MD5 "eab428d6e53f61e847fa360bb17ebe25") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.6.1") + set(ORTHANC_FRAMEWORK_MD5 "3971f5de96ba71dc9d3f3690afeaa7c0") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.7.0") + set(ORTHANC_FRAMEWORK_MD5 "ce5f689e852b01d3672bd3d2f952a5ef") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.7.1") + set(ORTHANC_FRAMEWORK_MD5 "3c171217f930abe80246997bdbcaf7cc") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.7.2") + set(ORTHANC_FRAMEWORK_MD5 "328f94dcbd78c169655a13f7ad58a2c2") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.7.3") + set(ORTHANC_FRAMEWORK_MD5 "3f1ba9502ec7c5449971d3b56087bcde") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.7.4") + set(ORTHANC_FRAMEWORK_MD5 "19fcb7c21876af86546baa048a22c6c0") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.8.0") + set(ORTHANC_FRAMEWORK_MD5 "f8ec7554ef5d23ea4ce474b1e8214de9") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.8.1") + set(ORTHANC_FRAMEWORK_MD5 "db094f96399cbe8b9bbdbce34884c220") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.8.2") + set(ORTHANC_FRAMEWORK_MD5 "8bfa10e66c9931e74111be0bfb1f4548") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.9.0") + set(ORTHANC_FRAMEWORK_MD5 "cea0b02ce184671eaf1bd668beefbf28") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.9.1") + set(ORTHANC_FRAMEWORK_MD5 "08eebc66ef93c3b40115c38501db5fbd") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.9.2") + set(ORTHANC_FRAMEWORK_MD5 "3ea66c09f64aca990016683b6375734e") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.9.3") + set(ORTHANC_FRAMEWORK_MD5 "9b86e6f00e03278293cd15643cc0233f") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.9.4") + set(ORTHANC_FRAMEWORK_MD5 "6d5ca4a73ac7d42445041ca79de1624d") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.9.5") + set(ORTHANC_FRAMEWORK_MD5 "10fc64de1254a095e5d3ed3931f0cfbb") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.9.6") + set(ORTHANC_FRAMEWORK_MD5 "4b5d05683d747c29b2860ad79d11e62e") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.9.7") + set(ORTHANC_FRAMEWORK_MD5 "c912bbb860d640d3ae3003b5c9698205") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.10.0") + set(ORTHANC_FRAMEWORK_MD5 "8610c82d9153f22e929f2110f8f60279") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.10.1") + set(ORTHANC_FRAMEWORK_MD5 "caf667fc5ea452b3d0c2f70bfd02599c") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.11.0") + set(ORTHANC_FRAMEWORK_MD5 "962c4a4a706a2ef28b390d8515dd7091") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.11.1") + set(ORTHANC_FRAMEWORK_MD5 "a39661c406adf22cf574fde290cf4bbf") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.11.2") + set(ORTHANC_FRAMEWORK_MD5 "ede3de356493a8868545f8cb4b8bc8b5") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.11.3") + set(ORTHANC_FRAMEWORK_MD5 "e48fc0cb09c4856803791a1be28c07dc") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.12.0") + set(ORTHANC_FRAMEWORK_MD5 "d32a0cde03b6eb603d8dd2b33d38bf1b") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.12.1") + set(ORTHANC_FRAMEWORK_MD5 "8a435140efc8ff4a01d8242f092f21de") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.12.2") + set(ORTHANC_FRAMEWORK_MD5 "d2476b9e796e339ac320b5333489bdb3") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.12.3") + set(ORTHANC_FRAMEWORK_MD5 "975f5bf2142c22cb1777b4f6a0a614c5") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "1.12.4") + set(ORTHANC_FRAMEWORK_MD5 "1e61779ea4a7cd705720bdcfed8a6a73") + + # Below this point are development snapshots that were used to + # release some plugin, before an official release of the Orthanc + # framework was available. Here is the command to be used to + # generate a proper archive: + # + # $ hg archive /tmp/Orthanc-`hg id -i | sed 's/\+//'`.tar.gz + # + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "ae0e3fd609df") + # DICOMweb 1.1 (framework pre-1.6.0) + set(ORTHANC_FRAMEWORK_PRE_RELEASE ON) + set(ORTHANC_FRAMEWORK_MD5 "7e09e9b530a2f527854f0b782d7e0645") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "82652c5fc04f") + # Stone Web viewer 1.0 (framework pre-1.8.1) + set(ORTHANC_FRAMEWORK_PRE_RELEASE ON) + set(ORTHANC_FRAMEWORK_MD5 "d77331d68917e66a3f4f9b807bbdab7f") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "4a3ba4bf4ba7") + # PostgreSQL 3.3 (framework pre-1.8.2) + set(ORTHANC_FRAMEWORK_PRE_RELEASE ON) + set(ORTHANC_FRAMEWORK_MD5 "2d82bddf06f9cfe82095495cb3b8abde") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "23ad1b9c7800") + # For "Toolbox::ReadJson()" and "Toolbox::Write{...}Json()" (pre-1.9.0) + set(ORTHANC_FRAMEWORK_PRE_RELEASE ON) + set(ORTHANC_FRAMEWORK_MD5 "9af92080e57c60dd288eba46ce606c00") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "b2e08d83e21d") + # WSI 1.1 (framework pre-1.10.0), to remove "-std=c++11" + set(ORTHANC_FRAMEWORK_PRE_RELEASE ON) + set(ORTHANC_FRAMEWORK_MD5 "2eaa073cbb4b44ffba199ad93393b2b1") + elseif (ORTHANC_FRAMEWORK_VERSION STREQUAL "daf4807631c5") + # DICOMweb 1.15 (framework pre-1.12.2) + set(ORTHANC_FRAMEWORK_PRE_RELEASE ON) + set(ORTHANC_FRAMEWORK_MD5 "ebe8bdf388319f1c9536b2b680451848") + endif() + endif() + endif() + +elseif (ORTHANC_FRAMEWORK_SOURCE STREQUAL "path") + message("Using the Orthanc framework from a path of the filesystem. Assuming mainline version.") + set(ORTHANC_FRAMEWORK_MAJOR 999) + set(ORTHANC_FRAMEWORK_MINOR 999) + set(ORTHANC_FRAMEWORK_REVISION 999) +endif() + + + +## +## Detection of the third-party software +## + +if (ORTHANC_FRAMEWORK_SOURCE STREQUAL "hg") + find_program(ORTHANC_FRAMEWORK_HG hg) + + if (${ORTHANC_FRAMEWORK_HG} MATCHES "ORTHANC_FRAMEWORK_HG-NOTFOUND") + message(FATAL_ERROR "Please install Mercurial") + endif() +endif() + + +if (ORTHANC_FRAMEWORK_SOURCE STREQUAL "archive" OR + ORTHANC_FRAMEWORK_SOURCE STREQUAL "web") + if ("${CMAKE_HOST_SYSTEM_NAME}" STREQUAL "Windows") + find_program(ORTHANC_FRAMEWORK_7ZIP 7z + PATHS + "$ENV{ProgramFiles}/7-Zip" + "$ENV{ProgramW6432}/7-Zip" + ) + + if (${ORTHANC_FRAMEWORK_7ZIP} MATCHES "ORTHANC_FRAMEWORK_7ZIP-NOTFOUND") + message(FATAL_ERROR "Please install the '7-zip' software (http://www.7-zip.org/)") + endif() + + else() + find_program(ORTHANC_FRAMEWORK_TAR tar) + if (${ORTHANC_FRAMEWORK_TAR} MATCHES "ORTHANC_FRAMEWORK_TAR-NOTFOUND") + message(FATAL_ERROR "Please install the 'tar' package") + endif() + endif() +endif() + + + +## +## Case of the Orthanc framework specified as a path on the filesystem +## + +if (ORTHANC_FRAMEWORK_SOURCE STREQUAL "path") + if (NOT DEFINED ORTHANC_FRAMEWORK_ROOT OR + ORTHANC_FRAMEWORK_ROOT STREQUAL "") + message(FATAL_ERROR "The variable ORTHANC_FRAMEWORK_ROOT must provide the path to the sources of Orthanc") + endif() + + if (NOT EXISTS ${ORTHANC_FRAMEWORK_ROOT}) + message(FATAL_ERROR "Non-existing directory: ${ORTHANC_FRAMEWORK_ROOT}") + endif() +endif() + + + +## +## Case of the Orthanc framework cloned using Mercurial +## + +if (ORTHANC_FRAMEWORK_SOURCE STREQUAL "hg") + if (NOT STATIC_BUILD AND NOT ALLOW_DOWNLOADS) + message(FATAL_ERROR "CMake is not allowed to download from Internet. Please set the ALLOW_DOWNLOADS option to ON") + endif() + + set(ORTHANC_ROOT ${CMAKE_BINARY_DIR}/orthanc) + + if (EXISTS ${ORTHANC_ROOT}) + message("Updating the Orthanc source repository using Mercurial") + execute_process( + COMMAND ${ORTHANC_FRAMEWORK_HG} pull + WORKING_DIRECTORY ${ORTHANC_ROOT} + RESULT_VARIABLE Failure + ) + else() + message("Forking the Orthanc source repository using Mercurial") + execute_process( + COMMAND ${ORTHANC_FRAMEWORK_HG} clone "https://orthanc.uclouvain.be/hg/orthanc/" + WORKING_DIRECTORY ${CMAKE_BINARY_DIR} + RESULT_VARIABLE Failure + ) + endif() + + if (Failure OR NOT EXISTS ${ORTHANC_ROOT}) + message(FATAL_ERROR "Cannot fork the Orthanc repository") + endif() + + message("Setting branch of the Orthanc repository to: ${ORTHANC_FRAMEWORK_BRANCH}") + + execute_process( + COMMAND ${ORTHANC_FRAMEWORK_HG} update -c ${ORTHANC_FRAMEWORK_BRANCH} + WORKING_DIRECTORY ${ORTHANC_ROOT} + RESULT_VARIABLE Failure + ) + + if (Failure) + message(FATAL_ERROR "Error while running Mercurial") + endif() +endif() + + + +## +## Case of the Orthanc framework provided as a source archive on the +## filesystem +## + +if (ORTHANC_FRAMEWORK_SOURCE STREQUAL "archive") + if (NOT DEFINED ORTHANC_FRAMEWORK_ARCHIVE OR + ORTHANC_FRAMEWORK_ARCHIVE STREQUAL "") + message(FATAL_ERROR "The variable ORTHANC_FRAMEWORK_ARCHIVE must provide the path to the sources of Orthanc") + endif() +endif() + + + +## +## Case of the Orthanc framework downloaded from the Web +## + +if (ORTHANC_FRAMEWORK_SOURCE STREQUAL "web") + if (DEFINED ORTHANC_FRAMEWORK_URL) + string(REGEX REPLACE "^.*/" "" ORTHANC_FRAMEMORK_FILENAME "${ORTHANC_FRAMEWORK_URL}") + else() + # Default case: Download from the official Web site + set(ORTHANC_FRAMEMORK_FILENAME Orthanc-${ORTHANC_FRAMEWORK_VERSION}.tar.gz) + if (ORTHANC_FRAMEWORK_PRE_RELEASE) + set(ORTHANC_FRAMEWORK_URL "https://orthanc.uclouvain.be/downloads/third-party-downloads/orthanc-framework/${ORTHANC_FRAMEMORK_FILENAME}") + else() + set(ORTHANC_FRAMEWORK_URL "https://orthanc.uclouvain.be/downloads/sources/orthanc/${ORTHANC_FRAMEMORK_FILENAME}") + endif() + endif() + + set(ORTHANC_FRAMEWORK_ARCHIVE "${CMAKE_SOURCE_DIR}/ThirdPartyDownloads/${ORTHANC_FRAMEMORK_FILENAME}") + + if (NOT EXISTS "${ORTHANC_FRAMEWORK_ARCHIVE}") + if (NOT STATIC_BUILD AND NOT ALLOW_DOWNLOADS) + message(FATAL_ERROR "CMake is not allowed to download from Internet. Please set the ALLOW_DOWNLOADS option to ON") + endif() + + message("Downloading: ${ORTHANC_FRAMEWORK_URL}") + + file(DOWNLOAD + "${ORTHANC_FRAMEWORK_URL}" "${ORTHANC_FRAMEWORK_ARCHIVE}" + SHOW_PROGRESS EXPECTED_MD5 "${ORTHANC_FRAMEWORK_MD5}" + TIMEOUT 60 + INACTIVITY_TIMEOUT 60 + ) + else() + message("Using local copy of: ${ORTHANC_FRAMEWORK_URL}") + endif() +endif() + + + + +## +## Uncompressing the Orthanc framework, if it was retrieved from a +## source archive on the filesystem, or from the official Web site +## + +if (ORTHANC_FRAMEWORK_SOURCE STREQUAL "archive" OR + ORTHANC_FRAMEWORK_SOURCE STREQUAL "web") + + if (NOT DEFINED ORTHANC_FRAMEWORK_ARCHIVE OR + NOT DEFINED ORTHANC_FRAMEWORK_VERSION OR + NOT DEFINED ORTHANC_FRAMEWORK_MD5) + message(FATAL_ERROR "Internal error") + endif() + + if (ORTHANC_FRAMEWORK_MD5 STREQUAL "") + message(FATAL_ERROR "Unknown release of Orthanc: ${ORTHANC_FRAMEWORK_VERSION}") + endif() + + file(MD5 ${ORTHANC_FRAMEWORK_ARCHIVE} ActualMD5) + + if (NOT "${ActualMD5}" STREQUAL "${ORTHANC_FRAMEWORK_MD5}") + message(FATAL_ERROR "The MD5 hash of the Orthanc archive is invalid: ${ORTHANC_FRAMEWORK_ARCHIVE}") + endif() + + set(ORTHANC_ROOT "${CMAKE_BINARY_DIR}/Orthanc-${ORTHANC_FRAMEWORK_VERSION}") + + if (NOT IS_DIRECTORY "${ORTHANC_ROOT}") + if (NOT ORTHANC_FRAMEWORK_ARCHIVE MATCHES ".tar.gz$") + message(FATAL_ERROR "Archive should have the \".tar.gz\" extension: ${ORTHANC_FRAMEWORK_ARCHIVE}") + endif() + + message("Uncompressing: ${ORTHANC_FRAMEWORK_ARCHIVE}") + + if ("${CMAKE_HOST_SYSTEM_NAME}" STREQUAL "Windows") + # How to silently extract files using 7-zip + # http://superuser.com/questions/331148/7zip-command-line-extract-silently-quietly + + execute_process( + COMMAND ${ORTHANC_FRAMEWORK_7ZIP} e -y ${ORTHANC_FRAMEWORK_ARCHIVE} + WORKING_DIRECTORY ${CMAKE_BINARY_DIR} + RESULT_VARIABLE Failure + OUTPUT_QUIET + ) + + if (Failure) + message(FATAL_ERROR "Error while running the uncompression tool") + endif() + + get_filename_component(TMP_FILENAME "${ORTHANC_FRAMEWORK_ARCHIVE}" NAME) + string(REGEX REPLACE ".gz$" "" TMP_FILENAME2 "${TMP_FILENAME}") + + execute_process( + COMMAND ${ORTHANC_FRAMEWORK_7ZIP} x -y ${TMP_FILENAME2} + WORKING_DIRECTORY ${CMAKE_BINARY_DIR} + RESULT_VARIABLE Failure + OUTPUT_QUIET + ) + + else() + execute_process( + COMMAND sh -c "${ORTHANC_FRAMEWORK_TAR} xfz ${ORTHANC_FRAMEWORK_ARCHIVE}" + WORKING_DIRECTORY ${CMAKE_BINARY_DIR} + RESULT_VARIABLE Failure + ) + endif() + + if (Failure) + message(FATAL_ERROR "Error while running the uncompression tool") + endif() + + if (NOT IS_DIRECTORY "${ORTHANC_ROOT}") + message(FATAL_ERROR "The Orthanc framework was not uncompressed at the proper location. Check the CMake instructions.") + endif() + endif() +endif() + + + +## +## Determine the path to the sources of the Orthanc framework +## + +if (ORTHANC_FRAMEWORK_SOURCE STREQUAL "archive" OR + ORTHANC_FRAMEWORK_SOURCE STREQUAL "hg" OR + ORTHANC_FRAMEWORK_SOURCE STREQUAL "web") + if (NOT DEFINED ORTHANC_ROOT OR + NOT DEFINED ORTHANC_FRAMEWORK_MAJOR OR + NOT DEFINED ORTHANC_FRAMEWORK_MINOR OR + NOT DEFINED ORTHANC_FRAMEWORK_REVISION) + message(FATAL_ERROR "Internal error in the DownloadOrthancFramework.cmake file") + endif() + + unset(ORTHANC_FRAMEWORK_ROOT CACHE) + + if ("${ORTHANC_FRAMEWORK_MAJOR}.${ORTHANC_FRAMEWORK_MINOR}.${ORTHANC_FRAMEWORK_REVISION}" VERSION_LESS "1.7.2") + set(ORTHANC_FRAMEWORK_ROOT "${ORTHANC_ROOT}/Core" CACHE + STRING "Path to the Orthanc framework source directory") + set(ENABLE_PLUGINS_VERSION_SCRIPT OFF) + else() + set(ORTHANC_FRAMEWORK_ROOT "${ORTHANC_ROOT}/OrthancFramework/Sources" CACHE + STRING "Path to the Orthanc framework source directory") + endif() + + unset(ORTHANC_ROOT) +endif() + +if (NOT ORTHANC_FRAMEWORK_SOURCE STREQUAL "system") + if (NOT EXISTS ${ORTHANC_FRAMEWORK_ROOT}/OrthancException.h OR + NOT EXISTS ${ORTHANC_FRAMEWORK_ROOT}/../Resources/CMake/OrthancFrameworkParameters.cmake) + message(FATAL_ERROR "Directory not containing the source code of the Orthanc framework: ${ORTHANC_FRAMEWORK_ROOT}") + endif() +endif() + + + +## +## Case of the Orthanc framework installed as a shared library in a +## GNU/Linux distribution (typically Debian). New in Orthanc 1.7.2. +## + +if (ORTHANC_FRAMEWORK_SOURCE STREQUAL "system") + set(ORTHANC_FRAMEWORK_LIBDIR "" CACHE PATH "") + set(ORTHANC_FRAMEWORK_USE_SHARED ON CACHE BOOL "Whether to use the shared library or the static library") + set(ORTHANC_FRAMEWORK_ADDITIONAL_LIBRARIES "" CACHE STRING "Additional libraries to link against, separated by whitespaces, typically needed if using the static library (a common minimal value is \"boost_filesystem boost_iostreams boost_locale boost_regex boost_thread jsoncpp pugixml uuid\")") + + if (CMAKE_SYSTEM_NAME STREQUAL "Windows" AND + CMAKE_COMPILER_IS_GNUCXX) # MinGW + set(DYNAMIC_MINGW_STDLIB ON) # Disable static linking against libc (to throw exceptions) + set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -static-libstdc++") + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libstdc++") + endif() + + include(CheckIncludeFile) + include(CheckIncludeFileCXX) + include(FindPythonInterp) + include(${CMAKE_CURRENT_LIST_DIR}/Compiler.cmake) + include(${CMAKE_CURRENT_LIST_DIR}/DownloadPackage.cmake) + include(${CMAKE_CURRENT_LIST_DIR}/AutoGeneratedCode.cmake) + set(EMBED_RESOURCES_PYTHON ${CMAKE_CURRENT_LIST_DIR}/EmbedResources.py) + + if (ORTHANC_FRAMEWORK_USE_SHARED) + list(GET CMAKE_FIND_LIBRARY_PREFIXES 0 Prefix) + list(GET CMAKE_FIND_LIBRARY_SUFFIXES 0 Suffix) + else() + list(GET CMAKE_FIND_LIBRARY_PREFIXES 0 Prefix) + list(GET CMAKE_FIND_LIBRARY_SUFFIXES 1 Suffix) + endif() + + # The "OrthancFramework" library must be the first one to be included + if ("${ORTHANC_FRAMEWORK_LIBDIR}" STREQUAL "") + set(ORTHANC_FRAMEWORK_LIBRARIES ${Prefix}OrthancFramework${Suffix}) + else () + set(ORTHANC_FRAMEWORK_LIBRARIES ${ORTHANC_FRAMEWORK_LIBDIR}/${Prefix}OrthancFramework${Suffix}) + endif() + + if (NOT ORTHANC_FRAMEWORK_ADDITIONAL_LIBRARIES STREQUAL "") + # https://stackoverflow.com/a/5272993/881731 + string(REPLACE " " ";" tmp ${ORTHANC_FRAMEWORK_ADDITIONAL_LIBRARIES}) + list(APPEND ORTHANC_FRAMEWORK_LIBRARIES ${tmp}) + endif() + + # Look for the version of the mandatory dependency JsonCpp (cf. JsonCppConfiguration.cmake) + if (CMAKE_CROSSCOMPILING) + set(JSONCPP_INCLUDE_DIR ${ORTHANC_FRAMEWORK_ROOT}/..) + else() + find_path(JSONCPP_INCLUDE_DIR json/reader.h + ${ORTHANC_FRAMEWORK_ROOT}/.. + /usr/include/jsoncpp + /usr/local/include/jsoncpp + ) + endif() + + message("JsonCpp include dir: ${JSONCPP_INCLUDE_DIR}") + include_directories(${JSONCPP_INCLUDE_DIR}) + + CHECK_INCLUDE_FILE_CXX(${JSONCPP_INCLUDE_DIR}/json/reader.h HAVE_JSONCPP_H) + if (NOT HAVE_JSONCPP_H) + message(FATAL_ERROR "Please install the libjsoncpp-dev package") + endif() + + # Look for Orthanc framework shared library + include(CheckCXXSymbolExists) + + if ("${CMAKE_SYSTEM_NAME}" STREQUAL "Windows") + set(ORTHANC_FRAMEWORK_INCLUDE_DIR ${ORTHANC_FRAMEWORK_ROOT}) + else() + find_path(ORTHANC_FRAMEWORK_INCLUDE_DIR OrthancFramework.h + /usr/include/orthanc-framework + /usr/local/include/orthanc-framework + ${ORTHANC_FRAMEWORK_ROOT} + ) + endif() + + if (${ORTHANC_FRAMEWORK_INCLUDE_DIR} STREQUAL "ORTHANC_FRAMEWORK_INCLUDE_DIR-NOTFOUND") + message(FATAL_ERROR "Cannot locate the OrthancFramework.h header") + endif() + + message("Orthanc framework include dir: ${ORTHANC_FRAMEWORK_INCLUDE_DIR}") + include_directories(${ORTHANC_FRAMEWORK_INCLUDE_DIR}) + + if (ORTHANC_FRAMEWORK_USE_SHARED) + set(CMAKE_REQUIRED_INCLUDES "${ORTHANC_FRAMEWORK_INCLUDE_DIR}") + set(CMAKE_REQUIRED_LIBRARIES "${ORTHANC_FRAMEWORK_LIBRARIES}") + + check_cxx_symbol_exists("Orthanc::InitializeFramework" "OrthancFramework.h" HAVE_ORTHANC_FRAMEWORK) + if (NOT HAVE_ORTHANC_FRAMEWORK) + message(FATAL_ERROR "Cannot find the Orthanc framework") + endif() + + unset(CMAKE_REQUIRED_INCLUDES) + unset(CMAKE_REQUIRED_LIBRARIES) + endif() +endif() diff --git a/Resources/Orthanc/CMake/DownloadPackage.cmake b/Resources/Orthanc/CMake/DownloadPackage.cmake new file mode 100644 index 0000000..20ea041 --- /dev/null +++ b/Resources/Orthanc/CMake/DownloadPackage.cmake @@ -0,0 +1,287 @@ +# Orthanc - A Lightweight, RESTful DICOM Store +# Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics +# Department, University Hospital of Liege, Belgium +# Copyright (C) 2017-2023 Osimis S.A., Belgium +# Copyright (C) 2024-2024 Orthanc Team SRL, Belgium +# Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium +# +# This program is free software: you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public License +# as published by the Free Software Foundation, either version 3 of +# the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this program. If not, see +# . + + +macro(GetUrlFilename TargetVariable Url) + string(REGEX REPLACE "^.*/" "" ${TargetVariable} "${Url}") +endmacro() + + +macro(GetUrlExtension TargetVariable Url) + #string(REGEX REPLACE "^.*/[^.]*\\." "" TMP "${Url}") + string(REGEX REPLACE "^.*\\." "" TMP "${Url}") + string(TOLOWER "${TMP}" "${TargetVariable}") +endmacro() + + + +## +## Setup the patch command-line tool +## + +if (NOT ORTHANC_DISABLE_PATCH) + if ("${CMAKE_HOST_SYSTEM_NAME}" STREQUAL "Windows") + set(PATCH_EXECUTABLE ${CMAKE_CURRENT_LIST_DIR}/../ThirdParty/patch/patch.exe) + if (NOT EXISTS ${PATCH_EXECUTABLE}) + message(FATAL_ERROR "Unable to find the patch.exe tool that is shipped with Orthanc") + endif() + + else () + find_program(PATCH_EXECUTABLE patch) + if (${PATCH_EXECUTABLE} MATCHES "PATCH_EXECUTABLE-NOTFOUND") + message(FATAL_ERROR "Please install the 'patch' standard command-line tool") + endif() + endif() +endif() + + + +## +## Check the existence of the required decompression tools +## + +if ("${CMAKE_HOST_SYSTEM_NAME}" STREQUAL "Windows") + find_program(ZIP_EXECUTABLE 7z + PATHS + "$ENV{ProgramFiles}/7-Zip" + "$ENV{ProgramW6432}/7-Zip" + ) + + if (${ZIP_EXECUTABLE} MATCHES "ZIP_EXECUTABLE-NOTFOUND") + message(FATAL_ERROR "Please install the '7-zip' software (http://www.7-zip.org/)") + endif() + +else() + find_program(UNZIP_EXECUTABLE unzip) + if (${UNZIP_EXECUTABLE} MATCHES "UNZIP_EXECUTABLE-NOTFOUND") + message(FATAL_ERROR "Please install the 'unzip' package") + endif() + + find_program(TAR_EXECUTABLE tar) + if (${TAR_EXECUTABLE} MATCHES "TAR_EXECUTABLE-NOTFOUND") + message(FATAL_ERROR "Please install the 'tar' package") + endif() + + find_program(GUNZIP_EXECUTABLE gunzip) + if (${GUNZIP_EXECUTABLE} MATCHES "GUNZIP_EXECUTABLE-NOTFOUND") + message(FATAL_ERROR "Please install the 'gzip' package") + endif() +endif() + + +macro(DownloadFile MD5 Url) + GetUrlFilename(TMP_FILENAME "${Url}") + + set(TMP_PATH "${CMAKE_SOURCE_DIR}/ThirdPartyDownloads/${TMP_FILENAME}") + if (NOT EXISTS "${TMP_PATH}") + message("Downloading ${Url}") + + # This fixes issue 6: "I think cmake shouldn't download the + # packages which are not in the system, it should stop and let + # user know." + # https://code.google.com/p/orthanc/issues/detail?id=6 + if (NOT STATIC_BUILD AND NOT ALLOW_DOWNLOADS) + message(FATAL_ERROR "CMake is not allowed to download from Internet. Please set the ALLOW_DOWNLOADS option to ON") + endif() + + foreach (retry RANGE 1 5) # Retries 5 times + if ("${MD5}" STREQUAL "no-check") + message(WARNING "Not checking the MD5 of: ${Url}") + file(DOWNLOAD "${Url}" "${TMP_PATH}" + SHOW_PROGRESS TIMEOUT 30 INACTIVITY_TIMEOUT 10 + STATUS Failure) + else() + file(DOWNLOAD "${Url}" "${TMP_PATH}" + SHOW_PROGRESS TIMEOUT 30 INACTIVITY_TIMEOUT 10 + EXPECTED_MD5 "${MD5}" STATUS Failure) + endif() + + list(GET Failure 0 Status) + if (Status EQUAL 0) + break() # Successful download + endif() + endforeach() + + if (NOT Status EQUAL 0) + file(REMOVE ${TMP_PATH}) + message(FATAL_ERROR "Cannot download file: ${Url}") + endif() + + else() + message("Using local copy of ${Url}") + + if ("${MD5}" STREQUAL "no-check") + message(WARNING "Not checking the MD5 of: ${Url}") + else() + file(MD5 ${TMP_PATH} ActualMD5) + if (NOT "${ActualMD5}" STREQUAL "${MD5}") + message(FATAL_ERROR "The MD5 hash of a previously download file is invalid: ${TMP_PATH}") + endif() + endif() + endif() +endmacro() + + +macro(DownloadPackage MD5 Url TargetDirectory) + if (NOT IS_DIRECTORY "${TargetDirectory}") + DownloadFile("${MD5}" "${Url}") + + GetUrlExtension(TMP_EXTENSION "${Url}") + #message(${TMP_EXTENSION}) + message("Uncompressing ${TMP_FILENAME}") + + if ("${CMAKE_HOST_SYSTEM_NAME}" STREQUAL "Windows") + # How to silently extract files using 7-zip + # http://superuser.com/questions/331148/7zip-command-line-extract-silently-quietly + + if (("${TMP_EXTENSION}" STREQUAL "gz") OR + ("${TMP_EXTENSION}" STREQUAL "tgz") OR + ("${TMP_EXTENSION}" STREQUAL "xz")) + execute_process( + COMMAND ${ZIP_EXECUTABLE} e -y ${TMP_PATH} + WORKING_DIRECTORY ${CMAKE_BINARY_DIR} + RESULT_VARIABLE Failure + OUTPUT_QUIET + ) + + if (Failure) + message(FATAL_ERROR "Error while running the uncompression tool") + endif() + + if ("${TMP_EXTENSION}" STREQUAL "tgz") + string(REGEX REPLACE ".tgz$" ".tar" TMP_FILENAME2 "${TMP_FILENAME}") + elseif ("${TMP_EXTENSION}" STREQUAL "gz") + string(REGEX REPLACE ".gz$" "" TMP_FILENAME2 "${TMP_FILENAME}") + elseif ("${TMP_EXTENSION}" STREQUAL "xz") + string(REGEX REPLACE ".xz" "" TMP_FILENAME2 "${TMP_FILENAME}") + endif() + + execute_process( + COMMAND ${ZIP_EXECUTABLE} x -y ${TMP_FILENAME2} + WORKING_DIRECTORY ${CMAKE_BINARY_DIR} + RESULT_VARIABLE Failure + OUTPUT_QUIET + ) + elseif ("${TMP_EXTENSION}" STREQUAL "zip") + execute_process( + COMMAND ${ZIP_EXECUTABLE} x -y ${TMP_PATH} + WORKING_DIRECTORY ${CMAKE_BINARY_DIR} + RESULT_VARIABLE Failure + OUTPUT_QUIET + ) + else() + message(FATAL_ERROR "Unsupported package extension: ${TMP_EXTENSION}") + endif() + + else() + if ("${TMP_EXTENSION}" STREQUAL "zip") + execute_process( + COMMAND sh -c "${UNZIP_EXECUTABLE} -q ${TMP_PATH}" + WORKING_DIRECTORY ${CMAKE_BINARY_DIR} + RESULT_VARIABLE Failure + ) + elseif (("${TMP_EXTENSION}" STREQUAL "gz") OR ("${TMP_EXTENSION}" STREQUAL "tgz")) + #message("tar xvfz ${TMP_PATH}") + execute_process( + COMMAND sh -c "${TAR_EXECUTABLE} xfz ${TMP_PATH}" + WORKING_DIRECTORY ${CMAKE_BINARY_DIR} + RESULT_VARIABLE Failure + ) + elseif ("${TMP_EXTENSION}" STREQUAL "bz2") + execute_process( + COMMAND sh -c "${TAR_EXECUTABLE} xfj ${TMP_PATH}" + WORKING_DIRECTORY ${CMAKE_BINARY_DIR} + RESULT_VARIABLE Failure + ) + elseif ("${TMP_EXTENSION}" STREQUAL "xz") + execute_process( + COMMAND sh -c "${TAR_EXECUTABLE} xf ${TMP_PATH}" + WORKING_DIRECTORY ${CMAKE_BINARY_DIR} + RESULT_VARIABLE Failure + ) + else() + message(FATAL_ERROR "Unsupported package extension: ${TMP_EXTENSION}") + endif() + endif() + + if (Failure) + message(FATAL_ERROR "Error while running the uncompression tool") + endif() + + if (NOT IS_DIRECTORY "${TargetDirectory}") + message(FATAL_ERROR "The package was not uncompressed at the proper location. Check the CMake instructions.") + endif() + endif() +endmacro() + + + +macro(DownloadCompressedFile MD5 Url TargetFile) + if (NOT EXISTS "${TargetFile}") + DownloadFile("${MD5}" "${Url}") + + GetUrlExtension(TMP_EXTENSION "${Url}") + #message(${TMP_EXTENSION}) + message("Uncompressing ${TMP_FILENAME}") + + if ("${CMAKE_HOST_SYSTEM_NAME}" STREQUAL "Windows") + # How to silently extract files using 7-zip + # http://superuser.com/questions/331148/7zip-command-line-extract-silently-quietly + + if ("${TMP_EXTENSION}" STREQUAL "gz") + execute_process( + # "-so" writes uncompressed file to stdout + COMMAND ${ZIP_EXECUTABLE} e -so -y ${TMP_PATH} + OUTPUT_FILE "${TargetFile}" + WORKING_DIRECTORY ${CMAKE_BINARY_DIR} + RESULT_VARIABLE Failure + OUTPUT_QUIET + ) + + if (Failure) + message(FATAL_ERROR "Error while running the uncompression tool") + endif() + + else() + message(FATAL_ERROR "Unsupported file extension: ${TMP_EXTENSION}") + endif() + + else() + if ("${TMP_EXTENSION}" STREQUAL "gz") + execute_process( + COMMAND sh -c "${GUNZIP_EXECUTABLE} -c ${TMP_PATH}" + OUTPUT_FILE "${TargetFile}" + RESULT_VARIABLE Failure + ) + else() + message(FATAL_ERROR "Unsupported file extension: ${TMP_EXTENSION}") + endif() + endif() + + if (Failure) + message(FATAL_ERROR "Error while running the uncompression tool") + endif() + + if (NOT EXISTS "${TargetFile}") + message(FATAL_ERROR "The file was not uncompressed at the proper location. Check the CMake instructions.") + endif() + endif() +endmacro() diff --git a/Resources/Orthanc/CMake/EmbedResources.py b/Resources/Orthanc/CMake/EmbedResources.py new file mode 100644 index 0000000..9e033e9 --- /dev/null +++ b/Resources/Orthanc/CMake/EmbedResources.py @@ -0,0 +1,446 @@ +#!/usr/bin/python + +# Orthanc - A Lightweight, RESTful DICOM Store +# Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics +# Department, University Hospital of Liege, Belgium +# Copyright (C) 2017-2023 Osimis S.A., Belgium +# Copyright (C) 2024-2024 Orthanc Team SRL, Belgium +# Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium +# +# This program is free software: you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public License +# as published by the Free Software Foundation, either version 3 of +# the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this program. If not, see +# . + + +import sys +import os +import os.path +import pprint +import re + +UPCASE_CHECK = True +USE_SYSTEM_EXCEPTION = False +EXCEPTION_CLASS = 'OrthancException' +OUT_OF_RANGE_EXCEPTION = '::Orthanc::OrthancException(::Orthanc::ErrorCode_ParameterOutOfRange)' +INEXISTENT_PATH_EXCEPTION = '::Orthanc::OrthancException(::Orthanc::ErrorCode_InexistentItem)' +NAMESPACE = 'Orthanc.EmbeddedResources' +FRAMEWORK_PATH = None + +ARGS = [] +for i in range(len(sys.argv)): + if not sys.argv[i].startswith('--'): + ARGS.append(sys.argv[i]) + elif sys.argv[i].lower() == '--no-upcase-check': + UPCASE_CHECK = False + elif sys.argv[i].lower() == '--system-exception': + USE_SYSTEM_EXCEPTION = True + EXCEPTION_CLASS = '::std::runtime_error' + OUT_OF_RANGE_EXCEPTION = '%s("Parameter out of range")' % EXCEPTION_CLASS + INEXISTENT_PATH_EXCEPTION = '%s("Unknown path in a directory resource")' % EXCEPTION_CLASS + elif sys.argv[i].startswith('--namespace='): + NAMESPACE = sys.argv[i][sys.argv[i].find('=') + 1 : ] + elif sys.argv[i].startswith('--framework-path='): + FRAMEWORK_PATH = sys.argv[i][sys.argv[i].find('=') + 1 : ] + +if len(ARGS) < 2 or len(ARGS) % 2 != 0: + print ('Usage:') + print ('python %s [--no-upcase-check] [--system-exception] [--namespace=] [ ]*' % sys.argv[0]) + exit(-1) + +TARGET_BASE_FILENAME = ARGS[1] +SOURCES = ARGS[2:] + +try: + # Make sure the destination directory exists + os.makedirs(os.path.normpath(os.path.join(TARGET_BASE_FILENAME, '..'))) +except: + pass + + +##################################################################### +## Read each resource file +##################################################################### + +def CheckNoUpcase(s): + global UPCASE_CHECK + if (UPCASE_CHECK and + re.search('[A-Z]', s) != None): + raise Exception("Path in a directory with an upcase letter: %s" % s) + +resources = {} + +counter = 0 +i = 0 +while i < len(SOURCES): + resourceName = SOURCES[i].upper() + pathName = SOURCES[i + 1] + + if not os.path.exists(pathName): + raise Exception("Non existing path: %s" % pathName) + + if resourceName in resources: + raise Exception("Twice the same resource: " + resourceName) + + if os.path.isdir(pathName): + # The resource is a directory: Recursively explore its files + content = {} + for root, dirs, files in os.walk(pathName): + dirs.sort() + files.sort() + base = os.path.relpath(root, pathName) + + # Fix issue #24 (Build fails on OSX when directory has .DS_Store files): + # Ignore folders whose name starts with a dot (".") + if base.find('/.') != -1: + print('Ignoring folder: %s' % root) + continue + + for f in files: + if f.find('~') == -1: # Ignore Emacs backup files + if base == '.': + r = f + else: + r = os.path.join(base, f) + + CheckNoUpcase(r) + r = '/' + r.replace('\\', '/') + if r in content: + raise Exception("Twice the same filename (check case): " + r) + + content[r] = { + 'Filename' : os.path.join(root, f), + 'Index' : counter + } + counter += 1 + + resources[resourceName] = { + 'Type' : 'Directory', + 'Files' : content + } + + elif os.path.isfile(pathName): + resources[resourceName] = { + 'Type' : 'File', + 'Index' : counter, + 'Filename' : pathName + } + counter += 1 + + else: + raise Exception("Not a regular file, nor a directory: " + pathName) + + i += 2 + +#pprint.pprint(resources) + + +##################################################################### +## Write .h header +##################################################################### + +header = open(TARGET_BASE_FILENAME + '.h', 'w') + +header.write(""" +#pragma once + +#include +#include + +#if defined(_MSC_VER) +# pragma warning(disable: 4065) // "Switch statement contains 'default' but no 'case' labels" +#endif + +""") + + +for ns in NAMESPACE.split('.'): + header.write('namespace %s {\n' % ns) + + +header.write(""" + enum FileResourceId + { +""") + +isFirst = True +for name in resources: + if resources[name]['Type'] == 'File': + if isFirst: + isFirst = False + else: + header.write(',\n') + header.write(' %s' % name) + +header.write(""" + }; + + enum DirectoryResourceId + { +""") + +isFirst = True +for name in resources: + if resources[name]['Type'] == 'Directory': + if isFirst: + isFirst = False + else: + header.write(',\n') + header.write(' %s' % name) + +header.write(""" + }; + + const void* GetFileResourceBuffer(FileResourceId id); + size_t GetFileResourceSize(FileResourceId id); + void GetFileResource(std::string& result, FileResourceId id); + + const void* GetDirectoryResourceBuffer(DirectoryResourceId id, const char* path); + size_t GetDirectoryResourceSize(DirectoryResourceId id, const char* path); + void GetDirectoryResource(std::string& result, DirectoryResourceId id, const char* path); + + void ListResources(std::list& result, DirectoryResourceId id); + +""") + + +for ns in NAMESPACE.split('.'): + header.write('}\n') + +header.close() + + + +##################################################################### +## Write the resource content in the .cpp source +##################################################################### + +PYTHON_MAJOR_VERSION = sys.version_info[0] + +def WriteResource(cpp, item): + cpp.write(' static const uint8_t resource%dBuffer[] = {' % item['Index']) + + f = open(item['Filename'], "rb") + content = f.read() + f.close() + + # http://stackoverflow.com/a/1035360 + pos = 0 + buffer = [] # instead of appending a few bytes at a time to the cpp file, + # we first append each chunk to a list, join it and write it + # to the file. We've measured that it was 2-3 times faster in python3. + # Note that speed is important since if generation is too slow, + # cmake might try to compile the EmbeddedResources.cpp file while it is + # still being generated ! + for b in content: + if PYTHON_MAJOR_VERSION == 2: + c = ord(b[0]) + else: + c = b + + if pos > 0: + buffer.append(",") + + if (pos % 16) == 0: + buffer.append("\n") + + if c < 0: + raise Exception("Internal error") + + buffer.append("0x%02x" % c) + pos += 1 + + cpp.write("".join(buffer)) + # Zero-size array are disallowed, so we put one single void character in it. + if pos == 0: + cpp.write(' 0') + + cpp.write(' };\n') + cpp.write(' static const size_t resource%dSize = %d;\n' % (item['Index'], pos)) + + +cpp = open(TARGET_BASE_FILENAME + '.cpp', 'w') + +cpp.write('#include "%s.h"\n' % os.path.basename(TARGET_BASE_FILENAME)) + +if USE_SYSTEM_EXCEPTION: + cpp.write('#include ') +elif FRAMEWORK_PATH != None: + cpp.write('#include "%s/OrthancException.h"' % FRAMEWORK_PATH) +else: + cpp.write('#include ') + +cpp.write(""" +#include +#include + +""") + +for ns in NAMESPACE.split('.'): + cpp.write('namespace %s {\n' % ns) + + +for name in resources: + if resources[name]['Type'] == 'File': + WriteResource(cpp, resources[name]) + else: + for f in resources[name]['Files']: + WriteResource(cpp, resources[name]['Files'][f]) + + + +##################################################################### +## Write the accessors to the file resources in .cpp +##################################################################### + +cpp.write(""" + const void* GetFileResourceBuffer(FileResourceId id) + { + switch (id) + { +""") +for name in resources: + if resources[name]['Type'] == 'File': + cpp.write(' case %s:\n' % name) + cpp.write(' return resource%dBuffer;\n' % resources[name]['Index']) + +cpp.write(""" + default: + throw %s; + } + } + + size_t GetFileResourceSize(FileResourceId id) + { + switch (id) + { +""" % OUT_OF_RANGE_EXCEPTION) + +for name in resources: + if resources[name]['Type'] == 'File': + cpp.write(' case %s:\n' % name) + cpp.write(' return resource%dSize;\n' % resources[name]['Index']) + +cpp.write(""" + default: + throw %s; + } + } +""" % OUT_OF_RANGE_EXCEPTION) + + + +##################################################################### +## Write the accessors to the directory resources in .cpp +##################################################################### + +cpp.write(""" + const void* GetDirectoryResourceBuffer(DirectoryResourceId id, const char* path) + { + switch (id) + { +""") + +for name in resources: + if resources[name]['Type'] == 'Directory': + cpp.write(' case %s:\n' % name) + isFirst = True + for path in resources[name]['Files']: + cpp.write(' if (!strcmp(path, "%s"))\n' % path) + cpp.write(' return resource%dBuffer;\n' % resources[name]['Files'][path]['Index']) + cpp.write(' throw %s;\n\n' % INEXISTENT_PATH_EXCEPTION) + +cpp.write(""" default: + throw %s; + } + } + + size_t GetDirectoryResourceSize(DirectoryResourceId id, const char* path) + { + switch (id) + { +""" % OUT_OF_RANGE_EXCEPTION) + +for name in resources: + if resources[name]['Type'] == 'Directory': + cpp.write(' case %s:\n' % name) + isFirst = True + for path in resources[name]['Files']: + cpp.write(' if (!strcmp(path, "%s"))\n' % path) + cpp.write(' return resource%dSize;\n' % resources[name]['Files'][path]['Index']) + cpp.write(' throw %s;\n\n' % INEXISTENT_PATH_EXCEPTION) + +cpp.write(""" default: + throw %s; + } + } +""" % OUT_OF_RANGE_EXCEPTION) + + + + +##################################################################### +## List the resources in a directory +##################################################################### + +cpp.write(""" + void ListResources(std::list& result, DirectoryResourceId id) + { + result.clear(); + + switch (id) + { +""") + +for name in resources: + if resources[name]['Type'] == 'Directory': + cpp.write(' case %s:\n' % name) + for path in sorted(resources[name]['Files']): + cpp.write(' result.push_back("%s");\n' % path) + cpp.write(' break;\n\n') + +cpp.write(""" default: + throw %s; + } + } +""" % OUT_OF_RANGE_EXCEPTION) + + + + +##################################################################### +## Write the convenience wrappers in .cpp +##################################################################### + +cpp.write(""" + void GetFileResource(std::string& result, FileResourceId id) + { + size_t size = GetFileResourceSize(id); + result.resize(size); + if (size > 0) + memcpy(&result[0], GetFileResourceBuffer(id), size); + } + + void GetDirectoryResource(std::string& result, DirectoryResourceId id, const char* path) + { + size_t size = GetDirectoryResourceSize(id, path); + result.resize(size); + if (size > 0) + memcpy(&result[0], GetDirectoryResourceBuffer(id, path), size); + } +""") + + +for ns in NAMESPACE.split('.'): + cpp.write('}\n') + +cpp.close() diff --git a/Resources/Orthanc/CMake/GoogleTestConfiguration.cmake b/Resources/Orthanc/CMake/GoogleTestConfiguration.cmake new file mode 100644 index 0000000..6013f04 --- /dev/null +++ b/Resources/Orthanc/CMake/GoogleTestConfiguration.cmake @@ -0,0 +1,91 @@ +# Orthanc - A Lightweight, RESTful DICOM Store +# Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics +# Department, University Hospital of Liege, Belgium +# Copyright (C) 2017-2023 Osimis S.A., Belgium +# Copyright (C) 2024-2024 Orthanc Team SRL, Belgium +# Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium +# +# This program is free software: you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public License +# as published by the Free Software Foundation, either version 3 of +# the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this program. If not, see +# . + + +if (USE_GOOGLE_TEST_DEBIAN_PACKAGE) + find_path(GOOGLE_TEST_DEBIAN_SOURCES_DIR + NAMES src/gtest-all.cc + PATHS + ${CROSSTOOL_NG_IMAGE}/usr/src/gtest + ${CROSSTOOL_NG_IMAGE}/usr/src/googletest/googletest + PATH_SUFFIXES src + ) + + find_path(GOOGLE_TEST_DEBIAN_INCLUDE_DIR + NAMES gtest.h + PATHS + ${CROSSTOOL_NG_IMAGE}/usr/include/gtest + ) + + message("Path to the Debian Google Test sources: ${GOOGLE_TEST_DEBIAN_SOURCES_DIR}") + message("Path to the Debian Google Test includes: ${GOOGLE_TEST_DEBIAN_INCLUDE_DIR}") + + set(GOOGLE_TEST_SOURCES + ${GOOGLE_TEST_DEBIAN_SOURCES_DIR}/src/gtest-all.cc + ) + + include_directories(${GOOGLE_TEST_DEBIAN_SOURCES_DIR}) + + if (NOT EXISTS ${GOOGLE_TEST_SOURCES} OR + NOT EXISTS ${GOOGLE_TEST_DEBIAN_INCLUDE_DIR}/gtest.h) + message(FATAL_ERROR "Please install the libgtest-dev package") + endif() + +elseif (STATIC_BUILD OR NOT USE_SYSTEM_GOOGLE_TEST) + set(GOOGLE_TEST_SOURCES_DIR ${CMAKE_BINARY_DIR}/googletest-release-1.8.1) + set(GOOGLE_TEST_URL "https://orthanc.uclouvain.be/downloads/third-party-downloads/gtest-1.8.1.tar.gz") + set(GOOGLE_TEST_MD5 "2e6fbeb6a91310a16efe181886c59596") + + DownloadPackage(${GOOGLE_TEST_MD5} ${GOOGLE_TEST_URL} "${GOOGLE_TEST_SOURCES_DIR}") + + include_directories( + ${GOOGLE_TEST_SOURCES_DIR}/googletest + ${GOOGLE_TEST_SOURCES_DIR}/googletest/include + ${GOOGLE_TEST_SOURCES_DIR} + ) + + set(GOOGLE_TEST_SOURCES + ${GOOGLE_TEST_SOURCES_DIR}/googletest/src/gtest-all.cc + ) + + # https://code.google.com/p/googletest/issues/detail?id=412 + if (MSVC) # VS2012 does not support tuples correctly yet + add_definitions(/D _VARIADIC_MAX=10) + endif() + + if ("${CMAKE_SYSTEM_VERSION}" STREQUAL "LinuxStandardBase") + add_definitions(-DGTEST_HAS_CLONE=0) + endif() + + source_group(ThirdParty\\GoogleTest REGULAR_EXPRESSION ${GOOGLE_TEST_SOURCES_DIR}/.*) + +else() + include(FindGTest) + if (NOT GTEST_FOUND) + message(FATAL_ERROR "Unable to find GoogleTest") + endif() + + include_directories(${GTEST_INCLUDE_DIRS}) + + # The variable GTEST_LIBRARIES contains the shared library of + # Google Test, create an alias for more uniformity + set(GOOGLE_TEST_LIBRARIES ${GTEST_LIBRARIES}) +endif() diff --git a/Resources/Orthanc/Plugins/ExportedSymbolsPlugins.list b/Resources/Orthanc/Plugins/ExportedSymbolsPlugins.list new file mode 100644 index 0000000..f76e0e8 --- /dev/null +++ b/Resources/Orthanc/Plugins/ExportedSymbolsPlugins.list @@ -0,0 +1,7 @@ +# This is the list of the symbols that must be exported by Orthanc +# plugins, if targeting OS X + +_OrthancPluginInitialize +_OrthancPluginFinalize +_OrthancPluginGetName +_OrthancPluginGetVersion diff --git a/Resources/Orthanc/Plugins/OrthancPluginCppWrapper.cpp b/Resources/Orthanc/Plugins/OrthancPluginCppWrapper.cpp new file mode 100644 index 0000000..df40e00 --- /dev/null +++ b/Resources/Orthanc/Plugins/OrthancPluginCppWrapper.cpp @@ -0,0 +1,4117 @@ +/** + * Orthanc - A Lightweight, RESTful DICOM Store + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2023 Osimis S.A., Belgium + * Copyright (C) 2024-2024 Orthanc Team SRL, Belgium + * Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + **/ + + +#include "OrthancPluginCppWrapper.h" + +#include +#include +#include + + +#include +#include +#include + +#if !defined(JSONCPP_VERSION_MAJOR) || !defined(JSONCPP_VERSION_MINOR) +# error Cannot access the version of JsonCpp +#endif + + +/** + * We use deprecated "Json::Reader", "Json::StyledWriter" and + * "Json::FastWriter" if JsonCpp < 1.7.0. This choice is rather + * arbitrary, but if Json >= 1.9.0, gcc generates explicit deprecation + * warnings (clang was warning in earlier versions). For reference, + * these classes seem to have been deprecated since JsonCpp 1.4.0 (on + * February 2015) by the following changeset: + * https://github.com/open-source-parsers/jsoncpp/commit/8df98f6112890d6272734975dd6d70cf8999bb22 + **/ +#if (JSONCPP_VERSION_MAJOR >= 2 || \ + (JSONCPP_VERSION_MAJOR == 1 && JSONCPP_VERSION_MINOR >= 8)) +# define JSONCPP_USE_DEPRECATED 0 +#else +# define JSONCPP_USE_DEPRECATED 1 +#endif + + +#if !ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 2, 0) +static const OrthancPluginErrorCode OrthancPluginErrorCode_NullPointer = OrthancPluginErrorCode_Plugin; +#endif + + +namespace OrthancPlugins +{ + static OrthancPluginContext* globalContext_ = NULL; + static std::string pluginName_; + + + void SetGlobalContext(OrthancPluginContext* context) + { + if (context == NULL) + { + ORTHANC_PLUGINS_THROW_EXCEPTION(NullPointer); + } + else if (globalContext_ == NULL) + { + globalContext_ = context; + } + else + { + ORTHANC_PLUGINS_THROW_EXCEPTION(BadSequenceOfCalls); + } + } + + + void SetGlobalContext(OrthancPluginContext* context, + const char* pluginName) + { + SetGlobalContext(context); + pluginName_ = pluginName; + } + + + void ResetGlobalContext() + { + globalContext_ = NULL; + pluginName_.clear(); + } + + bool HasGlobalContext() + { + return globalContext_ != NULL; + } + + + OrthancPluginContext* GetGlobalContext() + { + if (globalContext_ == NULL) + { + ORTHANC_PLUGINS_THROW_EXCEPTION(BadSequenceOfCalls); + } + else + { + return globalContext_; + } + } + + +#if HAS_ORTHANC_PLUGIN_LOG_MESSAGE == 1 + void LogMessage(OrthancPluginLogLevel level, + const char* file, + uint32_t line, + const std::string& message) + { + if (HasGlobalContext()) + { +#if HAS_ORTHANC_PLUGIN_LOG_MESSAGE == 1 + const char* pluginName = (pluginName_.empty() ? NULL : pluginName_.c_str()); + OrthancPluginLogMessage(GetGlobalContext(), message.c_str(), pluginName, file, line, OrthancPluginLogCategory_Generic, level); +#else + switch (level) + { + case OrthancPluginLogLevel_Error: + OrthancPluginLogError(GetGlobalContext(), message.c_str()); + break; + + case OrthancPluginLogLevel_Warning: + OrthancPluginLogWarning(GetGlobalContext(), message.c_str()); + break; + + case OrthancPluginLogLevel_Info: + OrthancPluginLogInfo(GetGlobalContext(), message.c_str()); + break; + + default: + ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange); + } +#endif + } + } +#endif + + + void LogError(const std::string& message) + { + if (HasGlobalContext()) + { + OrthancPluginLogError(GetGlobalContext(), message.c_str()); + } + } + + void LogWarning(const std::string& message) + { + if (HasGlobalContext()) + { + OrthancPluginLogWarning(GetGlobalContext(), message.c_str()); + } + } + + void LogInfo(const std::string& message) + { + if (HasGlobalContext()) + { + OrthancPluginLogInfo(GetGlobalContext(), message.c_str()); + } + } + + + void MemoryBuffer::Check(OrthancPluginErrorCode code) + { + if (code != OrthancPluginErrorCode_Success) + { + // Prevent using garbage information + buffer_.data = NULL; + buffer_.size = 0; + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(code); + } + } + + + bool MemoryBuffer::CheckHttp(OrthancPluginErrorCode code) + { + if (code != OrthancPluginErrorCode_Success) + { + // Prevent using garbage information + buffer_.data = NULL; + buffer_.size = 0; + } + + if (code == OrthancPluginErrorCode_Success) + { + return true; + } + else if (code == OrthancPluginErrorCode_UnknownResource || + code == OrthancPluginErrorCode_InexistentItem) + { + return false; + } + else + { + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(code); + } + } + + + MemoryBuffer::MemoryBuffer() + { + buffer_.data = NULL; + buffer_.size = 0; + } + + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 7, 0) + MemoryBuffer::MemoryBuffer(const void* buffer, + size_t size) + { + uint32_t s = static_cast(size); + if (static_cast(s) != size) + { + ORTHANC_PLUGINS_THROW_EXCEPTION(NotEnoughMemory); + } + else if (OrthancPluginCreateMemoryBuffer(GetGlobalContext(), &buffer_, s) != + OrthancPluginErrorCode_Success) + { + ORTHANC_PLUGINS_THROW_EXCEPTION(NotEnoughMemory); + } + else + { + memcpy(buffer_.data, buffer, size); + } + } +#endif + + + void MemoryBuffer::Clear() + { + if (buffer_.data != NULL) + { + OrthancPluginFreeMemoryBuffer(GetGlobalContext(), &buffer_); + buffer_.data = NULL; + buffer_.size = 0; + } + } + + + void MemoryBuffer::Assign(OrthancPluginMemoryBuffer& other) + { + Clear(); + + buffer_.data = other.data; + buffer_.size = other.size; + + other.data = NULL; + other.size = 0; + } + + + void MemoryBuffer::Swap(MemoryBuffer& other) + { + std::swap(buffer_.data, other.buffer_.data); + std::swap(buffer_.size, other.buffer_.size); + } + + + OrthancPluginMemoryBuffer MemoryBuffer::Release() + { + OrthancPluginMemoryBuffer result = buffer_; + + buffer_.data = NULL; + buffer_.size = 0; + + return result; + } + + + void MemoryBuffer::ToString(std::string& target) const + { + if (buffer_.size == 0) + { + target.clear(); + } + else + { + target.assign(reinterpret_cast(buffer_.data), buffer_.size); + } + } + + + void MemoryBuffer::ToJson(Json::Value& target) const + { + if (buffer_.data == NULL || + buffer_.size == 0) + { + ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); + } + + if (!ReadJson(target, buffer_.data, buffer_.size)) + { + ORTHANC_PLUGINS_LOG_ERROR("Cannot convert some memory buffer to JSON"); + ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); + } + } + + + bool MemoryBuffer::RestApiGet(const std::string& uri, + bool applyPlugins) + { + Clear(); + + if (applyPlugins) + { + return CheckHttp(OrthancPluginRestApiGetAfterPlugins(GetGlobalContext(), &buffer_, uri.c_str())); + } + else + { + return CheckHttp(OrthancPluginRestApiGet(GetGlobalContext(), &buffer_, uri.c_str())); + } + } + + // helper class to convert std::map of headers to the plugin SDK C structure + class PluginHttpHeaders + { + private: + std::vector headersKeys_; + std::vector headersValues_; + + public: + explicit PluginHttpHeaders(const std::map& httpHeaders) + { + for (std::map::const_iterator + it = httpHeaders.begin(); it != httpHeaders.end(); ++it) + { + headersKeys_.push_back(it->first.c_str()); + headersValues_.push_back(it->second.c_str()); + } + } + + const char* const* GetKeys() + { + return (headersKeys_.empty() ? NULL : &headersKeys_[0]); + } + + const char* const* GetValues() + { + return (headersValues_.empty() ? NULL : &headersValues_[0]); + } + + uint32_t GetSize() + { + return static_cast(headersKeys_.size()); + } + }; + + bool MemoryBuffer::RestApiGet(const std::string& uri, + const std::map& httpHeaders, + bool applyPlugins) + { + Clear(); + + PluginHttpHeaders headers(httpHeaders); + + return CheckHttp(OrthancPluginRestApiGet2( + GetGlobalContext(), &buffer_, uri.c_str(), + headers.GetSize(), + headers.GetKeys(), + headers.GetValues(), applyPlugins)); + } + + bool MemoryBuffer::RestApiPost(const std::string& uri, + const void* body, + size_t bodySize, + bool applyPlugins) + { + Clear(); + + // Cast for compatibility with Orthanc SDK <= 1.5.6 + const char* b = reinterpret_cast(body); + + if (applyPlugins) + { + return CheckHttp(OrthancPluginRestApiPostAfterPlugins(GetGlobalContext(), &buffer_, uri.c_str(), b, bodySize)); + } + else + { + return CheckHttp(OrthancPluginRestApiPost(GetGlobalContext(), &buffer_, uri.c_str(), b, bodySize)); + } + } + +#if HAS_ORTHANC_PLUGIN_GENERIC_CALL_REST_API == 1 + + bool MemoryBuffer::RestApiPost(const std::string& uri, + const void* body, + size_t bodySize, + const std::map& httpHeaders, + bool applyPlugins) + { + MemoryBuffer answerHeaders; + uint16_t httpStatus; + + PluginHttpHeaders headers(httpHeaders); + + return CheckHttp(OrthancPluginCallRestApi(GetGlobalContext(), + &buffer_, + *answerHeaders, + &httpStatus, + OrthancPluginHttpMethod_Post, + uri.c_str(), + headers.GetSize(), headers.GetKeys(), headers.GetValues(), + body, bodySize, + applyPlugins)); + } + + + bool MemoryBuffer::RestApiPost(const std::string& uri, + const Json::Value& body, + const std::map& httpHeaders, + bool applyPlugins) + { + std::string s; + WriteFastJson(s, body); + return RestApiPost(uri, s.c_str(), s.size(), httpHeaders, applyPlugins); + } +#endif + + bool MemoryBuffer::RestApiPut(const std::string& uri, + const void* body, + size_t bodySize, + bool applyPlugins) + { + Clear(); + + // Cast for compatibility with Orthanc SDK <= 1.5.6 + const char* b = reinterpret_cast(body); + + if (applyPlugins) + { + return CheckHttp(OrthancPluginRestApiPutAfterPlugins(GetGlobalContext(), &buffer_, uri.c_str(), b, bodySize)); + } + else + { + return CheckHttp(OrthancPluginRestApiPut(GetGlobalContext(), &buffer_, uri.c_str(), b, bodySize)); + } + } + + + static bool ReadJsonInternal(Json::Value& target, + const void* buffer, + size_t size, + bool collectComments) + { +#if JSONCPP_USE_DEPRECATED == 1 + Json::Reader reader; + return reader.parse(reinterpret_cast(buffer), + reinterpret_cast(buffer) + size, target, collectComments); +#else + Json::CharReaderBuilder builder; + builder.settings_["collectComments"] = collectComments; + + const std::unique_ptr reader(builder.newCharReader()); + assert(reader.get() != NULL); + + JSONCPP_STRING err; + if (reader->parse(reinterpret_cast(buffer), + reinterpret_cast(buffer) + size, &target, &err)) + { + return true; + } + else + { + ORTHANC_PLUGINS_LOG_ERROR("Cannot parse JSON: " + std::string(err)); + return false; + } +#endif + } + + + bool ReadJson(Json::Value& target, + const std::string& source) + { + return ReadJson(target, source.empty() ? NULL : source.c_str(), source.size()); + } + + + bool ReadJson(Json::Value& target, + const void* buffer, + size_t size) + { + return ReadJsonInternal(target, buffer, size, true); + } + + + bool ReadJsonWithoutComments(Json::Value& target, + const std::string& source) + { + return ReadJsonWithoutComments(target, source.empty() ? NULL : source.c_str(), source.size()); + } + + + bool ReadJsonWithoutComments(Json::Value& target, + const void* buffer, + size_t size) + { + return ReadJsonInternal(target, buffer, size, false); + } + + + void WriteFastJson(std::string& target, + const Json::Value& source) + { +#if JSONCPP_USE_DEPRECATED == 1 + Json::FastWriter writer; + target = writer.write(source); +#else + Json::StreamWriterBuilder builder; + builder.settings_["indentation"] = ""; + target = Json::writeString(builder, source); +#endif + } + + + void WriteStyledJson(std::string& target, + const Json::Value& source) + { +#if JSONCPP_USE_DEPRECATED == 1 + Json::StyledWriter writer; + target = writer.write(source); +#else + Json::StreamWriterBuilder builder; + builder.settings_["indentation"] = " "; + target = Json::writeString(builder, source); +#endif + } + + + bool MemoryBuffer::RestApiPost(const std::string& uri, + const Json::Value& body, + bool applyPlugins) + { + std::string s; + WriteFastJson(s, body); + return RestApiPost(uri, s, applyPlugins); + } + + + bool MemoryBuffer::RestApiPut(const std::string& uri, + const Json::Value& body, + bool applyPlugins) + { + std::string s; + WriteFastJson(s, body); + return RestApiPut(uri, s, applyPlugins); + } + + + void MemoryBuffer::CreateDicom(const Json::Value& tags, + OrthancPluginCreateDicomFlags flags) + { + Clear(); + + std::string s; + WriteFastJson(s, tags); + + Check(OrthancPluginCreateDicom(GetGlobalContext(), &buffer_, s.c_str(), NULL, flags)); + } + + void MemoryBuffer::CreateDicom(const Json::Value& tags, + const OrthancImage& pixelData, + OrthancPluginCreateDicomFlags flags) + { + Clear(); + + std::string s; + WriteFastJson(s, tags); + + Check(OrthancPluginCreateDicom(GetGlobalContext(), &buffer_, s.c_str(), pixelData.GetObject(), flags)); + } + + + void MemoryBuffer::ReadFile(const std::string& path) + { + Clear(); + Check(OrthancPluginReadFile(GetGlobalContext(), &buffer_, path.c_str())); + } + + + void MemoryBuffer::GetDicomQuery(const OrthancPluginWorklistQuery* query) + { + Clear(); + Check(OrthancPluginWorklistGetDicomQuery(GetGlobalContext(), &buffer_, query)); + } + + + void OrthancString::Assign(char* str) + { + Clear(); + + if (str != NULL) + { + str_ = str; + } + } + + + void OrthancString::Clear() + { + if (str_ != NULL) + { + OrthancPluginFreeString(GetGlobalContext(), str_); + str_ = NULL; + } + } + + + void OrthancString::ToString(std::string& target) const + { + if (str_ == NULL) + { + target.clear(); + } + else + { + target.assign(str_); + } + } + + + void OrthancString::ToJson(Json::Value& target) const + { + if (str_ == NULL) + { + ORTHANC_PLUGINS_LOG_ERROR("Cannot convert an empty memory buffer to JSON"); + ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); + } + + if (!ReadJson(target, str_)) + { + ORTHANC_PLUGINS_LOG_ERROR("Cannot convert some memory buffer to JSON"); + ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); + } + } + + + void OrthancString::ToJsonWithoutComments(Json::Value& target) const + { + if (str_ == NULL) + { + ORTHANC_PLUGINS_LOG_ERROR("Cannot convert an empty memory buffer to JSON"); + ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); + } + + if (!ReadJsonWithoutComments(target, str_)) + { + ORTHANC_PLUGINS_LOG_ERROR("Cannot convert some memory buffer to JSON"); + ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); + } + } + + + void MemoryBuffer::DicomToJson(Json::Value& target, + OrthancPluginDicomToJsonFormat format, + OrthancPluginDicomToJsonFlags flags, + uint32_t maxStringLength) + { + OrthancString str; + str.Assign(OrthancPluginDicomBufferToJson + (GetGlobalContext(), GetData(), GetSize(), format, flags, maxStringLength)); + str.ToJson(target); + } + + + bool MemoryBuffer::HttpGet(const std::string& url, + const std::string& username, + const std::string& password) + { + Clear(); + return CheckHttp(OrthancPluginHttpGet(GetGlobalContext(), &buffer_, url.c_str(), + username.empty() ? NULL : username.c_str(), + password.empty() ? NULL : password.c_str())); + } + + + bool MemoryBuffer::HttpPost(const std::string& url, + const std::string& body, + const std::string& username, + const std::string& password) + { + Clear(); + + if (body.size() > 0xffffffffu) + { + ORTHANC_PLUGINS_LOG_ERROR("Cannot handle body size > 4GB"); + ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); + } + + return CheckHttp(OrthancPluginHttpPost(GetGlobalContext(), &buffer_, url.c_str(), + body.c_str(), body.size(), + username.empty() ? NULL : username.c_str(), + password.empty() ? NULL : password.c_str())); + } + + + bool MemoryBuffer::HttpPut(const std::string& url, + const std::string& body, + const std::string& username, + const std::string& password) + { + Clear(); + + if (body.size() > 0xffffffffu) + { + ORTHANC_PLUGINS_LOG_ERROR("Cannot handle body size > 4GB"); + ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); + } + + return CheckHttp(OrthancPluginHttpPut(GetGlobalContext(), &buffer_, url.c_str(), + body.empty() ? NULL : body.c_str(), + body.size(), + username.empty() ? NULL : username.c_str(), + password.empty() ? NULL : password.c_str())); + } + + + void MemoryBuffer::GetDicomInstance(const std::string& instanceId) + { + Clear(); + Check(OrthancPluginGetDicomForInstance(GetGlobalContext(), &buffer_, instanceId.c_str())); + } + + + bool HttpDelete(const std::string& url, + const std::string& username, + const std::string& password) + { + OrthancPluginErrorCode error = OrthancPluginHttpDelete + (GetGlobalContext(), url.c_str(), + username.empty() ? NULL : username.c_str(), + password.empty() ? NULL : password.c_str()); + + if (error == OrthancPluginErrorCode_Success) + { + return true; + } + else if (error == OrthancPluginErrorCode_UnknownResource || + error == OrthancPluginErrorCode_InexistentItem) + { + return false; + } + else + { + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(error); + } + } + + void OrthancConfiguration::LoadConfiguration() + { + OrthancString str; + str.Assign(OrthancPluginGetConfiguration(GetGlobalContext())); + + if (str.GetContent() == NULL) + { + ORTHANC_PLUGINS_LOG_ERROR("Cannot access the Orthanc configuration"); + ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); + } + + str.ToJsonWithoutComments(configuration_); + + if (configuration_.type() != Json::objectValue) + { + ORTHANC_PLUGINS_LOG_ERROR("Unable to read the Orthanc configuration"); + ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); + } + } + + + OrthancConfiguration::OrthancConfiguration() + { + LoadConfiguration(); + } + + + OrthancConfiguration::OrthancConfiguration(bool loadConfiguration) + { + if (loadConfiguration) + { + LoadConfiguration(); + } + else + { + configuration_ = Json::objectValue; + } + } + + OrthancConfiguration::OrthancConfiguration(const Json::Value& configuration, const std::string& path) : + configuration_(configuration), + path_(path) + { + } + + + std::string OrthancConfiguration::GetPath(const std::string& key) const + { + if (path_.empty()) + { + return key; + } + else + { + return path_ + "." + key; + } + } + + + bool OrthancConfiguration::IsSection(const std::string& key) const + { + assert(configuration_.type() == Json::objectValue); + + return (configuration_.isMember(key) && + configuration_[key].type() == Json::objectValue); + } + + + void OrthancConfiguration::GetSection(OrthancConfiguration& target, + const std::string& key) const + { + assert(configuration_.type() == Json::objectValue); + + target.path_ = GetPath(key); + + if (!configuration_.isMember(key)) + { + target.configuration_ = Json::objectValue; + } + else + { + if (configuration_[key].type() != Json::objectValue) + { + ORTHANC_PLUGINS_LOG_ERROR("The configuration section \"" + target.path_ + + "\" is not an associative array as expected"); + + ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); + } + + target.configuration_ = configuration_[key]; + } + } + + + bool OrthancConfiguration::LookupStringValue(std::string& target, + const std::string& key) const + { + assert(configuration_.type() == Json::objectValue); + + if (!configuration_.isMember(key)) + { + return false; + } + + if (configuration_[key].type() != Json::stringValue) + { + ORTHANC_PLUGINS_LOG_ERROR("The configuration option \"" + GetPath(key) + + "\" is not a string as expected"); + + ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); + } + + target = configuration_[key].asString(); + return true; + } + + + bool OrthancConfiguration::LookupIntegerValue(int& target, + const std::string& key) const + { + assert(configuration_.type() == Json::objectValue); + + if (!configuration_.isMember(key)) + { + return false; + } + + switch (configuration_[key].type()) + { + case Json::intValue: + target = configuration_[key].asInt(); + return true; + + case Json::uintValue: + target = configuration_[key].asUInt(); + return true; + + default: + ORTHANC_PLUGINS_LOG_ERROR("The configuration option \"" + GetPath(key) + + "\" is not an integer as expected"); + + ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); + } + } + + + bool OrthancConfiguration::LookupUnsignedIntegerValue(unsigned int& target, + const std::string& key) const + { + int tmp; + if (!LookupIntegerValue(tmp, key)) + { + return false; + } + + if (tmp < 0) + { + ORTHANC_PLUGINS_LOG_ERROR("The configuration option \"" + GetPath(key) + + "\" is not a positive integer as expected"); + + ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); + } + else + { + target = static_cast(tmp); + return true; + } + } + + + bool OrthancConfiguration::LookupBooleanValue(bool& target, + const std::string& key) const + { + assert(configuration_.type() == Json::objectValue); + + if (!configuration_.isMember(key)) + { + return false; + } + + if (configuration_[key].type() != Json::booleanValue) + { + ORTHANC_PLUGINS_LOG_ERROR("The configuration option \"" + GetPath(key) + + "\" is not a Boolean as expected"); + + ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); + } + + target = configuration_[key].asBool(); + return true; + } + + + bool OrthancConfiguration::LookupFloatValue(float& target, + const std::string& key) const + { + assert(configuration_.type() == Json::objectValue); + + if (!configuration_.isMember(key)) + { + return false; + } + + switch (configuration_[key].type()) + { + case Json::realValue: + target = configuration_[key].asFloat(); + return true; + + case Json::intValue: + target = static_cast(configuration_[key].asInt()); + return true; + + case Json::uintValue: + target = static_cast(configuration_[key].asUInt()); + return true; + + default: + ORTHANC_PLUGINS_LOG_ERROR("The configuration option \"" + GetPath(key) + + "\" is not an integer as expected"); + + ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); + } + } + + + bool OrthancConfiguration::LookupListOfStrings(std::list& target, + const std::string& key, + bool allowSingleString) const + { + assert(configuration_.type() == Json::objectValue); + + target.clear(); + + if (!configuration_.isMember(key)) + { + return false; + } + + switch (configuration_[key].type()) + { + case Json::arrayValue: + { + bool ok = true; + + for (Json::Value::ArrayIndex i = 0; ok && i < configuration_[key].size(); i++) + { + if (configuration_[key][i].type() == Json::stringValue) + { + target.push_back(configuration_[key][i].asString()); + } + else + { + ok = false; + } + } + + if (ok) + { + return true; + } + + break; + } + + case Json::stringValue: + if (allowSingleString) + { + target.push_back(configuration_[key].asString()); + return true; + } + + break; + + default: + break; + } + + ORTHANC_PLUGINS_LOG_ERROR("The configuration option \"" + GetPath(key) + + "\" is not a list of strings as expected"); + + ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); + } + + + bool OrthancConfiguration::LookupSetOfStrings(std::set& target, + const std::string& key, + bool allowSingleString) const + { + std::list lst; + + if (LookupListOfStrings(lst, key, allowSingleString)) + { + target.clear(); + + for (std::list::const_iterator + it = lst.begin(); it != lst.end(); ++it) + { + target.insert(*it); + } + + return true; + } + else + { + return false; + } + } + + + std::string OrthancConfiguration::GetStringValue(const std::string& key, + const std::string& defaultValue) const + { + std::string tmp; + if (LookupStringValue(tmp, key)) + { + return tmp; + } + else + { + return defaultValue; + } + } + + + int OrthancConfiguration::GetIntegerValue(const std::string& key, + int defaultValue) const + { + int tmp; + if (LookupIntegerValue(tmp, key)) + { + return tmp; + } + else + { + return defaultValue; + } + } + + + unsigned int OrthancConfiguration::GetUnsignedIntegerValue(const std::string& key, + unsigned int defaultValue) const + { + unsigned int tmp; + if (LookupUnsignedIntegerValue(tmp, key)) + { + return tmp; + } + else + { + return defaultValue; + } + } + + + bool OrthancConfiguration::GetBooleanValue(const std::string& key, + bool defaultValue) const + { + bool tmp; + if (LookupBooleanValue(tmp, key)) + { + return tmp; + } + else + { + return defaultValue; + } + } + + + float OrthancConfiguration::GetFloatValue(const std::string& key, + float defaultValue) const + { + float tmp; + if (LookupFloatValue(tmp, key)) + { + return tmp; + } + else + { + return defaultValue; + } + } + + + void OrthancConfiguration::GetDictionary(std::map& target, + const std::string& key) const + { + assert(configuration_.type() == Json::objectValue); + + target.clear(); + + if (!configuration_.isMember(key)) + { + return; + } + + if (configuration_[key].type() != Json::objectValue) + { + ORTHANC_PLUGINS_LOG_ERROR("The configuration option \"" + GetPath(key) + + "\" is not an object as expected"); + + ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); + } + + Json::Value::Members members = configuration_[key].getMemberNames(); + + for (size_t i = 0; i < members.size(); i++) + { + const Json::Value& value = configuration_[key][members[i]]; + + if (value.type() == Json::stringValue) + { + target[members[i]] = value.asString(); + } + else + { + ORTHANC_PLUGINS_LOG_ERROR("The configuration option \"" + GetPath(key) + + "\" is not a dictionary mapping strings to strings"); + + ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); + } + } + } + + + void OrthancImage::Clear() + { + if (image_ != NULL) + { + OrthancPluginFreeImage(GetGlobalContext(), image_); + image_ = NULL; + } + } + + + void OrthancImage::CheckImageAvailable() const + { + if (image_ == NULL) + { + ORTHANC_PLUGINS_LOG_ERROR("Trying to access a NULL image"); + ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange); + } + } + + + OrthancImage::OrthancImage() : + image_(NULL) + { + } + + + OrthancImage::OrthancImage(OrthancPluginImage* image) : + image_(image) + { + } + + + OrthancImage::OrthancImage(OrthancPluginPixelFormat format, + uint32_t width, + uint32_t height) + { + image_ = OrthancPluginCreateImage(GetGlobalContext(), format, width, height); + + if (image_ == NULL) + { + ORTHANC_PLUGINS_LOG_ERROR("Cannot create an image"); + ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); + } + } + + + OrthancImage::OrthancImage(OrthancPluginPixelFormat format, + uint32_t width, + uint32_t height, + uint32_t pitch, + void* buffer) + { + image_ = OrthancPluginCreateImageAccessor + (GetGlobalContext(), format, width, height, pitch, buffer); + + if (image_ == NULL) + { + ORTHANC_PLUGINS_LOG_ERROR("Cannot create an image accessor"); + ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); + } + } + + void OrthancImage::UncompressPngImage(const void* data, + size_t size) + { + Clear(); + + image_ = OrthancPluginUncompressImage(GetGlobalContext(), data, size, OrthancPluginImageFormat_Png); + + if (image_ == NULL) + { + ORTHANC_PLUGINS_LOG_ERROR("Cannot uncompress a PNG image"); + ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange); + } + } + + + void OrthancImage::UncompressJpegImage(const void* data, + size_t size) + { + Clear(); + image_ = OrthancPluginUncompressImage(GetGlobalContext(), data, size, OrthancPluginImageFormat_Jpeg); + if (image_ == NULL) + { + ORTHANC_PLUGINS_LOG_ERROR("Cannot uncompress a JPEG image"); + ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange); + } + } + + + void OrthancImage::DecodeDicomImage(const void* data, + size_t size, + unsigned int frame) + { + Clear(); + image_ = OrthancPluginDecodeDicomImage(GetGlobalContext(), data, size, frame); + if (image_ == NULL) + { + ORTHANC_PLUGINS_LOG_ERROR("Cannot uncompress a DICOM image"); + ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange); + } + } + + + OrthancPluginPixelFormat OrthancImage::GetPixelFormat() const + { + CheckImageAvailable(); + return OrthancPluginGetImagePixelFormat(GetGlobalContext(), image_); + } + + + unsigned int OrthancImage::GetWidth() const + { + CheckImageAvailable(); + return OrthancPluginGetImageWidth(GetGlobalContext(), image_); + } + + + unsigned int OrthancImage::GetHeight() const + { + CheckImageAvailable(); + return OrthancPluginGetImageHeight(GetGlobalContext(), image_); + } + + + unsigned int OrthancImage::GetPitch() const + { + CheckImageAvailable(); + return OrthancPluginGetImagePitch(GetGlobalContext(), image_); + } + + + void* OrthancImage::GetBuffer() const + { + CheckImageAvailable(); + return OrthancPluginGetImageBuffer(GetGlobalContext(), image_); + } + + + void OrthancImage::CompressPngImage(MemoryBuffer& target) const + { + CheckImageAvailable(); + + OrthancPlugins::MemoryBuffer answer; + OrthancPluginCompressPngImage(GetGlobalContext(), *answer, GetPixelFormat(), + GetWidth(), GetHeight(), GetPitch(), GetBuffer()); + + target.Swap(answer); + } + + + void OrthancImage::CompressJpegImage(MemoryBuffer& target, + uint8_t quality) const + { + CheckImageAvailable(); + + OrthancPlugins::MemoryBuffer answer; + OrthancPluginCompressJpegImage(GetGlobalContext(), *answer, GetPixelFormat(), + GetWidth(), GetHeight(), GetPitch(), GetBuffer(), quality); + + target.Swap(answer); + } + + + void OrthancImage::AnswerPngImage(OrthancPluginRestOutput* output) const + { + CheckImageAvailable(); + OrthancPluginCompressAndAnswerPngImage(GetGlobalContext(), output, GetPixelFormat(), + GetWidth(), GetHeight(), GetPitch(), GetBuffer()); + } + + + void OrthancImage::AnswerJpegImage(OrthancPluginRestOutput* output, + uint8_t quality) const + { + CheckImageAvailable(); + OrthancPluginCompressAndAnswerJpegImage(GetGlobalContext(), output, GetPixelFormat(), + GetWidth(), GetHeight(), GetPitch(), GetBuffer(), quality); + } + + + OrthancPluginImage* OrthancImage::Release() + { + CheckImageAvailable(); + OrthancPluginImage* tmp = image_; + image_ = NULL; + return tmp; + } + + +#if HAS_ORTHANC_PLUGIN_FIND_MATCHER == 1 + FindMatcher::FindMatcher(const OrthancPluginWorklistQuery* worklist) : + matcher_(NULL), + worklist_(worklist) + { + if (worklist_ == NULL) + { + ORTHANC_PLUGINS_THROW_EXCEPTION(ParameterOutOfRange); + } + } + + + void FindMatcher::SetupDicom(const void* query, + uint32_t size) + { + worklist_ = NULL; + + matcher_ = OrthancPluginCreateFindMatcher(GetGlobalContext(), query, size); + if (matcher_ == NULL) + { + ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); + } + } + + + FindMatcher::~FindMatcher() + { + // The "worklist_" field + + if (matcher_ != NULL) + { + OrthancPluginFreeFindMatcher(GetGlobalContext(), matcher_); + } + } + + + + bool FindMatcher::IsMatch(const void* dicom, + uint32_t size) const + { + int32_t result; + + if (matcher_ != NULL) + { + result = OrthancPluginFindMatcherIsMatch(GetGlobalContext(), matcher_, dicom, size); + } + else if (worklist_ != NULL) + { + result = OrthancPluginWorklistIsMatch(GetGlobalContext(), worklist_, dicom, size); + } + else + { + ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); + } + + if (result == 0) + { + return false; + } + else if (result == 1) + { + return true; + } + else + { + ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); + } + } + +#endif /* HAS_ORTHANC_PLUGIN_FIND_MATCHER == 1 */ + + void AnswerJson(const Json::Value& value, + OrthancPluginRestOutput* output) + { + std::string bodyString; + WriteStyledJson(bodyString, value); + OrthancPluginAnswerBuffer(GetGlobalContext(), output, bodyString.c_str(), bodyString.size(), "application/json"); + } + + void AnswerString(const std::string& answer, + const char* mimeType, + OrthancPluginRestOutput* output) + { + OrthancPluginAnswerBuffer(GetGlobalContext(), output, answer.c_str(), answer.size(), mimeType); + } + + void AnswerHttpError(uint16_t httpError, OrthancPluginRestOutput *output) + { + OrthancPluginSendHttpStatusCode(GetGlobalContext(), output, httpError); + } + + void AnswerMethodNotAllowed(OrthancPluginRestOutput *output, const char* allowedMethods) + { + OrthancPluginSendMethodNotAllowed(GetGlobalContext(), output, allowedMethods); + } + + bool RestApiGetString(std::string& result, + const std::string& uri, + bool applyPlugins) + { + MemoryBuffer answer; + if (!answer.RestApiGet(uri, applyPlugins)) + { + return false; + } + else + { + answer.ToString(result); + return true; + } + } + + bool RestApiGetString(std::string& result, + const std::string& uri, + const std::map& httpHeaders, + bool applyPlugins) + { + MemoryBuffer answer; + if (!answer.RestApiGet(uri, httpHeaders, applyPlugins)) + { + return false; + } + else + { + answer.ToString(result); + return true; + } + } + + + bool RestApiGet(Json::Value& result, + const std::string& uri, + const std::map& httpHeaders, + bool applyPlugins) + { + MemoryBuffer answer; + + if (!answer.RestApiGet(uri, httpHeaders, applyPlugins)) + { + return false; + } + else + { + if (!answer.IsEmpty()) + { + answer.ToJson(result); + } + return true; + } + } + + + bool RestApiGet(Json::Value& result, + const std::string& uri, + bool applyPlugins) + { + MemoryBuffer answer; + + if (!answer.RestApiGet(uri, applyPlugins)) + { + return false; + } + else + { + if (!answer.IsEmpty()) + { + answer.ToJson(result); + } + return true; + } + } + + + bool RestApiPost(std::string& result, + const std::string& uri, + const void* body, + size_t bodySize, + bool applyPlugins) + { + MemoryBuffer answer; + + if (!answer.RestApiPost(uri, body, bodySize, applyPlugins)) + { + return false; + } + else + { + if (!answer.IsEmpty()) + { + result.assign(answer.GetData(), answer.GetSize()); + } + return true; + } + } + + + bool RestApiPost(Json::Value& result, + const std::string& uri, + const void* body, + size_t bodySize, + bool applyPlugins) + { + MemoryBuffer answer; + + if (!answer.RestApiPost(uri, body, bodySize, applyPlugins)) + { + return false; + } + else + { + if (!answer.IsEmpty()) + { + answer.ToJson(result); + } + return true; + } + } + +#if HAS_ORTHANC_PLUGIN_GENERIC_CALL_REST_API == 1 + bool RestApiPost(Json::Value& result, + const std::string& uri, + const Json::Value& body, + const std::map& httpHeaders, + bool applyPlugins) + { + MemoryBuffer answer; + + if (!answer.RestApiPost(uri, body, httpHeaders, applyPlugins)) + { + return false; + } + else + { + if (!answer.IsEmpty()) + { + answer.ToJson(result); + } + return true; + } + } +#endif + + + bool RestApiPost(Json::Value& result, + const std::string& uri, + const Json::Value& body, + bool applyPlugins) + { + std::string s; + WriteFastJson(s, body); + return RestApiPost(result, uri, s, applyPlugins); + } + + + bool RestApiPut(Json::Value& result, + const std::string& uri, + const void* body, + size_t bodySize, + bool applyPlugins) + { + MemoryBuffer answer; + + if (!answer.RestApiPut(uri, body, bodySize, applyPlugins)) + { + return false; + } + else + { + if (!answer.IsEmpty()) // i.e, on a PUT to metadata/..., orthanc returns an empty response + { + answer.ToJson(result); + } + return true; + } + } + + + bool RestApiPut(Json::Value& result, + const std::string& uri, + const Json::Value& body, + bool applyPlugins) + { + std::string s; + WriteFastJson(s, body); + return RestApiPut(result, uri, s, applyPlugins); + } + + + bool RestApiDelete(const std::string& uri, + bool applyPlugins) + { + OrthancPluginErrorCode error; + + if (applyPlugins) + { + error = OrthancPluginRestApiDeleteAfterPlugins(GetGlobalContext(), uri.c_str()); + } + else + { + error = OrthancPluginRestApiDelete(GetGlobalContext(), uri.c_str()); + } + + if (error == OrthancPluginErrorCode_Success) + { + return true; + } + else if (error == OrthancPluginErrorCode_UnknownResource || + error == OrthancPluginErrorCode_InexistentItem) + { + return false; + } + else + { + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(error); + } + } + + + void ReportMinimalOrthancVersion(unsigned int major, + unsigned int minor, + unsigned int revision) + { + ORTHANC_PLUGINS_LOG_ERROR("Your version of the Orthanc core (" + + std::string(GetGlobalContext()->orthancVersion) + + ") is too old to run this plugin (version " + + boost::lexical_cast(major) + "." + + boost::lexical_cast(minor) + "." + + boost::lexical_cast(revision) + + " is required)"); + } + + bool CheckMinimalVersion(const char* version, + unsigned int major, + unsigned int minor, + unsigned int revision) + { + if (!strcmp(version, "mainline")) + { + // Assume compatibility with the mainline + return true; + } + +#ifdef _MSC_VER +#define ORTHANC_SCANF sscanf_s +#else +#define ORTHANC_SCANF sscanf +#endif + + // Parse the version + int aa, bb, cc = 0; + if ((ORTHANC_SCANF(version, "%4d.%4d.%4d", &aa, &bb, &cc) != 3 && + ORTHANC_SCANF(version, "%4d.%4d", &aa, &bb) != 2) || + aa < 0 || + bb < 0 || + cc < 0) + { + return false; + } + + unsigned int a = static_cast(aa); + unsigned int b = static_cast(bb); + unsigned int c = static_cast(cc); + + // Check the major version number + + if (a > major) + { + return true; + } + + if (a < major) + { + return false; + } + + // Check the minor version number + assert(a == major); + + if (b > minor) + { + return true; + } + + if (b < minor) + { + return false; + } + + // Check the patch level version number + assert(a == major && b == minor); + + if (c >= revision) + { + return true; + } + else + { + return false; + } + } + + + bool CheckMinimalOrthancVersion(unsigned int major, + unsigned int minor, + unsigned int revision) + { + if (!HasGlobalContext()) + { + ORTHANC_PLUGINS_LOG_ERROR("Bad Orthanc context in the plugin"); + return false; + } + + return CheckMinimalVersion(GetGlobalContext()->orthancVersion, + major, minor, revision); + } + + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 5, 0) + const char* AutodetectMimeType(const std::string& path) + { + const char* mime = OrthancPluginAutodetectMimeType(GetGlobalContext(), path.c_str()); + + if (mime == NULL) + { + // Should never happen, just for safety + return "application/octet-stream"; + } + else + { + return mime; + } + } +#endif + + +#if HAS_ORTHANC_PLUGIN_PEERS == 1 + size_t OrthancPeers::GetPeerIndex(const std::string& name) const + { + size_t index; + if (LookupName(index, name)) + { + return index; + } + else + { + ORTHANC_PLUGINS_LOG_ERROR("Inexistent peer: " + name); + ORTHANC_PLUGINS_THROW_EXCEPTION(UnknownResource); + } + } + + + OrthancPeers::OrthancPeers() : + peers_(NULL), + timeout_(0) + { + peers_ = OrthancPluginGetPeers(GetGlobalContext()); + + if (peers_ == NULL) + { + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_Plugin); + } + + uint32_t count = OrthancPluginGetPeersCount(GetGlobalContext(), peers_); + + for (uint32_t i = 0; i < count; i++) + { + const char* name = OrthancPluginGetPeerName(GetGlobalContext(), peers_, i); + if (name == NULL) + { + OrthancPluginFreePeers(GetGlobalContext(), peers_); + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_Plugin); + } + + index_[name] = i; + } + } + + + OrthancPeers::~OrthancPeers() + { + if (peers_ != NULL) + { + OrthancPluginFreePeers(GetGlobalContext(), peers_); + } + } + + + bool OrthancPeers::LookupName(size_t& target, + const std::string& name) const + { + Index::const_iterator found = index_.find(name); + + if (found == index_.end()) + { + return false; + } + else + { + target = found->second; + return true; + } + } + + + std::string OrthancPeers::GetPeerName(size_t index) const + { + if (index >= index_.size()) + { + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange); + } + else + { + const char* s = OrthancPluginGetPeerName(GetGlobalContext(), peers_, static_cast(index)); + if (s == NULL) + { + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_Plugin); + } + else + { + return s; + } + } + } + + + std::string OrthancPeers::GetPeerUrl(size_t index) const + { + if (index >= index_.size()) + { + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange); + } + else + { + const char* s = OrthancPluginGetPeerUrl(GetGlobalContext(), peers_, static_cast(index)); + if (s == NULL) + { + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_Plugin); + } + else + { + return s; + } + } + } + + + std::string OrthancPeers::GetPeerUrl(const std::string& name) const + { + return GetPeerUrl(GetPeerIndex(name)); + } + + + bool OrthancPeers::LookupUserProperty(std::string& value, + size_t index, + const std::string& key) const + { + if (index >= index_.size()) + { + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange); + } + else + { + const char* s = OrthancPluginGetPeerUserProperty(GetGlobalContext(), peers_, static_cast(index), key.c_str()); + if (s == NULL) + { + return false; + } + else + { + value.assign(s); + return true; + } + } + } + + + bool OrthancPeers::LookupUserProperty(std::string& value, + const std::string& peer, + const std::string& key) const + { + return LookupUserProperty(value, GetPeerIndex(peer), key); + } + + + bool OrthancPeers::DoGet(MemoryBuffer& target, + size_t index, + const std::string& uri, + const std::map& headers) const + { + if (index >= index_.size()) + { + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange); + } + + OrthancPlugins::MemoryBuffer answer; + uint16_t status; + PluginHttpHeaders pluginHeaders(headers); + + OrthancPluginErrorCode code = OrthancPluginCallPeerApi + (GetGlobalContext(), *answer, NULL, &status, peers_, + static_cast(index), OrthancPluginHttpMethod_Get, uri.c_str(), + pluginHeaders.GetSize(), pluginHeaders.GetKeys(), pluginHeaders.GetValues(), NULL, 0, timeout_); + + if (code == OrthancPluginErrorCode_Success) + { + target.Swap(answer); + return (status == 200); + } + else + { + return false; + } + } + + + bool OrthancPeers::DoGet(MemoryBuffer& target, + const std::string& name, + const std::string& uri, + const std::map& headers) const + { + size_t index; + return (LookupName(index, name) && + DoGet(target, index, uri, headers)); + } + + + bool OrthancPeers::DoGet(Json::Value& target, + size_t index, + const std::string& uri, + const std::map& headers) const + { + MemoryBuffer buffer; + + if (DoGet(buffer, index, uri, headers)) + { + buffer.ToJson(target); + return true; + } + else + { + return false; + } + } + + + bool OrthancPeers::DoGet(Json::Value& target, + const std::string& name, + const std::string& uri, + const std::map& headers) const + { + MemoryBuffer buffer; + + if (DoGet(buffer, name, uri, headers)) + { + buffer.ToJson(target); + return true; + } + else + { + return false; + } + } + + + bool OrthancPeers::DoPost(MemoryBuffer& target, + const std::string& name, + const std::string& uri, + const std::string& body, + const std::map& headers) const + { + size_t index; + return (LookupName(index, name) && + DoPost(target, index, uri, body, headers)); + } + + + bool OrthancPeers::DoPost(Json::Value& target, + size_t index, + const std::string& uri, + const std::string& body, + const std::map& headers) const + { + MemoryBuffer buffer; + + if (DoPost(buffer, index, uri, body, headers)) + { + buffer.ToJson(target); + return true; + } + else + { + return false; + } + } + + + bool OrthancPeers::DoPost(Json::Value& target, + const std::string& name, + const std::string& uri, + const std::string& body, + const std::map& headers) const + { + MemoryBuffer buffer; + + if (DoPost(buffer, name, uri, body, headers)) + { + buffer.ToJson(target); + return true; + } + else + { + return false; + } + } + + + bool OrthancPeers::DoPost(MemoryBuffer& target, + size_t index, + const std::string& uri, + const std::string& body, + const std::map& headers) const + { + if (index >= index_.size()) + { + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange); + } + + if (body.size() > 0xffffffffu) + { + ORTHANC_PLUGINS_LOG_ERROR("Cannot handle body size > 4GB"); + ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); + } + + OrthancPlugins::MemoryBuffer answer; + uint16_t status; + PluginHttpHeaders pluginHeaders(headers); + + OrthancPluginErrorCode code = OrthancPluginCallPeerApi + (GetGlobalContext(), *answer, NULL, &status, peers_, + static_cast(index), OrthancPluginHttpMethod_Post, uri.c_str(), + pluginHeaders.GetSize(), pluginHeaders.GetKeys(), pluginHeaders.GetValues(), body.empty() ? NULL : body.c_str(), body.size(), timeout_); + + if (code == OrthancPluginErrorCode_Success) + { + target.Swap(answer); + return (status == 200); + } + else + { + return false; + } + } + + + bool OrthancPeers::DoPut(size_t index, + const std::string& uri, + const std::string& body, + const std::map& headers) const + { + if (index >= index_.size()) + { + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange); + } + + if (body.size() > 0xffffffffu) + { + ORTHANC_PLUGINS_LOG_ERROR("Cannot handle body size > 4GB"); + ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); + } + + OrthancPlugins::MemoryBuffer answer; + uint16_t status; + PluginHttpHeaders pluginHeaders(headers); + + OrthancPluginErrorCode code = OrthancPluginCallPeerApi + (GetGlobalContext(), *answer, NULL, &status, peers_, + static_cast(index), OrthancPluginHttpMethod_Put, uri.c_str(), + pluginHeaders.GetSize(), pluginHeaders.GetKeys(), pluginHeaders.GetValues(), body.empty() ? NULL : body.c_str(), body.size(), timeout_); + + if (code == OrthancPluginErrorCode_Success) + { + return (status == 200); + } + else + { + return false; + } + } + + + bool OrthancPeers::DoPut(const std::string& name, + const std::string& uri, + const std::string& body, + const std::map& headers) const + { + size_t index; + return (LookupName(index, name) && + DoPut(index, uri, body, headers)); + } + + + bool OrthancPeers::DoDelete(size_t index, + const std::string& uri, + const std::map& headers) const + { + if (index >= index_.size()) + { + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange); + } + + OrthancPlugins::MemoryBuffer answer; + uint16_t status; + PluginHttpHeaders pluginHeaders(headers); + + OrthancPluginErrorCode code = OrthancPluginCallPeerApi + (GetGlobalContext(), *answer, NULL, &status, peers_, + static_cast(index), OrthancPluginHttpMethod_Delete, uri.c_str(), + pluginHeaders.GetSize(), pluginHeaders.GetKeys(), pluginHeaders.GetValues(), NULL, 0, timeout_); + + if (code == OrthancPluginErrorCode_Success) + { + return (status == 200); + } + else + { + return false; + } + } + + + bool OrthancPeers::DoDelete(const std::string& name, + const std::string& uri, + const std::map& headers) const + { + size_t index; + return (LookupName(index, name) && + DoDelete(index, uri, headers)); + } +#endif + + + + + + /****************************************************************** + ** JOBS + ******************************************************************/ + +#if HAS_ORTHANC_PLUGIN_JOB == 1 + void OrthancJob::CallbackFinalize(void* job) + { + if (job != NULL) + { + delete reinterpret_cast(job); + } + } + + + float OrthancJob::CallbackGetProgress(void* job) + { + assert(job != NULL); + + try + { + return reinterpret_cast(job)->progress_; + } + catch (...) + { + return 0; + } + } + + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 11, 3) + static OrthancPluginErrorCode CopyStringToMemoryBuffer(OrthancPluginMemoryBuffer* target, + const std::string& source) + { + if (OrthancPluginCreateMemoryBuffer(globalContext_, target, source.size()) != OrthancPluginErrorCode_Success) + { + return OrthancPluginErrorCode_NotEnoughMemory; + } + else + { + if (!source.empty()) + { + memcpy(target->data, source.c_str(), source.size()); + } + + return OrthancPluginErrorCode_Success; + } + } +#endif + + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 11, 3) + OrthancPluginErrorCode OrthancJob::CallbackGetContent(OrthancPluginMemoryBuffer* target, + void* job) + { + assert(job != NULL); + OrthancJob& that = *reinterpret_cast(job); + return CopyStringToMemoryBuffer(target, that.content_); + } +#else + const char* OrthancJob::CallbackGetContent(void* job) + { + assert(job != NULL); + + try + { + return reinterpret_cast(job)->content_.c_str(); + } + catch (...) + { + return 0; + } + } +#endif + + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 11, 3) + int32_t OrthancJob::CallbackGetSerialized(OrthancPluginMemoryBuffer* target, + void* job) + { + assert(job != NULL); + OrthancJob& that = *reinterpret_cast(job); + + if (that.hasSerialized_) + { + if (CopyStringToMemoryBuffer(target, that.serialized_) == OrthancPluginErrorCode_Success) + { + return 1; + } + else + { + return -1; + } + } + else + { + return 0; + } + } +#else + const char* OrthancJob::CallbackGetSerialized(void* job) + { + assert(job != NULL); + + try + { + const OrthancJob& tmp = *reinterpret_cast(job); + + if (tmp.hasSerialized_) + { + return tmp.serialized_.c_str(); + } + else + { + return NULL; + } + } + catch (...) + { + return 0; + } + } +#endif + + + OrthancPluginJobStepStatus OrthancJob::CallbackStep(void* job) + { + assert(job != NULL); + + try + { + return reinterpret_cast(job)->Step(); + } + catch (ORTHANC_PLUGINS_EXCEPTION_CLASS&) + { + return OrthancPluginJobStepStatus_Failure; + } + catch (...) + { + return OrthancPluginJobStepStatus_Failure; + } + } + + + OrthancPluginErrorCode OrthancJob::CallbackStop(void* job, + OrthancPluginJobStopReason reason) + { + assert(job != NULL); + + try + { + reinterpret_cast(job)->Stop(reason); + return OrthancPluginErrorCode_Success; + } + catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) + { + return static_cast(e.GetErrorCode()); + } + catch (...) + { + return OrthancPluginErrorCode_Plugin; + } + } + + + OrthancPluginErrorCode OrthancJob::CallbackReset(void* job) + { + assert(job != NULL); + + try + { + reinterpret_cast(job)->Reset(); + return OrthancPluginErrorCode_Success; + } + catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) + { + return static_cast(e.GetErrorCode()); + } + catch (...) + { + return OrthancPluginErrorCode_Plugin; + } + } + + + void OrthancJob::ClearContent() + { + Json::Value empty = Json::objectValue; + UpdateContent(empty); + } + + + void OrthancJob::UpdateContent(const Json::Value& content) + { + if (content.type() != Json::objectValue) + { + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_BadFileFormat); + } + else + { + WriteFastJson(content_, content); + } + } + + + void OrthancJob::ClearSerialized() + { + hasSerialized_ = false; + serialized_.clear(); + } + + + void OrthancJob::UpdateSerialized(const Json::Value& serialized) + { + if (serialized.type() != Json::objectValue) + { + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_BadFileFormat); + } + else + { + WriteFastJson(serialized_, serialized); + hasSerialized_ = true; + } + } + + + void OrthancJob::UpdateProgress(float progress) + { + if (progress < 0 || + progress > 1) + { + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_ParameterOutOfRange); + } + + progress_ = progress; + } + + + OrthancJob::OrthancJob(const std::string& jobType) : + jobType_(jobType), + progress_(0) + { + ClearContent(); + ClearSerialized(); + } + + + OrthancPluginJob* OrthancJob::Create(OrthancJob* job) + { + if (job == NULL) + { + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_NullPointer); + } + + OrthancPluginJob* orthanc = +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 11, 3) + OrthancPluginCreateJob2 +#else + OrthancPluginCreateJob +#endif + (GetGlobalContext(), job, CallbackFinalize, job->jobType_.c_str(), + CallbackGetProgress, CallbackGetContent, CallbackGetSerialized, + CallbackStep, CallbackStop, CallbackReset); + + if (orthanc == NULL) + { + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_Plugin); + } + else + { + return orthanc; + } + } + + + std::string OrthancJob::Submit(OrthancJob* job, + int priority) + { + if (job == NULL) + { + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_NullPointer); + } + + OrthancPluginJob* orthanc = Create(job); + + char* id = OrthancPluginSubmitJob(GetGlobalContext(), orthanc, priority); + + if (id == NULL) + { + ORTHANC_PLUGINS_LOG_ERROR("Plugin cannot submit job"); + OrthancPluginFreeJob(GetGlobalContext(), orthanc); + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_Plugin); + } + else + { + std::string tmp(id); + tmp.assign(id); + OrthancPluginFreeString(GetGlobalContext(), id); + + return tmp; + } + } + + + void OrthancJob::SubmitAndWait(Json::Value& result, + OrthancJob* job /* takes ownership */, + int priority) + { + std::string id = Submit(job, priority); + + for (;;) + { + boost::this_thread::sleep(boost::posix_time::milliseconds(100)); + + Json::Value status; + if (!RestApiGet(status, "/jobs/" + id, false) || + !status.isMember("State") || + status["State"].type() != Json::stringValue) + { + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_InexistentItem); + } + + const std::string state = status["State"].asString(); + if (state == "Success") + { + if (status.isMember("Content")) + { + result = status["Content"]; + } + else + { + result = Json::objectValue; + } + + return; + } + else if (state == "Running") + { + continue; + } + else if (!status.isMember("ErrorCode") || + status["ErrorCode"].type() != Json::intValue) + { + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(OrthancPluginErrorCode_InternalError); + } + else + { + if (!status.isMember("ErrorDescription") || + status["ErrorDescription"].type() != Json::stringValue) + { + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(status["ErrorCode"].asInt()); + } + else + { +#if HAS_ORTHANC_EXCEPTION == 1 + throw Orthanc::OrthancException(static_cast(status["ErrorCode"].asInt()), + status["ErrorDescription"].asString()); +#else + ORTHANC_PLUGINS_LOG_ERROR("Exception while executing the job: " + status["ErrorDescription"].asString()); + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(status["ErrorCode"].asInt()); +#endif + } + } + } + } + + + void OrthancJob::SubmitFromRestApiPost(OrthancPluginRestOutput* output, + const Json::Value& body, + OrthancJob* job) + { + static const char* KEY_SYNCHRONOUS = "Synchronous"; + static const char* KEY_ASYNCHRONOUS = "Asynchronous"; + static const char* KEY_PRIORITY = "Priority"; + + boost::movelib::unique_ptr protection(job); + + if (body.type() != Json::objectValue) + { +#if HAS_ORTHANC_EXCEPTION == 1 + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat, + "Expected a JSON object in the body"); +#else + ORTHANC_PLUGINS_LOG_ERROR("Expected a JSON object in the body"); + ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); +#endif + } + + bool synchronous = true; + + if (body.isMember(KEY_SYNCHRONOUS)) + { + if (body[KEY_SYNCHRONOUS].type() != Json::booleanValue) + { +#if HAS_ORTHANC_EXCEPTION == 1 + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat, + "Option \"" + std::string(KEY_SYNCHRONOUS) + + "\" must be Boolean"); +#else + ORTHANC_PLUGINS_LOG_ERROR("Option \"" + std::string(KEY_SYNCHRONOUS) + "\" must be Boolean"); + ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); +#endif + } + else + { + synchronous = body[KEY_SYNCHRONOUS].asBool(); + } + } + + if (body.isMember(KEY_ASYNCHRONOUS)) + { + if (body[KEY_ASYNCHRONOUS].type() != Json::booleanValue) + { +#if HAS_ORTHANC_EXCEPTION == 1 + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat, + "Option \"" + std::string(KEY_ASYNCHRONOUS) + + "\" must be Boolean"); +#else + ORTHANC_PLUGINS_LOG_ERROR("Option \"" + std::string(KEY_ASYNCHRONOUS) + "\" must be Boolean"); + ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); +#endif + } + else + { + synchronous = !body[KEY_ASYNCHRONOUS].asBool(); + } + } + + int priority = 0; + + if (body.isMember(KEY_PRIORITY)) + { + if (body[KEY_PRIORITY].type() != Json::intValue) + { +#if HAS_ORTHANC_EXCEPTION == 1 + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat, + "Option \"" + std::string(KEY_PRIORITY) + + "\" must be an integer"); +#else + ORTHANC_PLUGINS_LOG_ERROR("Option \"" + std::string(KEY_PRIORITY) + "\" must be an integer"); + ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); +#endif + } + else + { + priority = !body[KEY_PRIORITY].asInt(); + } + } + + Json::Value result; + + if (synchronous) + { + OrthancPlugins::OrthancJob::SubmitAndWait(result, protection.release(), priority); + } + else + { + std::string id = OrthancPlugins::OrthancJob::Submit(protection.release(), priority); + + result = Json::objectValue; + result["ID"] = id; + result["Path"] = "/jobs/" + id; + } + + std::string s = result.toStyledString(); + OrthancPluginAnswerBuffer(OrthancPlugins::GetGlobalContext(), output, s.c_str(), + s.size(), "application/json"); + } + +#endif + + + + + /****************************************************************** + ** METRICS + ******************************************************************/ + +#if HAS_ORTHANC_PLUGIN_METRICS == 1 + MetricsTimer::MetricsTimer(const char* name) : + name_(name) + { + start_ = boost::posix_time::microsec_clock::universal_time(); + } + + MetricsTimer::~MetricsTimer() + { + const boost::posix_time::ptime stop = boost::posix_time::microsec_clock::universal_time(); + const boost::posix_time::time_duration diff = stop - start_; + OrthancPluginSetMetricsValue(GetGlobalContext(), name_.c_str(), static_cast(diff.total_milliseconds()), + OrthancPluginMetricsType_Timer); + } +#endif + + + + + /****************************************************************** + ** HTTP CLIENT + ******************************************************************/ + +#if HAS_ORTHANC_PLUGIN_HTTP_CLIENT == 1 + class HttpClient::RequestBodyWrapper : public boost::noncopyable + { + private: + static RequestBodyWrapper& GetObject(void* body) + { + assert(body != NULL); + return *reinterpret_cast(body); + } + + IRequestBody& body_; + bool done_; + std::string chunk_; + + public: + RequestBodyWrapper(IRequestBody& body) : + body_(body), + done_(false) + { + } + + static uint8_t IsDone(void* body) + { + return GetObject(body).done_; + } + + static const void* GetChunkData(void* body) + { + return GetObject(body).chunk_.c_str(); + } + + static uint32_t GetChunkSize(void* body) + { + return static_cast(GetObject(body).chunk_.size()); + } + + static OrthancPluginErrorCode Next(void* body) + { + RequestBodyWrapper& that = GetObject(body); + + if (that.done_) + { + return OrthancPluginErrorCode_BadSequenceOfCalls; + } + else + { + try + { + that.done_ = !that.body_.ReadNextChunk(that.chunk_); + return OrthancPluginErrorCode_Success; + } + catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) + { + return static_cast(e.GetErrorCode()); + } + catch (...) + { + return OrthancPluginErrorCode_Plugin; + } + } + } + }; + + +#if HAS_ORTHANC_PLUGIN_CHUNKED_HTTP_CLIENT == 1 + static OrthancPluginErrorCode AnswerAddHeaderCallback(void* answer, + const char* key, + const char* value) + { + assert(answer != NULL && key != NULL && value != NULL); + + try + { + reinterpret_cast(answer)->AddHeader(key, value); + return OrthancPluginErrorCode_Success; + } + catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) + { + return static_cast(e.GetErrorCode()); + } + catch (...) + { + return OrthancPluginErrorCode_Plugin; + } + } +#endif + + +#if HAS_ORTHANC_PLUGIN_CHUNKED_HTTP_CLIENT == 1 + static OrthancPluginErrorCode AnswerAddChunkCallback(void* answer, + const void* data, + uint32_t size) + { + assert(answer != NULL); + + try + { + reinterpret_cast(answer)->AddChunk(data, size); + return OrthancPluginErrorCode_Success; + } + catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) + { + return static_cast(e.GetErrorCode()); + } + catch (...) + { + return OrthancPluginErrorCode_Plugin; + } + } +#endif + + + HttpClient::HttpClient() : + httpStatus_(0), + method_(OrthancPluginHttpMethod_Get), + timeout_(0), + pkcs11_(false), + chunkedBody_(NULL), + allowChunkedTransfers_(true) + { + } + + + void HttpClient::AddHeaders(const HttpHeaders& headers) + { + for (HttpHeaders::const_iterator it = headers.begin(); + it != headers.end(); ++it) + { + headers_[it->first] = it->second; + } + } + + + void HttpClient::SetCredentials(const std::string& username, + const std::string& password) + { + username_ = username; + password_ = password; + } + + + void HttpClient::ClearCredentials() + { + username_.clear(); + password_.clear(); + } + + + void HttpClient::SetCertificate(const std::string& certificateFile, + const std::string& keyFile, + const std::string& keyPassword) + { + certificateFile_ = certificateFile; + certificateKeyFile_ = keyFile; + certificateKeyPassword_ = keyPassword; + } + + + void HttpClient::ClearCertificate() + { + certificateFile_.clear(); + certificateKeyFile_.clear(); + certificateKeyPassword_.clear(); + } + + + void HttpClient::ClearBody() + { + fullBody_.clear(); + chunkedBody_ = NULL; + } + + + void HttpClient::SwapBody(std::string& body) + { + fullBody_.swap(body); + chunkedBody_ = NULL; + } + + + void HttpClient::SetBody(const std::string& body) + { + fullBody_ = body; + chunkedBody_ = NULL; + } + + + void HttpClient::SetBody(IRequestBody& body) + { + fullBody_.clear(); + chunkedBody_ = &body; + } + + + namespace + { + class HeadersWrapper : public boost::noncopyable + { + private: + std::vector headersKeys_; + std::vector headersValues_; + + public: + HeadersWrapper(const HttpClient::HttpHeaders& headers) + { + headersKeys_.reserve(headers.size()); + headersValues_.reserve(headers.size()); + + for (HttpClient::HttpHeaders::const_iterator it = headers.begin(); it != headers.end(); ++it) + { + headersKeys_.push_back(it->first.c_str()); + headersValues_.push_back(it->second.c_str()); + } + } + + void AddStaticString(const char* key, + const char* value) + { + headersKeys_.push_back(key); + headersValues_.push_back(value); + } + + uint32_t GetCount() const + { + return headersKeys_.size(); + } + + const char* const* GetKeys() const + { + return headersKeys_.empty() ? NULL : &headersKeys_[0]; + } + + const char* const* GetValues() const + { + return headersValues_.empty() ? NULL : &headersValues_[0]; + } + }; + + + class MemoryRequestBody : public HttpClient::IRequestBody + { + private: + std::string body_; + bool done_; + + public: + MemoryRequestBody(const std::string& body) : + body_(body), + done_(false) + { + if (body_.empty()) + { + done_ = true; + } + } + + virtual bool ReadNextChunk(std::string& chunk) + { + if (done_) + { + return false; + } + else + { + chunk.swap(body_); + done_ = true; + return true; + } + } + }; + + + // This class mimics Orthanc::ChunkedBuffer + class ChunkedBuffer : public boost::noncopyable + { + private: + typedef std::list Content; + + Content content_; + size_t size_; + + public: + ChunkedBuffer() : + size_(0) + { + } + + ~ChunkedBuffer() + { + Clear(); + } + + void Clear() + { + for (Content::iterator it = content_.begin(); it != content_.end(); ++it) + { + assert(*it != NULL); + delete *it; + } + + size_ = 0; + content_.clear(); + } + + /** + * Since Orthanc 1.9.3, this function also clears the content of + * the ChunkedBuffer in order to mimic the behavior of the + * original class "Orthanc::ChunkedBuffer". This prevents the + * forgetting of calling "Clear()" in order to reduce memory + * consumption. + **/ + void Flatten(std::string& target) + { + target.resize(size_); + + size_t pos = 0; + + for (Content::const_iterator it = content_.begin(); it != content_.end(); ++it) + { + assert(*it != NULL); + size_t s = (*it)->size(); + + if (s != 0) + { + memcpy(&target[pos], (*it)->c_str(), s); + pos += s; + } + + delete *it; + } + + assert(pos == target.size()); + + size_ = 0; + content_.clear(); + } + + void AddChunk(const void* data, + size_t size) + { + content_.push_back(new std::string(reinterpret_cast(data), size)); + size_ += size; + } + + void AddChunk(const std::string& chunk) + { + content_.push_back(new std::string(chunk)); + size_ += chunk.size(); + } + }; + + +#if HAS_ORTHANC_PLUGIN_CHUNKED_HTTP_CLIENT == 1 + class MemoryAnswer : public HttpClient::IAnswer + { + private: + HttpClient::HttpHeaders headers_; + ChunkedBuffer body_; + + public: + const HttpClient::HttpHeaders& GetHeaders() const + { + return headers_; + } + + ChunkedBuffer& GetBody() + { + return body_; + } + + virtual void AddHeader(const std::string& key, + const std::string& value) + { + headers_[key] = value; + } + + virtual void AddChunk(const void* data, + size_t size) + { + body_.AddChunk(data, size); + } + }; +#endif + } + + +#if HAS_ORTHANC_PLUGIN_CHUNKED_HTTP_CLIENT == 1 + void HttpClient::ExecuteWithStream(uint16_t& httpStatus, + IAnswer& answer, + IRequestBody& body) const + { + HeadersWrapper h(headers_); + + if (method_ == OrthancPluginHttpMethod_Post || + method_ == OrthancPluginHttpMethod_Put) + { + // Automatically set the "Transfer-Encoding" header if absent + bool found = false; + + for (HttpHeaders::const_iterator it = headers_.begin(); it != headers_.end(); ++it) + { + if (boost::iequals(it->first, "Transfer-Encoding")) + { + found = true; + break; + } + } + + if (!found) + { + h.AddStaticString("Transfer-Encoding", "chunked"); + } + } + + RequestBodyWrapper request(body); + + OrthancPluginErrorCode error = OrthancPluginChunkedHttpClient( + GetGlobalContext(), + &answer, + AnswerAddChunkCallback, + AnswerAddHeaderCallback, + &httpStatus, + method_, + url_.c_str(), + h.GetCount(), + h.GetKeys(), + h.GetValues(), + &request, + RequestBodyWrapper::IsDone, + RequestBodyWrapper::GetChunkData, + RequestBodyWrapper::GetChunkSize, + RequestBodyWrapper::Next, + username_.empty() ? NULL : username_.c_str(), + password_.empty() ? NULL : password_.c_str(), + timeout_, + certificateFile_.empty() ? NULL : certificateFile_.c_str(), + certificateFile_.empty() ? NULL : certificateKeyFile_.c_str(), + certificateFile_.empty() ? NULL : certificateKeyPassword_.c_str(), + pkcs11_ ? 1 : 0); + + if (error != OrthancPluginErrorCode_Success) + { + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(error); + } + } +#endif + + + void HttpClient::ExecuteWithoutStream(uint16_t& httpStatus, + HttpHeaders& answerHeaders, + std::string& answerBody, + const std::string& body) const + { + HeadersWrapper headers(headers_); + + MemoryBuffer answerBodyBuffer, answerHeadersBuffer; + + if (body.size() > 0xffffffffu) + { + ORTHANC_PLUGINS_LOG_ERROR("Cannot handle body size > 4GB"); + ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); + } + + OrthancPluginErrorCode error = OrthancPluginHttpClient( + GetGlobalContext(), + *answerBodyBuffer, + *answerHeadersBuffer, + &httpStatus, + method_, + url_.c_str(), + headers.GetCount(), + headers.GetKeys(), + headers.GetValues(), + body.empty() ? NULL : body.c_str(), + body.size(), + username_.empty() ? NULL : username_.c_str(), + password_.empty() ? NULL : password_.c_str(), + timeout_, + certificateFile_.empty() ? NULL : certificateFile_.c_str(), + certificateFile_.empty() ? NULL : certificateKeyFile_.c_str(), + certificateFile_.empty() ? NULL : certificateKeyPassword_.c_str(), + pkcs11_ ? 1 : 0); + + if (error != OrthancPluginErrorCode_Success) + { + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(error); + } + + Json::Value v; + answerHeadersBuffer.ToJson(v); + + if (v.type() != Json::objectValue) + { + ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); + } + + Json::Value::Members members = v.getMemberNames(); + answerHeaders.clear(); + + for (size_t i = 0; i < members.size(); i++) + { + const Json::Value& h = v[members[i]]; + if (h.type() != Json::stringValue) + { + ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); + } + else + { + answerHeaders[members[i]] = h.asString(); + } + } + + answerBodyBuffer.ToString(answerBody); + } + + + void HttpClient::Execute(IAnswer& answer) + { +#if HAS_ORTHANC_PLUGIN_CHUNKED_HTTP_CLIENT == 1 + if (allowChunkedTransfers_) + { + if (chunkedBody_ != NULL) + { + ExecuteWithStream(httpStatus_, answer, *chunkedBody_); + } + else + { + MemoryRequestBody wrapper(fullBody_); + ExecuteWithStream(httpStatus_, answer, wrapper); + } + + return; + } +#endif + + // Compatibility mode for Orthanc SDK <= 1.5.6 or if chunked + // transfers are disabled. This results in higher memory usage + // (all chunks from the answer body are sent at once) + + HttpHeaders answerHeaders; + std::string answerBody; + Execute(answerHeaders, answerBody); + + for (HttpHeaders::const_iterator it = answerHeaders.begin(); + it != answerHeaders.end(); ++it) + { + answer.AddHeader(it->first, it->second); + } + + if (!answerBody.empty()) + { + answer.AddChunk(answerBody.c_str(), answerBody.size()); + } + } + + + void HttpClient::Execute(HttpHeaders& answerHeaders /* out */, + std::string& answerBody /* out */) + { +#if HAS_ORTHANC_PLUGIN_CHUNKED_HTTP_CLIENT == 1 + if (allowChunkedTransfers_) + { + MemoryAnswer answer; + Execute(answer); + answerHeaders = answer.GetHeaders(); + answer.GetBody().Flatten(answerBody); + return; + } +#endif + + // Compatibility mode for Orthanc SDK <= 1.5.6 or if chunked + // transfers are disabled. This results in higher memory usage + // (all chunks from the request body are sent at once) + + if (chunkedBody_ != NULL) + { + ChunkedBuffer buffer; + + std::string chunk; + while (chunkedBody_->ReadNextChunk(chunk)) + { + buffer.AddChunk(chunk); + } + + std::string body; + buffer.Flatten(body); + + ExecuteWithoutStream(httpStatus_, answerHeaders, answerBody, body); + } + else + { + ExecuteWithoutStream(httpStatus_, answerHeaders, answerBody, fullBody_); + } + } + + + void HttpClient::Execute(HttpHeaders& answerHeaders /* out */, + Json::Value& answerBody /* out */) + { + std::string body; + Execute(answerHeaders, body); + + if (!ReadJson(answerBody, body)) + { + ORTHANC_PLUGINS_LOG_ERROR("Cannot convert HTTP answer body to JSON"); + ORTHANC_PLUGINS_THROW_EXCEPTION(BadFileFormat); + } + } + + + void HttpClient::Execute() + { + HttpHeaders answerHeaders; + std::string body; + Execute(answerHeaders, body); + } + +#endif /* HAS_ORTHANC_PLUGIN_HTTP_CLIENT == 1 */ + + + + + + /****************************************************************** + ** CHUNKED HTTP SERVER + ******************************************************************/ + + namespace Internals + { + void NullRestCallback(OrthancPluginRestOutput* output, + const char* url, + const OrthancPluginHttpRequest* request) + { + } + + IChunkedRequestReader *NullChunkedRestCallback(const char* url, + const OrthancPluginHttpRequest* request) + { + return NULL; + } + + +#if HAS_ORTHANC_PLUGIN_CHUNKED_HTTP_SERVER == 1 + + OrthancPluginErrorCode ChunkedRequestReaderAddChunk( + OrthancPluginServerChunkedRequestReader* reader, + const void* data, + uint32_t size) + { + try + { + if (reader == NULL) + { + return OrthancPluginErrorCode_InternalError; + } + + reinterpret_cast(reader)->AddChunk(data, size); + return OrthancPluginErrorCode_Success; + } + catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) + { + return static_cast(e.GetErrorCode()); + } + catch (boost::bad_lexical_cast&) + { + return OrthancPluginErrorCode_BadFileFormat; + } + catch (...) + { + return OrthancPluginErrorCode_Plugin; + } + } + + + OrthancPluginErrorCode ChunkedRequestReaderExecute( + OrthancPluginServerChunkedRequestReader* reader, + OrthancPluginRestOutput* output) + { + try + { + if (reader == NULL) + { + return OrthancPluginErrorCode_InternalError; + } + + reinterpret_cast(reader)->Execute(output); + return OrthancPluginErrorCode_Success; + } + catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) + { + return static_cast(e.GetErrorCode()); + } + catch (boost::bad_lexical_cast&) + { + return OrthancPluginErrorCode_BadFileFormat; + } + catch (...) + { + return OrthancPluginErrorCode_Plugin; + } + } + + + void ChunkedRequestReaderFinalize( + OrthancPluginServerChunkedRequestReader* reader) + { + if (reader != NULL) + { + delete reinterpret_cast(reader); + } + } + +#else + + OrthancPluginErrorCode ChunkedRestCompatibility(OrthancPluginRestOutput* output, + const char* url, + const OrthancPluginHttpRequest* request, + RestCallback GetHandler, + ChunkedRestCallback PostHandler, + RestCallback DeleteHandler, + ChunkedRestCallback PutHandler) + { + try + { + std::string allowed; + + if (GetHandler != Internals::NullRestCallback) + { + allowed += "GET"; + } + + if (PostHandler != Internals::NullChunkedRestCallback) + { + if (!allowed.empty()) + { + allowed += ","; + } + + allowed += "POST"; + } + + if (DeleteHandler != Internals::NullRestCallback) + { + if (!allowed.empty()) + { + allowed += ","; + } + + allowed += "DELETE"; + } + + if (PutHandler != Internals::NullChunkedRestCallback) + { + if (!allowed.empty()) + { + allowed += ","; + } + + allowed += "PUT"; + } + + switch (request->method) + { + case OrthancPluginHttpMethod_Get: + if (GetHandler == Internals::NullRestCallback) + { + OrthancPluginSendMethodNotAllowed(GetGlobalContext(), output, allowed.c_str()); + } + else + { + GetHandler(output, url, request); + } + + break; + + case OrthancPluginHttpMethod_Post: + if (PostHandler == Internals::NullChunkedRestCallback) + { + OrthancPluginSendMethodNotAllowed(GetGlobalContext(), output, allowed.c_str()); + } + else + { + boost::movelib::unique_ptr reader(PostHandler(url, request)); + if (reader.get() == NULL) + { + ORTHANC_PLUGINS_THROW_EXCEPTION(Plugin); + } + else + { + reader->AddChunk(request->body, request->bodySize); + reader->Execute(output); + } + } + + break; + + case OrthancPluginHttpMethod_Delete: + if (DeleteHandler == Internals::NullRestCallback) + { + OrthancPluginSendMethodNotAllowed(GetGlobalContext(), output, allowed.c_str()); + } + else + { + DeleteHandler(output, url, request); + } + + break; + + case OrthancPluginHttpMethod_Put: + if (PutHandler == Internals::NullChunkedRestCallback) + { + OrthancPluginSendMethodNotAllowed(GetGlobalContext(), output, allowed.c_str()); + } + else + { + boost::movelib::unique_ptr reader(PutHandler(url, request)); + if (reader.get() == NULL) + { + ORTHANC_PLUGINS_THROW_EXCEPTION(Plugin); + } + else + { + reader->AddChunk(request->body, request->bodySize); + reader->Execute(output); + } + } + + break; + + default: + ORTHANC_PLUGINS_THROW_EXCEPTION(InternalError); + } + + return OrthancPluginErrorCode_Success; + } + catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) + { +#if HAS_ORTHANC_EXCEPTION == 1 && HAS_ORTHANC_PLUGIN_EXCEPTION_DETAILS == 1 + if (HasGlobalContext() && + e.HasDetails()) + { + // The "false" instructs Orthanc not to log the detailed + // error message. This is to avoid duplicating the details, + // because "OrthancException" already does it on construction. + OrthancPluginSetHttpErrorDetails + (GetGlobalContext(), output, e.GetDetails(), false); + } +#endif + + return static_cast(e.GetErrorCode()); + } + catch (boost::bad_lexical_cast&) + { + return OrthancPluginErrorCode_BadFileFormat; + } + catch (...) + { + return OrthancPluginErrorCode_Plugin; + } + } +#endif + } + + +#if HAS_ORTHANC_PLUGIN_STORAGE_COMMITMENT_SCP == 1 + OrthancPluginErrorCode IStorageCommitmentScpHandler::Lookup( + OrthancPluginStorageCommitmentFailureReason* target, + void* rawHandler, + const char* sopClassUid, + const char* sopInstanceUid) + { + assert(target != NULL && + rawHandler != NULL); + + try + { + IStorageCommitmentScpHandler& handler = *reinterpret_cast(rawHandler); + *target = handler.Lookup(sopClassUid, sopInstanceUid); + return OrthancPluginErrorCode_Success; + } + catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) + { + return static_cast(e.GetErrorCode()); + } + catch (...) + { + return OrthancPluginErrorCode_Plugin; + } + } +#endif + + +#if HAS_ORTHANC_PLUGIN_STORAGE_COMMITMENT_SCP == 1 + void IStorageCommitmentScpHandler::Destructor(void* rawHandler) + { + assert(rawHandler != NULL); + delete reinterpret_cast(rawHandler); + } +#endif + + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 6, 1) + DicomInstance::DicomInstance(const OrthancPluginDicomInstance* instance) : + toFree_(false), + instance_(instance) + { + } +#else + DicomInstance::DicomInstance(OrthancPluginDicomInstance* instance) : + toFree_(false), + instance_(instance) + { + } +#endif + + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 7, 0) + DicomInstance::DicomInstance(const void* buffer, + size_t size) : + toFree_(true), + instance_(OrthancPluginCreateDicomInstance(GetGlobalContext(), buffer, size)) + { + if (instance_ == NULL) + { + ORTHANC_PLUGINS_THROW_EXCEPTION(NullPointer); + } + } +#endif + + + DicomInstance::~DicomInstance() + { +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 7, 0) + if (toFree_ && + instance_ != NULL) + { + OrthancPluginFreeDicomInstance( + GetGlobalContext(), const_cast(instance_)); + } +#endif + } + + + std::string DicomInstance::GetRemoteAet() const + { + const char* s = OrthancPluginGetInstanceRemoteAet(GetGlobalContext(), instance_); + if (s == NULL) + { + ORTHANC_PLUGINS_THROW_EXCEPTION(Plugin); + } + else + { + return std::string(s); + } + } + + + void DicomInstance::GetJson(Json::Value& target) const + { + OrthancString s; + s.Assign(OrthancPluginGetInstanceJson(GetGlobalContext(), instance_)); + s.ToJson(target); + } + + + void DicomInstance::GetSimplifiedJson(Json::Value& target) const + { + OrthancString s; + s.Assign(OrthancPluginGetInstanceSimplifiedJson(GetGlobalContext(), instance_)); + s.ToJson(target); + } + + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 6, 1) + std::string DicomInstance::GetTransferSyntaxUid() const + { + OrthancString s; + s.Assign(OrthancPluginGetInstanceTransferSyntaxUid(GetGlobalContext(), instance_)); + + std::string result; + s.ToString(result); + return result; + } +#endif + + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 6, 1) + bool DicomInstance::HasPixelData() const + { + int32_t result = OrthancPluginHasInstancePixelData(GetGlobalContext(), instance_); + if (result < 0) + { + ORTHANC_PLUGINS_THROW_EXCEPTION(Plugin); + } + else + { + return (result != 0); + } + } +#endif + + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 7, 0) + void DicomInstance::GetRawFrame(std::string& target, + unsigned int frameIndex) const + { + MemoryBuffer buffer; + OrthancPluginErrorCode code = OrthancPluginGetInstanceRawFrame( + GetGlobalContext(), *buffer, instance_, frameIndex); + + if (code == OrthancPluginErrorCode_Success) + { + buffer.ToString(target); + } + else + { + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(code); + } + } +#endif + + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 7, 0) + OrthancImage* DicomInstance::GetDecodedFrame(unsigned int frameIndex) const + { + OrthancPluginImage* image = OrthancPluginGetInstanceDecodedFrame( + GetGlobalContext(), instance_, frameIndex); + + if (image == NULL) + { + ORTHANC_PLUGINS_THROW_EXCEPTION(Plugin); + } + else + { + return new OrthancImage(image); + } + } +#endif + + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 7, 0) + void DicomInstance::Serialize(std::string& target) const + { + MemoryBuffer buffer; + OrthancPluginErrorCode code = OrthancPluginSerializeDicomInstance( + GetGlobalContext(), *buffer, instance_); + + if (code == OrthancPluginErrorCode_Success) + { + buffer.ToString(target); + } + else + { + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(code); + } + } +#endif + + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 7, 0) + DicomInstance* DicomInstance::Transcode(const void* buffer, + size_t size, + const std::string& transferSyntax) + { + OrthancPluginDicomInstance* instance = OrthancPluginTranscodeDicomInstance( + GetGlobalContext(), buffer, size, transferSyntax.c_str()); + + if (instance == NULL) + { + ORTHANC_PLUGINS_THROW_EXCEPTION(Plugin); + } + else + { + boost::movelib::unique_ptr result(new DicomInstance(instance)); + result->toFree_ = true; + return result.release(); + } + } +#endif + + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 12, 1) + DicomInstance* DicomInstance::Load(const std::string& instanceId, + OrthancPluginLoadDicomInstanceMode mode) + { + OrthancPluginDicomInstance* instance = OrthancPluginLoadDicomInstance( + GetGlobalContext(), instanceId.c_str(), mode); + + if (instance == NULL) + { + ORTHANC_PLUGINS_THROW_EXCEPTION(Plugin); + } + else + { + boost::movelib::unique_ptr result(new DicomInstance(instance)); + result->toFree_ = true; + return result.release(); + } + } +#endif + + +#if HAS_ORTHANC_PLUGIN_WEBDAV == 1 + static std::vector WebDavConvertPath(uint32_t pathSize, + const char* const* pathItems) + { + std::vector result(pathSize); + + for (uint32_t i = 0; i < pathSize; i++) + { + result[i] = pathItems[i]; + } + + return result; + } +#endif + + +#if HAS_ORTHANC_PLUGIN_WEBDAV == 1 + static OrthancPluginErrorCode WebDavIsExistingFolder(uint8_t* isExisting, + uint32_t pathSize, + const char* const* pathItems, + void* payload) + { + IWebDavCollection& that = *reinterpret_cast(payload); + + try + { + *isExisting = (that.IsExistingFolder(WebDavConvertPath(pathSize, pathItems)) ? 1 : 0); + return OrthancPluginErrorCode_Success; + } + catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) + { + return static_cast(e.GetErrorCode()); + } + catch (...) + { + return OrthancPluginErrorCode_Plugin; + } + } +#endif + + +#if HAS_ORTHANC_PLUGIN_WEBDAV == 1 + static OrthancPluginErrorCode WebDavListFolder(uint8_t* isExisting, + OrthancPluginWebDavCollection* collection, + OrthancPluginWebDavAddFile addFile, + OrthancPluginWebDavAddFolder addFolder, + uint32_t pathSize, + const char* const* pathItems, + void* payload) + { + IWebDavCollection& that = *reinterpret_cast(payload); + + try + { + std::list files; + std::list subfolders; + + if (!that.ListFolder(files, subfolders, WebDavConvertPath(pathSize, pathItems))) + { + *isExisting = 0; + } + else + { + *isExisting = 1; + + for (std::list::const_iterator + it = files.begin(); it != files.end(); ++it) + { + OrthancPluginErrorCode code = addFile( + collection, it->GetName().c_str(), it->GetContentSize(), + it->GetMimeType().c_str(), it->GetDateTime().c_str()); + + if (code != OrthancPluginErrorCode_Success) + { + return code; + } + } + + for (std::list::const_iterator it = + subfolders.begin(); it != subfolders.end(); ++it) + { + OrthancPluginErrorCode code = addFolder( + collection, it->GetName().c_str(), it->GetDateTime().c_str()); + + if (code != OrthancPluginErrorCode_Success) + { + return code; + } + } + } + + return OrthancPluginErrorCode_Success; + } + catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) + { + return static_cast(e.GetErrorCode()); + } + catch (...) + { + return OrthancPluginErrorCode_Plugin; + } + } +#endif + + +#if HAS_ORTHANC_PLUGIN_WEBDAV == 1 + static OrthancPluginErrorCode WebDavRetrieveFile(OrthancPluginWebDavCollection* collection, + OrthancPluginWebDavRetrieveFile retrieveFile, + uint32_t pathSize, + const char* const* pathItems, + void* payload) + { + IWebDavCollection& that = *reinterpret_cast(payload); + + try + { + std::string content, mime, dateTime; + + if (that.GetFile(content, mime, dateTime, WebDavConvertPath(pathSize, pathItems))) + { + return retrieveFile(collection, content.empty() ? NULL : content.c_str(), + content.size(), mime.c_str(), dateTime.c_str()); + } + else + { + // Inexisting file + return OrthancPluginErrorCode_Success; + } + } + catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) + { + return static_cast(e.GetErrorCode()); + } + catch (...) + { + return OrthancPluginErrorCode_InternalError; + } + } +#endif + + +#if HAS_ORTHANC_PLUGIN_WEBDAV == 1 + static OrthancPluginErrorCode WebDavStoreFileCallback(uint8_t* isReadOnly, /* out */ + uint32_t pathSize, + const char* const* pathItems, + const void* data, + uint64_t size, + void* payload) + { + IWebDavCollection& that = *reinterpret_cast(payload); + + try + { + if (static_cast(static_cast(size)) != size) + { + ORTHANC_PLUGINS_THROW_EXCEPTION(NotEnoughMemory); + } + + *isReadOnly = (that.StoreFile(WebDavConvertPath(pathSize, pathItems), data, + static_cast(size)) ? 1 : 0); + return OrthancPluginErrorCode_Success; + } + catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) + { + return static_cast(e.GetErrorCode()); + } + catch (...) + { + return OrthancPluginErrorCode_InternalError; + } + } +#endif + + +#if HAS_ORTHANC_PLUGIN_WEBDAV == 1 + static OrthancPluginErrorCode WebDavCreateFolderCallback(uint8_t* isReadOnly, /* out */ + uint32_t pathSize, + const char* const* pathItems, + void* payload) + { + IWebDavCollection& that = *reinterpret_cast(payload); + + try + { + *isReadOnly = (that.CreateFolder(WebDavConvertPath(pathSize, pathItems)) ? 1 : 0); + return OrthancPluginErrorCode_Success; + } + catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) + { + return static_cast(e.GetErrorCode()); + } + catch (...) + { + return OrthancPluginErrorCode_InternalError; + } + } +#endif + + +#if HAS_ORTHANC_PLUGIN_WEBDAV == 1 + static OrthancPluginErrorCode WebDavDeleteItemCallback(uint8_t* isReadOnly, /* out */ + uint32_t pathSize, + const char* const* pathItems, + void* payload) + { + IWebDavCollection& that = *reinterpret_cast(payload); + + try + { + *isReadOnly = (that.DeleteItem(WebDavConvertPath(pathSize, pathItems)) ? 1 : 0); + return OrthancPluginErrorCode_Success; + } + catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) + { + return static_cast(e.GetErrorCode()); + } + catch (...) + { + return OrthancPluginErrorCode_InternalError; + } + } +#endif + + +#if HAS_ORTHANC_PLUGIN_WEBDAV == 1 + void IWebDavCollection::Register(const std::string& uri, + IWebDavCollection& collection) + { + OrthancPluginErrorCode code = OrthancPluginRegisterWebDavCollection( + GetGlobalContext(), uri.c_str(), WebDavIsExistingFolder, WebDavListFolder, WebDavRetrieveFile, + WebDavStoreFileCallback, WebDavCreateFolderCallback, WebDavDeleteItemCallback, &collection); + + if (code != OrthancPluginErrorCode_Success) + { + ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(code); + } + } +#endif + + void GetHttpHeaders(std::map& result, const OrthancPluginHttpRequest* request) + { + result.clear(); + + for (uint32_t i = 0; i < request->headersCount; ++i) + { + result[request->headersKeys[i]] = request->headersValues[i]; + } + } + +#if !ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 12, 4) + static void SetPluginProperty(const std::string& pluginIdentifier, + _OrthancPluginProperty property, + const std::string& value) + { + _OrthancPluginSetPluginProperty params; + params.plugin = pluginIdentifier.c_str(); + params.property = property; + params.value = value.c_str(); + + GetGlobalContext()->InvokeService(GetGlobalContext(), _OrthancPluginService_SetPluginProperty, ¶ms); + } +#endif + + void SetRootUri(const std::string& pluginIdentifier, + const std::string& uri) + { +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 12, 4) + OrthancPluginSetRootUri2(GetGlobalContext(), pluginIdentifier.c_str(), uri.c_str()); +#else + SetPluginProperty(pluginIdentifier, _OrthancPluginProperty_RootUri, uri); +#endif + } + + void SetDescription(const std::string& pluginIdentifier, + const std::string& description) + { +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 12, 4) + OrthancPluginSetDescription2(GetGlobalContext(), pluginIdentifier.c_str(), description.c_str()); +#else + SetPluginProperty(pluginIdentifier, _OrthancPluginProperty_Description, description); +#endif + } + + void ExtendOrthancExplorer(const std::string& pluginIdentifier, + const std::string& javascript) + { +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 12, 4) + OrthancPluginExtendOrthancExplorer2(GetGlobalContext(), pluginIdentifier.c_str(), javascript.c_str()); +#else + SetPluginProperty(pluginIdentifier, _OrthancPluginProperty_OrthancExplorer, javascript); +#endif + } +} diff --git a/Resources/Orthanc/Plugins/OrthancPluginCppWrapper.h b/Resources/Orthanc/Plugins/OrthancPluginCppWrapper.h new file mode 100644 index 0000000..3656efa --- /dev/null +++ b/Resources/Orthanc/Plugins/OrthancPluginCppWrapper.h @@ -0,0 +1,1511 @@ +/** + * Orthanc - A Lightweight, RESTful DICOM Store + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2023 Osimis S.A., Belgium + * Copyright (C) 2024-2024 Orthanc Team SRL, Belgium + * Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + **/ + + +#pragma once + +#include "OrthancPluginException.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +/** + * The definition of ORTHANC_PLUGINS_VERSION_IS_ABOVE below is for + * backward compatibility with Orthanc SDK <= 1.3.0. + * + * $ hg diff -r Orthanc-1.3.0:Orthanc-1.3.1 ../../../Plugins/Include/orthanc/OrthancCPlugin.h + * + **/ +#if !defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE) +#define ORTHANC_PLUGINS_VERSION_IS_ABOVE(major, minor, revision) \ + (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER > major || \ + (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER == major && \ + (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER > minor || \ + (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER == minor && \ + ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER >= revision)))) +#endif + + +#if !defined(ORTHANC_FRAMEWORK_VERSION_IS_ABOVE) +#define ORTHANC_FRAMEWORK_VERSION_IS_ABOVE(major, minor, revision) \ + (ORTHANC_VERSION_MAJOR > major || \ + (ORTHANC_VERSION_MAJOR == major && \ + (ORTHANC_VERSION_MINOR > minor || \ + (ORTHANC_VERSION_MINOR == minor && \ + ORTHANC_VERSION_REVISION >= revision)))) +#endif + + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 2, 0) +// The "OrthancPluginFindMatcher()" primitive was introduced in Orthanc 1.2.0 +# define HAS_ORTHANC_PLUGIN_FIND_MATCHER 1 +#else +# define HAS_ORTHANC_PLUGIN_FIND_MATCHER 0 +#endif + + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 4, 2) +# define HAS_ORTHANC_PLUGIN_PEERS 1 +# define HAS_ORTHANC_PLUGIN_JOB 1 +#else +# define HAS_ORTHANC_PLUGIN_PEERS 0 +# define HAS_ORTHANC_PLUGIN_JOB 0 +#endif + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 5, 0) +# define HAS_ORTHANC_PLUGIN_EXCEPTION_DETAILS 1 +#else +# define HAS_ORTHANC_PLUGIN_EXCEPTION_DETAILS 0 +#endif + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 5, 4) +# define HAS_ORTHANC_PLUGIN_METRICS 1 +#else +# define HAS_ORTHANC_PLUGIN_METRICS 0 +#endif + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 1, 0) +# define HAS_ORTHANC_PLUGIN_HTTP_CLIENT 1 +#else +# define HAS_ORTHANC_PLUGIN_HTTP_CLIENT 0 +#endif + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 5, 7) +# define HAS_ORTHANC_PLUGIN_CHUNKED_HTTP_CLIENT 1 +#else +# define HAS_ORTHANC_PLUGIN_CHUNKED_HTTP_CLIENT 0 +#endif + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 5, 7) +# define HAS_ORTHANC_PLUGIN_CHUNKED_HTTP_SERVER 1 +#else +# define HAS_ORTHANC_PLUGIN_CHUNKED_HTTP_SERVER 0 +#endif + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 6, 0) +# define HAS_ORTHANC_PLUGIN_STORAGE_COMMITMENT_SCP 1 +#else +# define HAS_ORTHANC_PLUGIN_STORAGE_COMMITMENT_SCP 0 +#endif + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 9, 2) +# define HAS_ORTHANC_PLUGIN_GENERIC_CALL_REST_API 1 +#else +# define HAS_ORTHANC_PLUGIN_GENERIC_CALL_REST_API 0 +#endif + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 10, 1) +# define HAS_ORTHANC_PLUGIN_WEBDAV 1 +#else +# define HAS_ORTHANC_PLUGIN_WEBDAV 0 +#endif + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 12, 4) +# define HAS_ORTHANC_PLUGIN_LOG_MESSAGE 1 +#else +# define HAS_ORTHANC_PLUGIN_LOG_MESSAGE 0 +#endif + + +// Macro to tag a function as having been deprecated +#if (__cplusplus >= 201402L) // C++14 +# define ORTHANC_PLUGIN_CPP_WRAPPER_DEPRECATED(f) [[deprecated]] f +#elif defined(__GNUC__) || defined(__clang__) +# define ORTHANC_PLUGIN_CPP_WRAPPER_DEPRECATED(f) f __attribute__((deprecated)) +#elif defined(_MSC_VER) +# define ORTHANC_PLUGIN_CPP_WRAPPER_DEPRECATED(f) __declspec(deprecated) f +#else +# define ORTHANC_PLUGIN_CPP_WRAPPER_DEPRECATED +#endif + + +#if !defined(__ORTHANC_FILE__) +# if defined(_MSC_VER) +# pragma message("Warning: Macro __ORTHANC_FILE__ is not defined, this will leak the full path of the source files in the binaries") +# else +# warning Warning: Macro __ORTHANC_FILE__ is not defined, this will leak the full path of the source files in the binaries +# endif +# define __ORTHANC_FILE__ __FILE__ +#endif + + +#if HAS_ORTHANC_PLUGIN_LOG_MESSAGE == 1 +# define ORTHANC_PLUGINS_LOG_ERROR(msg) ::OrthancPlugins::LogMessage(OrthancPluginLogLevel_Error, __ORTHANC_FILE__, __LINE__, msg) +# define ORTHANC_PLUGINS_LOG_WARNING(msg) ::OrthancPlugins::LogMessage(OrthancPluginLogLevel_Warning, __ORTHANC_FILE__, __LINE__, msg) +# define ORTHANC_PLUGINS_LOG_INFO(msg) ::OrthancPlugins::LogMessage(OrthancPluginLogLevel_Info, __ORTHANC_FILE__, __LINE__, msg) +#else +# define ORTHANC_PLUGINS_LOG_ERROR(msg) ::OrthancPlugins::LogError(msg) +# define ORTHANC_PLUGINS_LOG_WARNING(msg) ::OrthancPlugins::LogWarning(msg) +# define ORTHANC_PLUGINS_LOG_INFO(msg) ::OrthancPlugins::LogInfo(msg) +#endif + + +namespace OrthancPlugins +{ + typedef void (*RestCallback) (OrthancPluginRestOutput* output, + const char* url, + const OrthancPluginHttpRequest* request); + + void SetGlobalContext(OrthancPluginContext* context); + + void SetGlobalContext(OrthancPluginContext* context, + const char* pluginName); + + void ResetGlobalContext(); + + bool HasGlobalContext(); + + OrthancPluginContext* GetGlobalContext(); + + + class OrthancImage; + + + class MemoryBuffer : public boost::noncopyable + { + private: + OrthancPluginMemoryBuffer buffer_; + + void Check(OrthancPluginErrorCode code); + + bool CheckHttp(OrthancPluginErrorCode code); + + public: + MemoryBuffer(); + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 7, 0) + // This constructor makes a copy of the given buffer in the memory + // handled by the Orthanc core + MemoryBuffer(const void* buffer, + size_t size); +#endif + + ~MemoryBuffer() + { + Clear(); + } + + OrthancPluginMemoryBuffer* operator*() + { + return &buffer_; + } + + // This transfers ownership from "other" to "this" + void Assign(OrthancPluginMemoryBuffer& other); + + void Swap(MemoryBuffer& other); + + OrthancPluginMemoryBuffer Release(); + + const char* GetData() const + { + if (buffer_.size > 0) + { + return reinterpret_cast(buffer_.data); + } + else + { + return NULL; + } + } + + size_t GetSize() const + { + return buffer_.size; + } + + bool IsEmpty() const + { + return GetSize() == 0 || GetData() == NULL; + } + + void Clear(); + + void ToString(std::string& target) const; + + void ToJson(Json::Value& target) const; + + bool RestApiGet(const std::string& uri, + bool applyPlugins); + + bool RestApiGet(const std::string& uri, + const std::map& httpHeaders, + bool applyPlugins); + + bool RestApiPost(const std::string& uri, + const void* body, + size_t bodySize, + bool applyPlugins); + + bool RestApiPut(const std::string& uri, + const void* body, + size_t bodySize, + bool applyPlugins); + + bool RestApiPost(const std::string& uri, + const Json::Value& body, + bool applyPlugins); + +#if HAS_ORTHANC_PLUGIN_GENERIC_CALL_REST_API == 1 + bool RestApiPost(const std::string& uri, + const Json::Value& body, + const std::map& httpHeaders, + bool applyPlugins); + + bool RestApiPost(const std::string& uri, + const void* body, + size_t bodySize, + const std::map& httpHeaders, + bool applyPlugins); +#endif + + bool RestApiPut(const std::string& uri, + const Json::Value& body, + bool applyPlugins); + + bool RestApiPost(const std::string& uri, + const std::string& body, + bool applyPlugins) + { + return RestApiPost(uri, body.empty() ? NULL : body.c_str(), body.size(), applyPlugins); + } + + bool RestApiPut(const std::string& uri, + const std::string& body, + bool applyPlugins) + { + return RestApiPut(uri, body.empty() ? NULL : body.c_str(), body.size(), applyPlugins); + } + + void CreateDicom(const Json::Value& tags, + OrthancPluginCreateDicomFlags flags); + + void CreateDicom(const Json::Value& tags, + const OrthancImage& pixelData, + OrthancPluginCreateDicomFlags flags); + + void ReadFile(const std::string& path); + + void GetDicomQuery(const OrthancPluginWorklistQuery* query); + + void DicomToJson(Json::Value& target, + OrthancPluginDicomToJsonFormat format, + OrthancPluginDicomToJsonFlags flags, + uint32_t maxStringLength); + + bool HttpGet(const std::string& url, + const std::string& username, + const std::string& password); + + bool HttpPost(const std::string& url, + const std::string& body, + const std::string& username, + const std::string& password); + + bool HttpPut(const std::string& url, + const std::string& body, + const std::string& username, + const std::string& password); + + void GetDicomInstance(const std::string& instanceId); + }; + + + class OrthancString : public boost::noncopyable + { + private: + char* str_; + + void Clear(); + + public: + OrthancString() : + str_(NULL) + { + } + + ~OrthancString() + { + Clear(); + } + + // This transfers ownership, warning: The string must have been + // allocated by the Orthanc core + void Assign(char* str); + + const char* GetContent() const + { + return str_; + } + + bool IsNullOrEmpty() const + { + return str_ == NULL || str_[0] == 0; + } + + void ToString(std::string& target) const; + + void ToJson(Json::Value& target) const; + + void ToJsonWithoutComments(Json::Value& target) const; +}; + + + class OrthancConfiguration : public boost::noncopyable + { + private: + Json::Value configuration_; // Necessarily a Json::objectValue + std::string path_; + + std::string GetPath(const std::string& key) const; + + void LoadConfiguration(); + + public: + OrthancConfiguration(); // loads the full Orthanc configuration + + explicit OrthancConfiguration(bool load); + + explicit OrthancConfiguration(const Json::Value& configuration, const std::string& path); // e.g. to load a section from a default json content + + const Json::Value& GetJson() const + { + return configuration_; + } + + bool IsSection(const std::string& key) const; + + void GetSection(OrthancConfiguration& target, + const std::string& key) const; + + bool LookupStringValue(std::string& target, + const std::string& key) const; + + bool LookupIntegerValue(int& target, + const std::string& key) const; + + bool LookupUnsignedIntegerValue(unsigned int& target, + const std::string& key) const; + + bool LookupBooleanValue(bool& target, + const std::string& key) const; + + bool LookupFloatValue(float& target, + const std::string& key) const; + + bool LookupListOfStrings(std::list& target, + const std::string& key, + bool allowSingleString) const; + + bool LookupSetOfStrings(std::set& target, + const std::string& key, + bool allowSingleString) const; + + std::string GetStringValue(const std::string& key, + const std::string& defaultValue) const; + + int GetIntegerValue(const std::string& key, + int defaultValue) const; + + unsigned int GetUnsignedIntegerValue(const std::string& key, + unsigned int defaultValue) const; + + bool GetBooleanValue(const std::string& key, + bool defaultValue) const; + + float GetFloatValue(const std::string& key, + float defaultValue) const; + + void GetDictionary(std::map& target, + const std::string& key) const; + }; + + class OrthancImage : public boost::noncopyable + { + private: + OrthancPluginImage* image_; + + void Clear(); + + void CheckImageAvailable() const; + + public: + OrthancImage(); + + explicit OrthancImage(OrthancPluginImage* image); + + OrthancImage(OrthancPluginPixelFormat format, + uint32_t width, + uint32_t height); + + OrthancImage(OrthancPluginPixelFormat format, + uint32_t width, + uint32_t height, + uint32_t pitch, + void* buffer); + + ~OrthancImage() + { + Clear(); + } + + void UncompressPngImage(const void* data, + size_t size); + + void UncompressJpegImage(const void* data, + size_t size); + + void DecodeDicomImage(const void* data, + size_t size, + unsigned int frame); + + OrthancPluginPixelFormat GetPixelFormat() const; + + unsigned int GetWidth() const; + + unsigned int GetHeight() const; + + unsigned int GetPitch() const; + + void* GetBuffer() const; + + const OrthancPluginImage* GetObject() const + { + return image_; + } + + void CompressPngImage(MemoryBuffer& target) const; + + void CompressJpegImage(MemoryBuffer& target, + uint8_t quality) const; + + void AnswerPngImage(OrthancPluginRestOutput* output) const; + + void AnswerJpegImage(OrthancPluginRestOutput* output, + uint8_t quality) const; + + void* GetWriteableBuffer(); + + OrthancPluginImage* Release(); + }; + + +#if HAS_ORTHANC_PLUGIN_FIND_MATCHER == 1 + class FindMatcher : public boost::noncopyable + { + private: + OrthancPluginFindMatcher* matcher_; + const OrthancPluginWorklistQuery* worklist_; + + void SetupDicom(const void* query, + uint32_t size); + + public: + explicit FindMatcher(const OrthancPluginWorklistQuery* worklist); + + FindMatcher(const void* query, + uint32_t size) + { + SetupDicom(query, size); + } + + explicit FindMatcher(const MemoryBuffer& dicom) + { + SetupDicom(dicom.GetData(), dicom.GetSize()); + } + + ~FindMatcher(); + + bool IsMatch(const void* dicom, + uint32_t size) const; + + bool IsMatch(const MemoryBuffer& dicom) const + { + return IsMatch(dicom.GetData(), dicom.GetSize()); + } + }; +#endif + + + bool ReadJson(Json::Value& target, + const std::string& source); + + bool ReadJson(Json::Value& target, + const void* buffer, + size_t size); + + bool ReadJsonWithoutComments(Json::Value& target, + const std::string& source); + + bool ReadJsonWithoutComments(Json::Value& target, + const void* buffer, + size_t size); + + void WriteFastJson(std::string& target, + const Json::Value& source); + + void WriteStyledJson(std::string& target, + const Json::Value& source); + + bool RestApiGet(Json::Value& result, + const std::string& uri, + bool applyPlugins); + + bool RestApiGet(Json::Value& result, + const std::string& uri, + const std::map& httpHeaders, + bool applyPlugins); + + bool RestApiGetString(std::string& result, + const std::string& uri, + bool applyPlugins); + + bool RestApiGetString(std::string& result, + const std::string& uri, + const std::map& httpHeaders, + bool applyPlugins); + + bool RestApiPost(std::string& result, + const std::string& uri, + const void* body, + size_t bodySize, + bool applyPlugins); + + bool RestApiPost(Json::Value& result, + const std::string& uri, + const void* body, + size_t bodySize, + bool applyPlugins); + +#if HAS_ORTHANC_PLUGIN_GENERIC_CALL_REST_API == 1 + bool RestApiPost(Json::Value& result, + const std::string& uri, + const Json::Value& body, + const std::map& httpHeaders, + bool applyPlugins); +#endif + + bool RestApiPost(Json::Value& result, + const std::string& uri, + const Json::Value& body, + bool applyPlugins); + + inline bool RestApiPost(Json::Value& result, + const std::string& uri, + const std::string& body, + bool applyPlugins) + { + return RestApiPost(result, uri, body.empty() ? NULL : body.c_str(), + body.size(), applyPlugins); + } + + inline bool RestApiPost(Json::Value& result, + const std::string& uri, + const MemoryBuffer& body, + bool applyPlugins) + { + return RestApiPost(result, uri, body.GetData(), + body.GetSize(), applyPlugins); + } + + bool RestApiPut(Json::Value& result, + const std::string& uri, + const void* body, + size_t bodySize, + bool applyPlugins); + + bool RestApiPut(Json::Value& result, + const std::string& uri, + const Json::Value& body, + bool applyPlugins); + + inline bool RestApiPut(Json::Value& result, + const std::string& uri, + const std::string& body, + bool applyPlugins) + { + return RestApiPut(result, uri, body.empty() ? NULL : body.c_str(), + body.size(), applyPlugins); + } + + bool RestApiDelete(const std::string& uri, + bool applyPlugins); + + bool HttpDelete(const std::string& url, + const std::string& username, + const std::string& password); + + void AnswerJson(const Json::Value& value, + OrthancPluginRestOutput* output); + + void AnswerString(const std::string& answer, + const char* mimeType, + OrthancPluginRestOutput* output); + + void AnswerHttpError(uint16_t httpError, + OrthancPluginRestOutput* output); + + void AnswerMethodNotAllowed(OrthancPluginRestOutput* output, const char* allowedMethods); + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 5, 0) + const char* AutodetectMimeType(const std::string& path); +#endif + +#if HAS_ORTHANC_PLUGIN_LOG_MESSAGE == 1 + void LogMessage(OrthancPluginLogLevel level, + const char* file, + uint32_t line, + const std::string& message); +#endif + +#if HAS_ORTHANC_PLUGIN_LOG_MESSAGE == 1 + // Use macro ORTHANC_PLUGINS_LOG_ERROR() instead + ORTHANC_PLUGIN_CPP_WRAPPER_DEPRECATED(void LogError(const std::string& message)); +#else + void LogError(const std::string& message); +#endif + +#if HAS_ORTHANC_PLUGIN_LOG_MESSAGE == 1 + // Use macro ORTHANC_PLUGINS_LOG_WARNING() instead + ORTHANC_PLUGIN_CPP_WRAPPER_DEPRECATED(void LogWarning(const std::string& message)); +#else + void LogWarning(const std::string& message); +#endif + +#if HAS_ORTHANC_PLUGIN_LOG_MESSAGE == 1 + // Use macro ORTHANC_PLUGINS_LOG_INFO() instead + ORTHANC_PLUGIN_CPP_WRAPPER_DEPRECATED(void LogInfo(const std::string& message)); +#else + void LogInfo(const std::string& message); +#endif + + void ReportMinimalOrthancVersion(unsigned int major, + unsigned int minor, + unsigned int revision); + + bool CheckMinimalOrthancVersion(unsigned int major, + unsigned int minor, + unsigned int revision); + + bool CheckMinimalVersion(const char* version, + unsigned int major, + unsigned int minor, + unsigned int revision); + + namespace Internals + { + template + static OrthancPluginErrorCode Protect(OrthancPluginRestOutput* output, + const char* url, + const OrthancPluginHttpRequest* request) + { + try + { + Callback(output, url, request); + return OrthancPluginErrorCode_Success; + } + catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) + { +#if HAS_ORTHANC_EXCEPTION == 1 && HAS_ORTHANC_PLUGIN_EXCEPTION_DETAILS == 1 + if (HasGlobalContext() && + e.HasDetails()) + { + // The "false" instructs Orthanc not to log the detailed + // error message. This is to avoid duplicating the details, + // because "OrthancException" already does it on construction. + OrthancPluginSetHttpErrorDetails + (GetGlobalContext(), output, e.GetDetails(), false); + } +#endif + + return static_cast(e.GetErrorCode()); + } + catch (boost::bad_lexical_cast&) + { + return OrthancPluginErrorCode_BadFileFormat; + } + catch (...) + { + return OrthancPluginErrorCode_Plugin; + } + } + } + + + template + void RegisterRestCallback(const std::string& uri, + bool isThreadSafe) + { + if (isThreadSafe) + { + OrthancPluginRegisterRestCallbackNoLock + (GetGlobalContext(), uri.c_str(), Internals::Protect); + } + else + { + OrthancPluginRegisterRestCallback + (GetGlobalContext(), uri.c_str(), Internals::Protect); + } + } + + +#if HAS_ORTHANC_PLUGIN_PEERS == 1 + class OrthancPeers : public boost::noncopyable + { + private: + typedef std::map Index; + + OrthancPluginPeers *peers_; + Index index_; + uint32_t timeout_; + + size_t GetPeerIndex(const std::string& name) const; + + public: + OrthancPeers(); + + ~OrthancPeers(); + + uint32_t GetTimeout() const + { + return timeout_; + } + + void SetTimeout(uint32_t timeout) + { + timeout_ = timeout; + } + + bool LookupName(size_t& target, + const std::string& name) const; + + std::string GetPeerName(size_t index) const; + + std::string GetPeerUrl(size_t index) const; + + std::string GetPeerUrl(const std::string& name) const; + + size_t GetPeersCount() const + { + return index_.size(); + } + + bool LookupUserProperty(std::string& value, + size_t index, + const std::string& key) const; + + bool LookupUserProperty(std::string& value, + const std::string& peer, + const std::string& key) const; + + bool DoGet(MemoryBuffer& target, + size_t index, + const std::string& uri, + const std::map& headers) const; + + bool DoGet(MemoryBuffer& target, + const std::string& name, + const std::string& uri, + const std::map& headers) const; + + bool DoGet(Json::Value& target, + size_t index, + const std::string& uri, + const std::map& headers) const; + + bool DoGet(Json::Value& target, + const std::string& name, + const std::string& uri, + const std::map& headers) const; + + bool DoPost(MemoryBuffer& target, + size_t index, + const std::string& uri, + const std::string& body, + const std::map& headers) const; + + bool DoPost(MemoryBuffer& target, + const std::string& name, + const std::string& uri, + const std::string& body, + const std::map& headers) const; + + bool DoPost(Json::Value& target, + size_t index, + const std::string& uri, + const std::string& body, + const std::map& headers) const; + + bool DoPost(Json::Value& target, + const std::string& name, + const std::string& uri, + const std::string& body, + const std::map& headers) const; + + bool DoPut(size_t index, + const std::string& uri, + const std::string& body, + const std::map& headers) const; + + bool DoPut(const std::string& name, + const std::string& uri, + const std::string& body, + const std::map& headers) const; + + bool DoDelete(size_t index, + const std::string& uri, + const std::map& headers) const; + + bool DoDelete(const std::string& name, + const std::string& uri, + const std::map& headers) const; + }; +#endif + + + +#if HAS_ORTHANC_PLUGIN_JOB == 1 + class OrthancJob : public boost::noncopyable + { + private: + std::string jobType_; + std::string content_; + bool hasSerialized_; + std::string serialized_; + float progress_; + + static void CallbackFinalize(void* job); + + static float CallbackGetProgress(void* job); + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 11, 3) + static OrthancPluginErrorCode CallbackGetContent(OrthancPluginMemoryBuffer* target, + void* job); +#else + static const char* CallbackGetContent(void* job); +#endif + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 11, 3) + static int32_t CallbackGetSerialized(OrthancPluginMemoryBuffer* target, + void* job); +#else + static const char* CallbackGetSerialized(void* job); +#endif + + static OrthancPluginJobStepStatus CallbackStep(void* job); + + static OrthancPluginErrorCode CallbackStop(void* job, + OrthancPluginJobStopReason reason); + + static OrthancPluginErrorCode CallbackReset(void* job); + + protected: + void ClearContent(); + + void UpdateContent(const Json::Value& content); + + void ClearSerialized(); + + void UpdateSerialized(const Json::Value& serialized); + + void UpdateProgress(float progress); + + public: + explicit OrthancJob(const std::string& jobType); + + virtual ~OrthancJob() + { + } + + virtual OrthancPluginJobStepStatus Step() = 0; + + virtual void Stop(OrthancPluginJobStopReason reason) = 0; + + virtual void Reset() = 0; + + static OrthancPluginJob* Create(OrthancJob* job /* takes ownership */); + + static std::string Submit(OrthancJob* job /* takes ownership */, + int priority); + + static void SubmitAndWait(Json::Value& result, + OrthancJob* job /* takes ownership */, + int priority); + + // Submit a job from a POST on the REST API with the same + // conventions as in the Orthanc core (according to the + // "Synchronous" and "Priority" options) + static void SubmitFromRestApiPost(OrthancPluginRestOutput* output, + const Json::Value& body, + OrthancJob* job); + }; +#endif + + +#if HAS_ORTHANC_PLUGIN_METRICS == 1 + inline void SetMetricsValue(char* name, + float value) + { + OrthancPluginSetMetricsValue(GetGlobalContext(), name, + value, OrthancPluginMetricsType_Default); + } + + class MetricsTimer : public boost::noncopyable + { + private: + std::string name_; + boost::posix_time::ptime start_; + + public: + explicit MetricsTimer(const char* name); + + ~MetricsTimer(); + }; +#endif + + +#if HAS_ORTHANC_PLUGIN_HTTP_CLIENT == 1 + class HttpClient : public boost::noncopyable + { + public: + typedef std::map HttpHeaders; + + class IRequestBody : public boost::noncopyable + { + public: + virtual ~IRequestBody() + { + } + + virtual bool ReadNextChunk(std::string& chunk) = 0; + }; + + + class IAnswer : public boost::noncopyable + { + public: + virtual ~IAnswer() + { + } + + virtual void AddHeader(const std::string& key, + const std::string& value) = 0; + + virtual void AddChunk(const void* data, + size_t size) = 0; + }; + + + private: + class RequestBodyWrapper; + + uint16_t httpStatus_; + OrthancPluginHttpMethod method_; + std::string url_; + HttpHeaders headers_; + std::string username_; + std::string password_; + uint32_t timeout_; + std::string certificateFile_; + std::string certificateKeyFile_; + std::string certificateKeyPassword_; + bool pkcs11_; + std::string fullBody_; + IRequestBody* chunkedBody_; + bool allowChunkedTransfers_; + +#if HAS_ORTHANC_PLUGIN_CHUNKED_HTTP_CLIENT == 1 + void ExecuteWithStream(uint16_t& httpStatus, // out + IAnswer& answer, // out + IRequestBody& body) const; +#endif + + void ExecuteWithoutStream(uint16_t& httpStatus, // out + HttpHeaders& answerHeaders, // out + std::string& answerBody, // out + const std::string& body) const; + + public: + HttpClient(); + + uint16_t GetHttpStatus() const + { + return httpStatus_; + } + + void SetMethod(OrthancPluginHttpMethod method) + { + method_ = method; + } + + const std::string& GetUrl() const + { + return url_; + } + + void SetUrl(const std::string& url) + { + url_ = url; + } + + void SetHeaders(const HttpHeaders& headers) + { + headers_ = headers; + } + + void AddHeader(const std::string& key, + const std::string& value) + { + headers_[key] = value; + } + + void AddHeaders(const HttpHeaders& headers); + + void SetCredentials(const std::string& username, + const std::string& password); + + void ClearCredentials(); + + void SetTimeout(unsigned int timeout) // 0 for default timeout + { + timeout_ = timeout; + } + + void SetCertificate(const std::string& certificateFile, + const std::string& keyFile, + const std::string& keyPassword); + + void ClearCertificate(); + + void SetPkcs11(bool pkcs11) + { + pkcs11_ = pkcs11; + } + + void ClearBody(); + + void SwapBody(std::string& body); + + void SetBody(const std::string& body); + + void SetBody(IRequestBody& body); + + // This function can be used to disable chunked transfers if the + // remote server is Orthanc with a version <= 1.5.6. + void SetChunkedTransfersAllowed(bool allow) + { + allowChunkedTransfers_ = allow; + } + + bool IsChunkedTransfersAllowed() const + { + return allowChunkedTransfers_; + } + + void Execute(IAnswer& answer); + + void Execute(HttpHeaders& answerHeaders /* out */, + std::string& answerBody /* out */); + + void Execute(HttpHeaders& answerHeaders /* out */, + Json::Value& answerBody /* out */); + + void Execute(); + }; +#endif + + + + class IChunkedRequestReader : public boost::noncopyable + { + public: + virtual ~IChunkedRequestReader() + { + } + + virtual void AddChunk(const void* data, + size_t size) = 0; + + virtual void Execute(OrthancPluginRestOutput* output) = 0; + }; + + + typedef IChunkedRequestReader* (*ChunkedRestCallback) (const char* url, + const OrthancPluginHttpRequest* request); + + + namespace Internals + { + void NullRestCallback(OrthancPluginRestOutput* output, + const char* url, + const OrthancPluginHttpRequest* request); + + IChunkedRequestReader *NullChunkedRestCallback(const char* url, + const OrthancPluginHttpRequest* request); + + +#if HAS_ORTHANC_PLUGIN_CHUNKED_HTTP_SERVER == 1 + template + static OrthancPluginErrorCode ChunkedProtect(OrthancPluginServerChunkedRequestReader** reader, + const char* url, + const OrthancPluginHttpRequest* request) + { + try + { + if (reader == NULL) + { + return OrthancPluginErrorCode_InternalError; + } + else + { + *reader = reinterpret_cast(Callback(url, request)); + if (*reader == NULL) + { + return OrthancPluginErrorCode_Plugin; + } + else + { + return OrthancPluginErrorCode_Success; + } + } + } + catch (ORTHANC_PLUGINS_EXCEPTION_CLASS& e) + { + return static_cast(e.GetErrorCode()); + } + catch (boost::bad_lexical_cast&) + { + return OrthancPluginErrorCode_BadFileFormat; + } + catch (...) + { + return OrthancPluginErrorCode_Plugin; + } + } + + OrthancPluginErrorCode ChunkedRequestReaderAddChunk( + OrthancPluginServerChunkedRequestReader* reader, + const void* data, + uint32_t size); + + OrthancPluginErrorCode ChunkedRequestReaderExecute( + OrthancPluginServerChunkedRequestReader* reader, + OrthancPluginRestOutput* output); + + void ChunkedRequestReaderFinalize( + OrthancPluginServerChunkedRequestReader* reader); + +#else + + OrthancPluginErrorCode ChunkedRestCompatibility(OrthancPluginRestOutput* output, + const char* url, + const OrthancPluginHttpRequest* request, + RestCallback GetHandler, + ChunkedRestCallback PostHandler, + RestCallback DeleteHandler, + ChunkedRestCallback PutHandler); + + template< + RestCallback GetHandler, + ChunkedRestCallback PostHandler, + RestCallback DeleteHandler, + ChunkedRestCallback PutHandler + > + inline OrthancPluginErrorCode ChunkedRestCompatibility(OrthancPluginRestOutput* output, + const char* url, + const OrthancPluginHttpRequest* request) + { + return ChunkedRestCompatibility(output, url, request, GetHandler, + PostHandler, DeleteHandler, PutHandler); + } +#endif + } + + + + // NB: We use a templated class instead of a templated function, because + // default values are only available in functions since C++11 + template< + RestCallback GetHandler = Internals::NullRestCallback, + ChunkedRestCallback PostHandler = Internals::NullChunkedRestCallback, + RestCallback DeleteHandler = Internals::NullRestCallback, + ChunkedRestCallback PutHandler = Internals::NullChunkedRestCallback + > + class ChunkedRestRegistration : public boost::noncopyable + { + public: + static void Apply(const std::string& uri) + { +#if HAS_ORTHANC_PLUGIN_CHUNKED_HTTP_SERVER == 1 + OrthancPluginRegisterChunkedRestCallback( + GetGlobalContext(), uri.c_str(), + GetHandler == Internals::NullRestCallback ? NULL : Internals::Protect, + PostHandler == Internals::NullChunkedRestCallback ? NULL : Internals::ChunkedProtect, + DeleteHandler == Internals::NullRestCallback ? NULL : Internals::Protect, + PutHandler == Internals::NullChunkedRestCallback ? NULL : Internals::ChunkedProtect, + Internals::ChunkedRequestReaderAddChunk, + Internals::ChunkedRequestReaderExecute, + Internals::ChunkedRequestReaderFinalize); +#else + OrthancPluginRegisterRestCallbackNoLock( + GetGlobalContext(), uri.c_str(), + Internals::ChunkedRestCompatibility); +#endif + } + }; + + + +#if HAS_ORTHANC_PLUGIN_STORAGE_COMMITMENT_SCP == 1 + class IStorageCommitmentScpHandler : public boost::noncopyable + { + public: + virtual ~IStorageCommitmentScpHandler() + { + } + + virtual OrthancPluginStorageCommitmentFailureReason Lookup(const std::string& sopClassUid, + const std::string& sopInstanceUid) = 0; + + static OrthancPluginErrorCode Lookup(OrthancPluginStorageCommitmentFailureReason* target, + void* rawHandler, + const char* sopClassUid, + const char* sopInstanceUid); + + static void Destructor(void* rawHandler); + }; +#endif + + + class DicomInstance : public boost::noncopyable + { + private: + bool toFree_; + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 6, 1) + const OrthancPluginDicomInstance* instance_; +#else + OrthancPluginDicomInstance* instance_; +#endif + + public: +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 6, 1) + explicit DicomInstance(const OrthancPluginDicomInstance* instance); +#else + explicit DicomInstance(OrthancPluginDicomInstance* instance); +#endif + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 7, 0) + DicomInstance(const void* buffer, + size_t size); +#endif + + ~DicomInstance(); + + const OrthancPluginDicomInstance* GetObject() const + { + return instance_; + } + + std::string GetRemoteAet() const; + + const void* GetBuffer() const + { + return OrthancPluginGetInstanceData(GetGlobalContext(), instance_); + } + + size_t GetSize() const + { + return static_cast(OrthancPluginGetInstanceSize(GetGlobalContext(), instance_)); + } + + void GetJson(Json::Value& target) const; + + void GetSimplifiedJson(Json::Value& target) const; + + OrthancPluginInstanceOrigin GetOrigin() const + { + return OrthancPluginGetInstanceOrigin(GetGlobalContext(), instance_); + } + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 6, 1) + std::string GetTransferSyntaxUid() const; +#endif + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 6, 1) + bool HasPixelData() const; +#endif + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 7, 0) + unsigned int GetFramesCount() const + { + return OrthancPluginGetInstanceFramesCount(GetGlobalContext(), instance_); + } +#endif + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 7, 0) + void GetRawFrame(std::string& target, + unsigned int frameIndex) const; +#endif + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 7, 0) + OrthancImage* GetDecodedFrame(unsigned int frameIndex) const; +#endif + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 7, 0) + void Serialize(std::string& target) const; +#endif + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 7, 0) + static DicomInstance* Transcode(const void* buffer, + size_t size, + const std::string& transferSyntax); +#endif + +#if ORTHANC_PLUGINS_VERSION_IS_ABOVE(1, 12, 1) + static DicomInstance* Load(const std::string& instanceId, + OrthancPluginLoadDicomInstanceMode mode); +#endif + }; + +// helper method to convert Http headers from the plugin SDK to a std::map +void GetHttpHeaders(std::map& result, const OrthancPluginHttpRequest* request); + +#if HAS_ORTHANC_PLUGIN_WEBDAV == 1 + class IWebDavCollection : public boost::noncopyable + { + public: + class FileInfo + { + private: + std::string name_; + uint64_t contentSize_; + std::string mime_; + std::string dateTime_; + + public: + FileInfo(const std::string& name, + uint64_t contentSize, + const std::string& dateTime) : + name_(name), + contentSize_(contentSize), + dateTime_(dateTime) + { + } + + const std::string& GetName() const + { + return name_; + } + + uint64_t GetContentSize() const + { + return contentSize_; + } + + void SetMimeType(const std::string& mime) + { + mime_ = mime; + } + + const std::string& GetMimeType() const + { + return mime_; + } + + const std::string& GetDateTime() const + { + return dateTime_; + } + }; + + class FolderInfo + { + private: + std::string name_; + std::string dateTime_; + + public: + FolderInfo(const std::string& name, + const std::string& dateTime) : + name_(name), + dateTime_(dateTime) + { + } + + const std::string& GetName() const + { + return name_; + } + + const std::string& GetDateTime() const + { + return dateTime_; + } + }; + + virtual ~IWebDavCollection() + { + } + + virtual bool IsExistingFolder(const std::vector& path) = 0; + + virtual bool ListFolder(std::list& files, + std::list& subfolders, + const std::vector& path) = 0; + + virtual bool GetFile(std::string& content /* out */, + std::string& mime /* out */, + std::string& dateTime /* out */, + const std::vector& path) = 0; + + virtual bool StoreFile(const std::vector& path, + const void* data, + size_t size) = 0; + + virtual bool CreateFolder(const std::vector& path) = 0; + + virtual bool DeleteItem(const std::vector& path) = 0; + + static void Register(const std::string& uri, + IWebDavCollection& collection); + }; +#endif + + void SetRootUri(const std::string& pluginIdentifier, + const std::string& uri); + + void SetDescription(const std::string& pluginIdentifier, + const std::string& description); + + void ExtendOrthancExplorer(const std::string& pluginIdentifier, + const std::string& javascript); +} diff --git a/Resources/Orthanc/Plugins/OrthancPluginException.h b/Resources/Orthanc/Plugins/OrthancPluginException.h new file mode 100644 index 0000000..eac5b13 --- /dev/null +++ b/Resources/Orthanc/Plugins/OrthancPluginException.h @@ -0,0 +1,91 @@ +/** + * Orthanc - A Lightweight, RESTful DICOM Store + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2023 Osimis S.A., Belgium + * Copyright (C) 2024-2024 Orthanc Team SRL, Belgium + * Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + **/ + + +#pragma once + +#if !defined(HAS_ORTHANC_EXCEPTION) +# error The macro HAS_ORTHANC_EXCEPTION must be defined +#endif + + +#if HAS_ORTHANC_EXCEPTION == 1 +# include +# define ORTHANC_PLUGINS_ERROR_ENUMERATION ::Orthanc::ErrorCode +# define ORTHANC_PLUGINS_EXCEPTION_CLASS ::Orthanc::OrthancException +# define ORTHANC_PLUGINS_GET_ERROR_CODE(code) ::Orthanc::ErrorCode_ ## code +#else +# include +# define ORTHANC_PLUGINS_ERROR_ENUMERATION ::OrthancPluginErrorCode +# define ORTHANC_PLUGINS_EXCEPTION_CLASS ::OrthancPlugins::PluginException +# define ORTHANC_PLUGINS_GET_ERROR_CODE(code) ::OrthancPluginErrorCode_ ## code +#endif + + +#define ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(code) \ + throw ORTHANC_PLUGINS_EXCEPTION_CLASS(static_cast(code)); + + +#define ORTHANC_PLUGINS_THROW_EXCEPTION(code) \ + throw ORTHANC_PLUGINS_EXCEPTION_CLASS(ORTHANC_PLUGINS_GET_ERROR_CODE(code)); + + +#define ORTHANC_PLUGINS_CHECK_ERROR(code) \ + if (code != ORTHANC_PLUGINS_GET_ERROR_CODE(Success)) \ + { \ + ORTHANC_PLUGINS_THROW_EXCEPTION(code); \ + } + + +namespace OrthancPlugins +{ +#if HAS_ORTHANC_EXCEPTION == 0 + class PluginException + { + private: + OrthancPluginErrorCode code_; + + public: + explicit PluginException(OrthancPluginErrorCode code) : code_(code) + { + } + + OrthancPluginErrorCode GetErrorCode() const + { + return code_; + } + + const char* What(OrthancPluginContext* context) const + { + const char* description = OrthancPluginGetErrorDescription(context, code_); + if (description) + { + return description; + } + else + { + return "No description available"; + } + } + }; +#endif +} diff --git a/Resources/Orthanc/Plugins/OrthancPluginsExports.cmake b/Resources/Orthanc/Plugins/OrthancPluginsExports.cmake new file mode 100644 index 0000000..4f46d8c --- /dev/null +++ b/Resources/Orthanc/Plugins/OrthancPluginsExports.cmake @@ -0,0 +1,33 @@ +# Orthanc - A Lightweight, RESTful DICOM Store +# Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics +# Department, University Hospital of Liege, Belgium +# Copyright (C) 2017-2023 Osimis S.A., Belgium +# Copyright (C) 2024-2024 Orthanc Team SRL, Belgium +# Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium +# +# This program is free software: you can redistribute it and/or +# modify it under the terms of the GNU General Public License as +# published by the Free Software Foundation, either version 3 of the +# License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + + +# In Orthanc <= 1.7.1, the instructions below were part of +# "Compiler.cmake", and were protected by the (now unused) option +# "ENABLE_PLUGINS_VERSION_SCRIPT" in CMake + +if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux" OR + ${CMAKE_SYSTEM_NAME} STREQUAL "kFreeBSD" OR + ${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD" OR + ${CMAKE_SYSTEM_NAME} STREQUAL "OpenBSD") + set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--version-script=${CMAKE_CURRENT_LIST_DIR}/VersionScriptPlugins.map") +elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Darwin") + set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -exported_symbols_list ${CMAKE_CURRENT_LIST_DIR}/ExportedSymbolsPlugins.list") +endif() diff --git a/Resources/Orthanc/Plugins/VersionScriptPlugins.map b/Resources/Orthanc/Plugins/VersionScriptPlugins.map new file mode 100644 index 0000000..f36033b --- /dev/null +++ b/Resources/Orthanc/Plugins/VersionScriptPlugins.map @@ -0,0 +1,12 @@ +# This is a version-script for Orthanc plugins + +{ +global: + OrthancPluginInitialize; + OrthancPluginFinalize; + OrthancPluginGetName; + OrthancPluginGetVersion; + +local: + *; +}; diff --git a/Resources/Orthanc/README.txt b/Resources/Orthanc/README.txt new file mode 100644 index 0000000..0162afe --- /dev/null +++ b/Resources/Orthanc/README.txt @@ -0,0 +1,2 @@ +This folder contains an excerpt of the source code of Orthanc. It is +automatically generated using the "../SyncOrthancFolder.py" script. diff --git a/Resources/Orthanc/Sdk-1.11.2/orthanc/OrthancCPlugin.h b/Resources/Orthanc/Sdk-1.11.2/orthanc/OrthancCPlugin.h new file mode 100644 index 0000000..9424959 --- /dev/null +++ b/Resources/Orthanc/Sdk-1.11.2/orthanc/OrthancCPlugin.h @@ -0,0 +1,9043 @@ +/** + * \mainpage + * + * This C/C++ SDK allows external developers to create plugins that + * can be loaded into Orthanc to extend its functionality. Each + * Orthanc plugin must expose 4 public functions with the following + * signatures: + * + * -# int32_t OrthancPluginInitialize(const OrthancPluginContext* context): + * This function is invoked by Orthanc when it loads the plugin on startup. + * The plugin must: + * - Check its compatibility with the Orthanc version using + * ::OrthancPluginCheckVersion(). + * - Store the context pointer so that it can use the plugin + * services of Orthanc. + * - Register all its REST callbacks using ::OrthancPluginRegisterRestCallback(). + * - Possibly register its callback for received DICOM instances using ::OrthancPluginRegisterOnStoredInstanceCallback(). + * - Possibly register its callback for changes to the DICOM store using ::OrthancPluginRegisterOnChangeCallback(). + * - Possibly register a custom storage area using ::OrthancPluginRegisterStorageArea2(). + * - Possibly register a custom database back-end area using OrthancPluginRegisterDatabaseBackendV3(). + * - Possibly register a handler for C-Find SCP using OrthancPluginRegisterFindCallback(). + * - Possibly register a handler for C-Find SCP against DICOM worklists using OrthancPluginRegisterWorklistCallback(). + * - Possibly register a handler for C-Move SCP using OrthancPluginRegisterMoveCallback(). + * - Possibly register a custom decoder for DICOM images using OrthancPluginRegisterDecodeImageCallback(). + * - Possibly register a callback to filter incoming HTTP requests using OrthancPluginRegisterIncomingHttpRequestFilter2(). + * - Possibly register a callback to unserialize jobs using OrthancPluginRegisterJobsUnserializer(). + * - Possibly register a callback to refresh its metrics using OrthancPluginRegisterRefreshMetricsCallback(). + * - Possibly register a callback to answer chunked HTTP transfers using ::OrthancPluginRegisterChunkedRestCallback(). + * - Possibly register a callback for Storage Commitment SCP using ::OrthancPluginRegisterStorageCommitmentScpCallback(). + * - Possibly register a callback to keep/discard/modify incoming DICOM instances using OrthancPluginRegisterReceivedInstanceCallback(). + * - Possibly register a custom transcoder for DICOM images using OrthancPluginRegisterTranscoderCallback(). + * - Possibly register a callback to discard instances received through DICOM C-STORE using OrthancPluginRegisterIncomingCStoreInstanceFilter(). + * - Possibly register a callback to branch a WebDAV virtual filesystem using OrthancPluginRegisterWebDavCollection(). + * -# void OrthancPluginFinalize(): + * This function is invoked by Orthanc during its shutdown. The plugin + * must free all its memory. + * -# const char* OrthancPluginGetName(): + * The plugin must return a short string to identify itself. + * -# const char* OrthancPluginGetVersion(): + * The plugin must return a string containing its version number. + * + * The name and the version of a plugin is only used to prevent it + * from being loaded twice. Note that, in C++, it is mandatory to + * declare these functions within an extern "C" section. + * + * To ensure multi-threading safety, the various REST callbacks are + * guaranteed to be executed in mutual exclusion since Orthanc + * 0.8.5. If this feature is undesired (notably when developing + * high-performance plugins handling simultaneous requests), use + * ::OrthancPluginRegisterRestCallbackNoLock(). + **/ + + + +/** + * @defgroup Images Images and compression + * @brief Functions to deal with images and compressed buffers. + * + * @defgroup REST REST + * @brief Functions to answer REST requests in a callback. + * + * @defgroup Callbacks Callbacks + * @brief Functions to register and manage callbacks by the plugins. + * + * @defgroup DicomCallbacks DicomCallbacks + * @brief Functions to register and manage DICOM callbacks (worklists, C-FIND, C-MOVE, storage commitment). + * + * @defgroup Orthanc Orthanc + * @brief Functions to access the content of the Orthanc server. + * + * @defgroup DicomInstance DicomInstance + * @brief Functions to access DICOM images that are managed by the Orthanc core. + **/ + + + +/** + * @defgroup Toolbox Toolbox + * @brief Generic functions to help with the creation of plugins. + **/ + + + +/** + * Orthanc - A Lightweight, RESTful DICOM Store + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2022 Osimis S.A., Belgium + * Copyright (C) 2021-2022 Sebastien Jodogne, ICTEAM UCLouvain, Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + **/ + + + +#pragma once + + +#include +#include + +#ifdef WIN32 +# define ORTHANC_PLUGINS_API __declspec(dllexport) +#elif __GNUC__ >= 4 +# define ORTHANC_PLUGINS_API __attribute__ ((visibility ("default"))) +#else +# define ORTHANC_PLUGINS_API +#endif + +#define ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER 1 +#define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER 11 +#define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER 2 + + +#if !defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE) +#define ORTHANC_PLUGINS_VERSION_IS_ABOVE(major, minor, revision) \ + (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER > major || \ + (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER == major && \ + (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER > minor || \ + (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER == minor && \ + ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER >= revision)))) +#endif + + + +/******************************************************************** + ** Check that function inlining is properly supported. The use of + ** inlining is required, to avoid the duplication of object code + ** between two compilation modules that would use the Orthanc Plugin + ** API. + ********************************************************************/ + +/* If the auto-detection of the "inline" keyword below does not work + automatically and that your compiler is known to properly support + inlining, uncomment the following #define and adapt the definition + of "static inline". */ + +/* #define ORTHANC_PLUGIN_INLINE static inline */ + +#ifndef ORTHANC_PLUGIN_INLINE +# if __STDC_VERSION__ >= 199901L +/* This is C99 or above: http://predef.sourceforge.net/prestd.html */ +# define ORTHANC_PLUGIN_INLINE static inline +# elif defined(__cplusplus) +/* This is C++ */ +# define ORTHANC_PLUGIN_INLINE static inline +# elif defined(__GNUC__) +/* This is GCC running in C89 mode */ +# define ORTHANC_PLUGIN_INLINE static __inline +# elif defined(_MSC_VER) +/* This is Visual Studio running in C89 mode */ +# define ORTHANC_PLUGIN_INLINE static __inline +# else +# error Your compiler is not known to support the "inline" keyword +# endif +#endif + + + +/******************************************************************** + ** Inclusion of standard libraries. + ********************************************************************/ + +/** + * For Microsoft Visual Studio, a compatibility "stdint.h" can be + * downloaded at the following URL: + * https://hg.orthanc-server.com/orthanc/raw-file/tip/Resources/ThirdParty/VisualStudio/stdint.h + **/ +#include + +#include + + + +/******************************************************************** + ** Definition of the Orthanc Plugin API. + ********************************************************************/ + +/** @{ */ + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** + * The various error codes that can be returned by the Orthanc core. + **/ + typedef enum + { + OrthancPluginErrorCode_InternalError = -1 /*!< Internal error */, + OrthancPluginErrorCode_Success = 0 /*!< Success */, + OrthancPluginErrorCode_Plugin = 1 /*!< Error encountered within the plugin engine */, + OrthancPluginErrorCode_NotImplemented = 2 /*!< Not implemented yet */, + OrthancPluginErrorCode_ParameterOutOfRange = 3 /*!< Parameter out of range */, + OrthancPluginErrorCode_NotEnoughMemory = 4 /*!< The server hosting Orthanc is running out of memory */, + OrthancPluginErrorCode_BadParameterType = 5 /*!< Bad type for a parameter */, + OrthancPluginErrorCode_BadSequenceOfCalls = 6 /*!< Bad sequence of calls */, + OrthancPluginErrorCode_InexistentItem = 7 /*!< Accessing an inexistent item */, + OrthancPluginErrorCode_BadRequest = 8 /*!< Bad request */, + OrthancPluginErrorCode_NetworkProtocol = 9 /*!< Error in the network protocol */, + OrthancPluginErrorCode_SystemCommand = 10 /*!< Error while calling a system command */, + OrthancPluginErrorCode_Database = 11 /*!< Error with the database engine */, + OrthancPluginErrorCode_UriSyntax = 12 /*!< Badly formatted URI */, + OrthancPluginErrorCode_InexistentFile = 13 /*!< Inexistent file */, + OrthancPluginErrorCode_CannotWriteFile = 14 /*!< Cannot write to file */, + OrthancPluginErrorCode_BadFileFormat = 15 /*!< Bad file format */, + OrthancPluginErrorCode_Timeout = 16 /*!< Timeout */, + OrthancPluginErrorCode_UnknownResource = 17 /*!< Unknown resource */, + OrthancPluginErrorCode_IncompatibleDatabaseVersion = 18 /*!< Incompatible version of the database */, + OrthancPluginErrorCode_FullStorage = 19 /*!< The file storage is full */, + OrthancPluginErrorCode_CorruptedFile = 20 /*!< Corrupted file (e.g. inconsistent MD5 hash) */, + OrthancPluginErrorCode_InexistentTag = 21 /*!< Inexistent tag */, + OrthancPluginErrorCode_ReadOnly = 22 /*!< Cannot modify a read-only data structure */, + OrthancPluginErrorCode_IncompatibleImageFormat = 23 /*!< Incompatible format of the images */, + OrthancPluginErrorCode_IncompatibleImageSize = 24 /*!< Incompatible size of the images */, + OrthancPluginErrorCode_SharedLibrary = 25 /*!< Error while using a shared library (plugin) */, + OrthancPluginErrorCode_UnknownPluginService = 26 /*!< Plugin invoking an unknown service */, + OrthancPluginErrorCode_UnknownDicomTag = 27 /*!< Unknown DICOM tag */, + OrthancPluginErrorCode_BadJson = 28 /*!< Cannot parse a JSON document */, + OrthancPluginErrorCode_Unauthorized = 29 /*!< Bad credentials were provided to an HTTP request */, + OrthancPluginErrorCode_BadFont = 30 /*!< Badly formatted font file */, + OrthancPluginErrorCode_DatabasePlugin = 31 /*!< The plugin implementing a custom database back-end does not fulfill the proper interface */, + OrthancPluginErrorCode_StorageAreaPlugin = 32 /*!< Error in the plugin implementing a custom storage area */, + OrthancPluginErrorCode_EmptyRequest = 33 /*!< The request is empty */, + OrthancPluginErrorCode_NotAcceptable = 34 /*!< Cannot send a response which is acceptable according to the Accept HTTP header */, + OrthancPluginErrorCode_NullPointer = 35 /*!< Cannot handle a NULL pointer */, + OrthancPluginErrorCode_DatabaseUnavailable = 36 /*!< The database is currently not available (probably a transient situation) */, + OrthancPluginErrorCode_CanceledJob = 37 /*!< This job was canceled */, + OrthancPluginErrorCode_BadGeometry = 38 /*!< Geometry error encountered in Stone */, + OrthancPluginErrorCode_SslInitialization = 39 /*!< Cannot initialize SSL encryption, check out your certificates */, + OrthancPluginErrorCode_DiscontinuedAbi = 40 /*!< Calling a function that has been removed from the Orthanc Framework */, + OrthancPluginErrorCode_BadRange = 41 /*!< Incorrect range request */, + OrthancPluginErrorCode_DatabaseCannotSerialize = 42 /*!< Database could not serialize access due to concurrent update, the transaction should be retried */, + OrthancPluginErrorCode_Revision = 43 /*!< A bad revision number was provided, which might indicate conflict between multiple writers */, + OrthancPluginErrorCode_MainDicomTagsMultiplyDefined = 44 /*!< A main DICOM Tag has been defined multiple times for the same resource level */, + OrthancPluginErrorCode_SQLiteNotOpened = 1000 /*!< SQLite: The database is not opened */, + OrthancPluginErrorCode_SQLiteAlreadyOpened = 1001 /*!< SQLite: Connection is already open */, + OrthancPluginErrorCode_SQLiteCannotOpen = 1002 /*!< SQLite: Unable to open the database */, + OrthancPluginErrorCode_SQLiteStatementAlreadyUsed = 1003 /*!< SQLite: This cached statement is already being referred to */, + OrthancPluginErrorCode_SQLiteExecute = 1004 /*!< SQLite: Cannot execute a command */, + OrthancPluginErrorCode_SQLiteRollbackWithoutTransaction = 1005 /*!< SQLite: Rolling back a nonexistent transaction (have you called Begin()?) */, + OrthancPluginErrorCode_SQLiteCommitWithoutTransaction = 1006 /*!< SQLite: Committing a nonexistent transaction */, + OrthancPluginErrorCode_SQLiteRegisterFunction = 1007 /*!< SQLite: Unable to register a function */, + OrthancPluginErrorCode_SQLiteFlush = 1008 /*!< SQLite: Unable to flush the database */, + OrthancPluginErrorCode_SQLiteCannotRun = 1009 /*!< SQLite: Cannot run a cached statement */, + OrthancPluginErrorCode_SQLiteCannotStep = 1010 /*!< SQLite: Cannot step over a cached statement */, + OrthancPluginErrorCode_SQLiteBindOutOfRange = 1011 /*!< SQLite: Bing a value while out of range (serious error) */, + OrthancPluginErrorCode_SQLitePrepareStatement = 1012 /*!< SQLite: Cannot prepare a cached statement */, + OrthancPluginErrorCode_SQLiteTransactionAlreadyStarted = 1013 /*!< SQLite: Beginning the same transaction twice */, + OrthancPluginErrorCode_SQLiteTransactionCommit = 1014 /*!< SQLite: Failure when committing the transaction */, + OrthancPluginErrorCode_SQLiteTransactionBegin = 1015 /*!< SQLite: Cannot start a transaction */, + OrthancPluginErrorCode_DirectoryOverFile = 2000 /*!< The directory to be created is already occupied by a regular file */, + OrthancPluginErrorCode_FileStorageCannotWrite = 2001 /*!< Unable to create a subdirectory or a file in the file storage */, + OrthancPluginErrorCode_DirectoryExpected = 2002 /*!< The specified path does not point to a directory */, + OrthancPluginErrorCode_HttpPortInUse = 2003 /*!< The TCP port of the HTTP server is privileged or already in use */, + OrthancPluginErrorCode_DicomPortInUse = 2004 /*!< The TCP port of the DICOM server is privileged or already in use */, + OrthancPluginErrorCode_BadHttpStatusInRest = 2005 /*!< This HTTP status is not allowed in a REST API */, + OrthancPluginErrorCode_RegularFileExpected = 2006 /*!< The specified path does not point to a regular file */, + OrthancPluginErrorCode_PathToExecutable = 2007 /*!< Unable to get the path to the executable */, + OrthancPluginErrorCode_MakeDirectory = 2008 /*!< Cannot create a directory */, + OrthancPluginErrorCode_BadApplicationEntityTitle = 2009 /*!< An application entity title (AET) cannot be empty or be longer than 16 characters */, + OrthancPluginErrorCode_NoCFindHandler = 2010 /*!< No request handler factory for DICOM C-FIND SCP */, + OrthancPluginErrorCode_NoCMoveHandler = 2011 /*!< No request handler factory for DICOM C-MOVE SCP */, + OrthancPluginErrorCode_NoCStoreHandler = 2012 /*!< No request handler factory for DICOM C-STORE SCP */, + OrthancPluginErrorCode_NoApplicationEntityFilter = 2013 /*!< No application entity filter */, + OrthancPluginErrorCode_NoSopClassOrInstance = 2014 /*!< DicomUserConnection: Unable to find the SOP class and instance */, + OrthancPluginErrorCode_NoPresentationContext = 2015 /*!< DicomUserConnection: No acceptable presentation context for modality */, + OrthancPluginErrorCode_DicomFindUnavailable = 2016 /*!< DicomUserConnection: The C-FIND command is not supported by the remote SCP */, + OrthancPluginErrorCode_DicomMoveUnavailable = 2017 /*!< DicomUserConnection: The C-MOVE command is not supported by the remote SCP */, + OrthancPluginErrorCode_CannotStoreInstance = 2018 /*!< Cannot store an instance */, + OrthancPluginErrorCode_CreateDicomNotString = 2019 /*!< Only string values are supported when creating DICOM instances */, + OrthancPluginErrorCode_CreateDicomOverrideTag = 2020 /*!< Trying to override a value inherited from a parent module */, + OrthancPluginErrorCode_CreateDicomUseContent = 2021 /*!< Use \"Content\" to inject an image into a new DICOM instance */, + OrthancPluginErrorCode_CreateDicomNoPayload = 2022 /*!< No payload is present for one instance in the series */, + OrthancPluginErrorCode_CreateDicomUseDataUriScheme = 2023 /*!< The payload of the DICOM instance must be specified according to Data URI scheme */, + OrthancPluginErrorCode_CreateDicomBadParent = 2024 /*!< Trying to attach a new DICOM instance to an inexistent resource */, + OrthancPluginErrorCode_CreateDicomParentIsInstance = 2025 /*!< Trying to attach a new DICOM instance to an instance (must be a series, study or patient) */, + OrthancPluginErrorCode_CreateDicomParentEncoding = 2026 /*!< Unable to get the encoding of the parent resource */, + OrthancPluginErrorCode_UnknownModality = 2027 /*!< Unknown modality */, + OrthancPluginErrorCode_BadJobOrdering = 2028 /*!< Bad ordering of filters in a job */, + OrthancPluginErrorCode_JsonToLuaTable = 2029 /*!< Cannot convert the given JSON object to a Lua table */, + OrthancPluginErrorCode_CannotCreateLua = 2030 /*!< Cannot create the Lua context */, + OrthancPluginErrorCode_CannotExecuteLua = 2031 /*!< Cannot execute a Lua command */, + OrthancPluginErrorCode_LuaAlreadyExecuted = 2032 /*!< Arguments cannot be pushed after the Lua function is executed */, + OrthancPluginErrorCode_LuaBadOutput = 2033 /*!< The Lua function does not give the expected number of outputs */, + OrthancPluginErrorCode_NotLuaPredicate = 2034 /*!< The Lua function is not a predicate (only true/false outputs allowed) */, + OrthancPluginErrorCode_LuaReturnsNoString = 2035 /*!< The Lua function does not return a string */, + OrthancPluginErrorCode_StorageAreaAlreadyRegistered = 2036 /*!< Another plugin has already registered a custom storage area */, + OrthancPluginErrorCode_DatabaseBackendAlreadyRegistered = 2037 /*!< Another plugin has already registered a custom database back-end */, + OrthancPluginErrorCode_DatabaseNotInitialized = 2038 /*!< Plugin trying to call the database during its initialization */, + OrthancPluginErrorCode_SslDisabled = 2039 /*!< Orthanc has been built without SSL support */, + OrthancPluginErrorCode_CannotOrderSlices = 2040 /*!< Unable to order the slices of the series */, + OrthancPluginErrorCode_NoWorklistHandler = 2041 /*!< No request handler factory for DICOM C-Find Modality SCP */, + OrthancPluginErrorCode_AlreadyExistingTag = 2042 /*!< Cannot override the value of a tag that already exists */, + OrthancPluginErrorCode_NoStorageCommitmentHandler = 2043 /*!< No request handler factory for DICOM N-ACTION SCP (storage commitment) */, + OrthancPluginErrorCode_NoCGetHandler = 2044 /*!< No request handler factory for DICOM C-GET SCP */, + OrthancPluginErrorCode_UnsupportedMediaType = 3000 /*!< Unsupported media type */, + + _OrthancPluginErrorCode_INTERNAL = 0x7fffffff + } OrthancPluginErrorCode; + + + /** + * Forward declaration of one of the mandatory functions for Orthanc + * plugins. + **/ + ORTHANC_PLUGINS_API const char* OrthancPluginGetName(); + + + /** + * The various HTTP methods for a REST call. + **/ + typedef enum + { + OrthancPluginHttpMethod_Get = 1, /*!< GET request */ + OrthancPluginHttpMethod_Post = 2, /*!< POST request */ + OrthancPluginHttpMethod_Put = 3, /*!< PUT request */ + OrthancPluginHttpMethod_Delete = 4, /*!< DELETE request */ + + _OrthancPluginHttpMethod_INTERNAL = 0x7fffffff + } OrthancPluginHttpMethod; + + + /** + * @brief The parameters of a REST request. + * @ingroup Callbacks + **/ + typedef struct + { + /** + * @brief The HTTP method. + **/ + OrthancPluginHttpMethod method; + + /** + * @brief The number of groups of the regular expression. + **/ + uint32_t groupsCount; + + /** + * @brief The matched values for the groups of the regular expression. + **/ + const char* const* groups; + + /** + * @brief For a GET request, the number of GET parameters. + **/ + uint32_t getCount; + + /** + * @brief For a GET request, the keys of the GET parameters. + **/ + const char* const* getKeys; + + /** + * @brief For a GET request, the values of the GET parameters. + **/ + const char* const* getValues; + + /** + * @brief For a PUT or POST request, the content of the body. + **/ + const void* body; + + /** + * @brief For a PUT or POST request, the number of bytes of the body. + **/ + uint32_t bodySize; + + + /* -------------------------------------------------- + New in version 0.8.1 + -------------------------------------------------- */ + + /** + * @brief The number of HTTP headers. + **/ + uint32_t headersCount; + + /** + * @brief The keys of the HTTP headers (always converted to low-case). + **/ + const char* const* headersKeys; + + /** + * @brief The values of the HTTP headers. + **/ + const char* const* headersValues; + + } OrthancPluginHttpRequest; + + + typedef enum + { + /* Generic services */ + _OrthancPluginService_LogInfo = 1, + _OrthancPluginService_LogWarning = 2, + _OrthancPluginService_LogError = 3, + _OrthancPluginService_GetOrthancPath = 4, + _OrthancPluginService_GetOrthancDirectory = 5, + _OrthancPluginService_GetConfigurationPath = 6, + _OrthancPluginService_SetPluginProperty = 7, + _OrthancPluginService_GetGlobalProperty = 8, + _OrthancPluginService_SetGlobalProperty = 9, + _OrthancPluginService_GetCommandLineArgumentsCount = 10, + _OrthancPluginService_GetCommandLineArgument = 11, + _OrthancPluginService_GetExpectedDatabaseVersion = 12, + _OrthancPluginService_GetConfiguration = 13, + _OrthancPluginService_BufferCompression = 14, + _OrthancPluginService_ReadFile = 15, + _OrthancPluginService_WriteFile = 16, + _OrthancPluginService_GetErrorDescription = 17, + _OrthancPluginService_CallHttpClient = 18, + _OrthancPluginService_RegisterErrorCode = 19, + _OrthancPluginService_RegisterDictionaryTag = 20, + _OrthancPluginService_DicomBufferToJson = 21, + _OrthancPluginService_DicomInstanceToJson = 22, + _OrthancPluginService_CreateDicom = 23, + _OrthancPluginService_ComputeMd5 = 24, + _OrthancPluginService_ComputeSha1 = 25, + _OrthancPluginService_LookupDictionary = 26, + _OrthancPluginService_CallHttpClient2 = 27, + _OrthancPluginService_GenerateUuid = 28, + _OrthancPluginService_RegisterPrivateDictionaryTag = 29, + _OrthancPluginService_AutodetectMimeType = 30, + _OrthancPluginService_SetMetricsValue = 31, + _OrthancPluginService_EncodeDicomWebJson = 32, + _OrthancPluginService_EncodeDicomWebXml = 33, + _OrthancPluginService_ChunkedHttpClient = 34, /* New in Orthanc 1.5.7 */ + _OrthancPluginService_GetTagName = 35, /* New in Orthanc 1.5.7 */ + _OrthancPluginService_EncodeDicomWebJson2 = 36, /* New in Orthanc 1.7.0 */ + _OrthancPluginService_EncodeDicomWebXml2 = 37, /* New in Orthanc 1.7.0 */ + _OrthancPluginService_CreateMemoryBuffer = 38, /* New in Orthanc 1.7.0 */ + _OrthancPluginService_GenerateRestApiAuthorizationToken = 39, /* New in Orthanc 1.8.1 */ + _OrthancPluginService_CreateMemoryBuffer64 = 40, /* New in Orthanc 1.9.0 */ + _OrthancPluginService_CreateDicom2 = 41, /* New in Orthanc 1.9.0 */ + _OrthancPluginService_GetDatabaseServerIdentifier = 42, /* New in Orthanc 1.11.1 */ + + /* Registration of callbacks */ + _OrthancPluginService_RegisterRestCallback = 1000, + _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001, + _OrthancPluginService_RegisterStorageArea = 1002, + _OrthancPluginService_RegisterOnChangeCallback = 1003, + _OrthancPluginService_RegisterRestCallbackNoLock = 1004, + _OrthancPluginService_RegisterWorklistCallback = 1005, + _OrthancPluginService_RegisterDecodeImageCallback = 1006, + _OrthancPluginService_RegisterIncomingHttpRequestFilter = 1007, + _OrthancPluginService_RegisterFindCallback = 1008, + _OrthancPluginService_RegisterMoveCallback = 1009, + _OrthancPluginService_RegisterIncomingHttpRequestFilter2 = 1010, + _OrthancPluginService_RegisterRefreshMetricsCallback = 1011, + _OrthancPluginService_RegisterChunkedRestCallback = 1012, /* New in Orthanc 1.5.7 */ + _OrthancPluginService_RegisterStorageCommitmentScpCallback = 1013, + _OrthancPluginService_RegisterIncomingDicomInstanceFilter = 1014, + _OrthancPluginService_RegisterTranscoderCallback = 1015, /* New in Orthanc 1.7.0 */ + _OrthancPluginService_RegisterStorageArea2 = 1016, /* New in Orthanc 1.9.0 */ + _OrthancPluginService_RegisterIncomingCStoreInstanceFilter = 1017, /* New in Orthanc 1.10.0 */ + _OrthancPluginService_RegisterReceivedInstanceCallback = 1018, /* New in Orthanc 1.10.0 */ + _OrthancPluginService_RegisterWebDavCollection = 1019, /* New in Orthanc 1.10.1 */ + + /* Sending answers to REST calls */ + _OrthancPluginService_AnswerBuffer = 2000, + _OrthancPluginService_CompressAndAnswerPngImage = 2001, /* Unused as of Orthanc 0.9.4 */ + _OrthancPluginService_Redirect = 2002, + _OrthancPluginService_SendHttpStatusCode = 2003, + _OrthancPluginService_SendUnauthorized = 2004, + _OrthancPluginService_SendMethodNotAllowed = 2005, + _OrthancPluginService_SetCookie = 2006, + _OrthancPluginService_SetHttpHeader = 2007, + _OrthancPluginService_StartMultipartAnswer = 2008, + _OrthancPluginService_SendMultipartItem = 2009, + _OrthancPluginService_SendHttpStatus = 2010, + _OrthancPluginService_CompressAndAnswerImage = 2011, + _OrthancPluginService_SendMultipartItem2 = 2012, + _OrthancPluginService_SetHttpErrorDetails = 2013, + + /* Access to the Orthanc database and API */ + _OrthancPluginService_GetDicomForInstance = 3000, + _OrthancPluginService_RestApiGet = 3001, + _OrthancPluginService_RestApiPost = 3002, + _OrthancPluginService_RestApiDelete = 3003, + _OrthancPluginService_RestApiPut = 3004, + _OrthancPluginService_LookupPatient = 3005, + _OrthancPluginService_LookupStudy = 3006, + _OrthancPluginService_LookupSeries = 3007, + _OrthancPluginService_LookupInstance = 3008, + _OrthancPluginService_LookupStudyWithAccessionNumber = 3009, + _OrthancPluginService_RestApiGetAfterPlugins = 3010, + _OrthancPluginService_RestApiPostAfterPlugins = 3011, + _OrthancPluginService_RestApiDeleteAfterPlugins = 3012, + _OrthancPluginService_RestApiPutAfterPlugins = 3013, + _OrthancPluginService_ReconstructMainDicomTags = 3014, + _OrthancPluginService_RestApiGet2 = 3015, + _OrthancPluginService_CallRestApi = 3016, /* New in Orthanc 1.9.2 */ + + /* Access to DICOM instances */ + _OrthancPluginService_GetInstanceRemoteAet = 4000, + _OrthancPluginService_GetInstanceSize = 4001, + _OrthancPluginService_GetInstanceData = 4002, + _OrthancPluginService_GetInstanceJson = 4003, + _OrthancPluginService_GetInstanceSimplifiedJson = 4004, + _OrthancPluginService_HasInstanceMetadata = 4005, + _OrthancPluginService_GetInstanceMetadata = 4006, + _OrthancPluginService_GetInstanceOrigin = 4007, + _OrthancPluginService_GetInstanceTransferSyntaxUid = 4008, + _OrthancPluginService_HasInstancePixelData = 4009, + _OrthancPluginService_CreateDicomInstance = 4010, /* New in Orthanc 1.7.0 */ + _OrthancPluginService_FreeDicomInstance = 4011, /* New in Orthanc 1.7.0 */ + _OrthancPluginService_GetInstanceFramesCount = 4012, /* New in Orthanc 1.7.0 */ + _OrthancPluginService_GetInstanceRawFrame = 4013, /* New in Orthanc 1.7.0 */ + _OrthancPluginService_GetInstanceDecodedFrame = 4014, /* New in Orthanc 1.7.0 */ + _OrthancPluginService_TranscodeDicomInstance = 4015, /* New in Orthanc 1.7.0 */ + _OrthancPluginService_SerializeDicomInstance = 4016, /* New in Orthanc 1.7.0 */ + _OrthancPluginService_GetInstanceAdvancedJson = 4017, /* New in Orthanc 1.7.0 */ + _OrthancPluginService_GetInstanceDicomWebJson = 4018, /* New in Orthanc 1.7.0 */ + _OrthancPluginService_GetInstanceDicomWebXml = 4019, /* New in Orthanc 1.7.0 */ + + /* Services for plugins implementing a database back-end */ + _OrthancPluginService_RegisterDatabaseBackend = 5000, /* New in Orthanc 0.8.6 */ + _OrthancPluginService_DatabaseAnswer = 5001, + _OrthancPluginService_RegisterDatabaseBackendV2 = 5002, /* New in Orthanc 0.9.4 */ + _OrthancPluginService_StorageAreaCreate = 5003, + _OrthancPluginService_StorageAreaRead = 5004, + _OrthancPluginService_StorageAreaRemove = 5005, + _OrthancPluginService_RegisterDatabaseBackendV3 = 5006, /* New in Orthanc 1.9.2 */ + + /* Primitives for handling images */ + _OrthancPluginService_GetImagePixelFormat = 6000, + _OrthancPluginService_GetImageWidth = 6001, + _OrthancPluginService_GetImageHeight = 6002, + _OrthancPluginService_GetImagePitch = 6003, + _OrthancPluginService_GetImageBuffer = 6004, + _OrthancPluginService_UncompressImage = 6005, + _OrthancPluginService_FreeImage = 6006, + _OrthancPluginService_CompressImage = 6007, + _OrthancPluginService_ConvertPixelFormat = 6008, + _OrthancPluginService_GetFontsCount = 6009, + _OrthancPluginService_GetFontInfo = 6010, + _OrthancPluginService_DrawText = 6011, + _OrthancPluginService_CreateImage = 6012, + _OrthancPluginService_CreateImageAccessor = 6013, + _OrthancPluginService_DecodeDicomImage = 6014, + + /* Primitives for handling C-Find, C-Move and worklists */ + _OrthancPluginService_WorklistAddAnswer = 7000, + _OrthancPluginService_WorklistMarkIncomplete = 7001, + _OrthancPluginService_WorklistIsMatch = 7002, + _OrthancPluginService_WorklistGetDicomQuery = 7003, + _OrthancPluginService_FindAddAnswer = 7004, + _OrthancPluginService_FindMarkIncomplete = 7005, + _OrthancPluginService_GetFindQuerySize = 7006, + _OrthancPluginService_GetFindQueryTag = 7007, + _OrthancPluginService_GetFindQueryTagName = 7008, + _OrthancPluginService_GetFindQueryValue = 7009, + _OrthancPluginService_CreateFindMatcher = 7010, + _OrthancPluginService_FreeFindMatcher = 7011, + _OrthancPluginService_FindMatcherIsMatch = 7012, + + /* Primitives for accessing Orthanc Peers (new in 1.4.2) */ + _OrthancPluginService_GetPeers = 8000, + _OrthancPluginService_FreePeers = 8001, + _OrthancPluginService_GetPeersCount = 8003, + _OrthancPluginService_GetPeerName = 8004, + _OrthancPluginService_GetPeerUrl = 8005, + _OrthancPluginService_CallPeerApi = 8006, + _OrthancPluginService_GetPeerUserProperty = 8007, + + /* Primitives for handling jobs (new in 1.4.2) */ + _OrthancPluginService_CreateJob = 9000, + _OrthancPluginService_FreeJob = 9001, + _OrthancPluginService_SubmitJob = 9002, + _OrthancPluginService_RegisterJobsUnserializer = 9003, + + _OrthancPluginService_INTERNAL = 0x7fffffff + } _OrthancPluginService; + + + typedef enum + { + _OrthancPluginProperty_Description = 1, + _OrthancPluginProperty_RootUri = 2, + _OrthancPluginProperty_OrthancExplorer = 3, + + _OrthancPluginProperty_INTERNAL = 0x7fffffff + } _OrthancPluginProperty; + + + + /** + * The memory layout of the pixels of an image. + * @ingroup Images + **/ + typedef enum + { + /** + * @brief Graylevel 8bpp image. + * + * The image is graylevel. Each pixel is unsigned and stored in + * one byte. + **/ + OrthancPluginPixelFormat_Grayscale8 = 1, + + /** + * @brief Graylevel, unsigned 16bpp image. + * + * The image is graylevel. Each pixel is unsigned and stored in + * two bytes. + **/ + OrthancPluginPixelFormat_Grayscale16 = 2, + + /** + * @brief Graylevel, signed 16bpp image. + * + * The image is graylevel. Each pixel is signed and stored in two + * bytes. + **/ + OrthancPluginPixelFormat_SignedGrayscale16 = 3, + + /** + * @brief Color image in RGB24 format. + * + * This format describes a color image. The pixels are stored in 3 + * consecutive bytes. The memory layout is RGB. + **/ + OrthancPluginPixelFormat_RGB24 = 4, + + /** + * @brief Color image in RGBA32 format. + * + * This format describes a color image. The pixels are stored in 4 + * consecutive bytes. The memory layout is RGBA. + **/ + OrthancPluginPixelFormat_RGBA32 = 5, + + OrthancPluginPixelFormat_Unknown = 6, /*!< Unknown pixel format */ + + /** + * @brief Color image in RGB48 format. + * + * This format describes a color image. The pixels are stored in 6 + * consecutive bytes. The memory layout is RRGGBB. + **/ + OrthancPluginPixelFormat_RGB48 = 7, + + /** + * @brief Graylevel, unsigned 32bpp image. + * + * The image is graylevel. Each pixel is unsigned and stored in + * four bytes. + **/ + OrthancPluginPixelFormat_Grayscale32 = 8, + + /** + * @brief Graylevel, floating-point 32bpp image. + * + * The image is graylevel. Each pixel is floating-point and stored + * in four bytes. + **/ + OrthancPluginPixelFormat_Float32 = 9, + + /** + * @brief Color image in BGRA32 format. + * + * This format describes a color image. The pixels are stored in 4 + * consecutive bytes. The memory layout is BGRA. + **/ + OrthancPluginPixelFormat_BGRA32 = 10, + + /** + * @brief Graylevel, unsigned 64bpp image. + * + * The image is graylevel. Each pixel is unsigned and stored in + * eight bytes. + **/ + OrthancPluginPixelFormat_Grayscale64 = 11, + + _OrthancPluginPixelFormat_INTERNAL = 0x7fffffff + } OrthancPluginPixelFormat; + + + + /** + * The content types that are supported by Orthanc plugins. + **/ + typedef enum + { + OrthancPluginContentType_Unknown = 0, /*!< Unknown content type */ + OrthancPluginContentType_Dicom = 1, /*!< DICOM */ + OrthancPluginContentType_DicomAsJson = 2, /*!< JSON summary of a DICOM file */ + OrthancPluginContentType_DicomUntilPixelData = 3, /*!< DICOM Header till pixel data */ + + _OrthancPluginContentType_INTERNAL = 0x7fffffff + } OrthancPluginContentType; + + + + /** + * The supported types of DICOM resources. + **/ + typedef enum + { + OrthancPluginResourceType_Patient = 0, /*!< Patient */ + OrthancPluginResourceType_Study = 1, /*!< Study */ + OrthancPluginResourceType_Series = 2, /*!< Series */ + OrthancPluginResourceType_Instance = 3, /*!< Instance */ + OrthancPluginResourceType_None = 4, /*!< Unavailable resource type */ + + _OrthancPluginResourceType_INTERNAL = 0x7fffffff + } OrthancPluginResourceType; + + + + /** + * The supported types of changes that can be signaled to the change callback. + * @ingroup Callbacks + **/ + typedef enum + { + OrthancPluginChangeType_CompletedSeries = 0, /*!< Series is now complete */ + OrthancPluginChangeType_Deleted = 1, /*!< Deleted resource */ + OrthancPluginChangeType_NewChildInstance = 2, /*!< A new instance was added to this resource */ + OrthancPluginChangeType_NewInstance = 3, /*!< New instance received */ + OrthancPluginChangeType_NewPatient = 4, /*!< New patient created */ + OrthancPluginChangeType_NewSeries = 5, /*!< New series created */ + OrthancPluginChangeType_NewStudy = 6, /*!< New study created */ + OrthancPluginChangeType_StablePatient = 7, /*!< Timeout: No new instance in this patient */ + OrthancPluginChangeType_StableSeries = 8, /*!< Timeout: No new instance in this series */ + OrthancPluginChangeType_StableStudy = 9, /*!< Timeout: No new instance in this study */ + OrthancPluginChangeType_OrthancStarted = 10, /*!< Orthanc has started */ + OrthancPluginChangeType_OrthancStopped = 11, /*!< Orthanc is stopping */ + OrthancPluginChangeType_UpdatedAttachment = 12, /*!< Some user-defined attachment has changed for this resource */ + OrthancPluginChangeType_UpdatedMetadata = 13, /*!< Some user-defined metadata has changed for this resource */ + OrthancPluginChangeType_UpdatedPeers = 14, /*!< The list of Orthanc peers has changed */ + OrthancPluginChangeType_UpdatedModalities = 15, /*!< The list of DICOM modalities has changed */ + OrthancPluginChangeType_JobSubmitted = 16, /*!< New Job submitted */ + OrthancPluginChangeType_JobSuccess = 17, /*!< A Job has completed successfully */ + OrthancPluginChangeType_JobFailure = 18, /*!< A Job has failed */ + + _OrthancPluginChangeType_INTERNAL = 0x7fffffff + } OrthancPluginChangeType; + + + /** + * The compression algorithms that are supported by the Orthanc core. + * @ingroup Images + **/ + typedef enum + { + OrthancPluginCompressionType_Zlib = 0, /*!< Standard zlib compression */ + OrthancPluginCompressionType_ZlibWithSize = 1, /*!< zlib, prefixed with uncompressed size (uint64_t) */ + OrthancPluginCompressionType_Gzip = 2, /*!< Standard gzip compression */ + OrthancPluginCompressionType_GzipWithSize = 3, /*!< gzip, prefixed with uncompressed size (uint64_t) */ + + _OrthancPluginCompressionType_INTERNAL = 0x7fffffff + } OrthancPluginCompressionType; + + + /** + * The image formats that are supported by the Orthanc core. + * @ingroup Images + **/ + typedef enum + { + OrthancPluginImageFormat_Png = 0, /*!< Image compressed using PNG */ + OrthancPluginImageFormat_Jpeg = 1, /*!< Image compressed using JPEG */ + OrthancPluginImageFormat_Dicom = 2, /*!< Image compressed using DICOM */ + + _OrthancPluginImageFormat_INTERNAL = 0x7fffffff + } OrthancPluginImageFormat; + + + /** + * The value representations present in the DICOM standard (version 2013). + * @ingroup Toolbox + **/ + typedef enum + { + OrthancPluginValueRepresentation_AE = 1, /*!< Application Entity */ + OrthancPluginValueRepresentation_AS = 2, /*!< Age String */ + OrthancPluginValueRepresentation_AT = 3, /*!< Attribute Tag */ + OrthancPluginValueRepresentation_CS = 4, /*!< Code String */ + OrthancPluginValueRepresentation_DA = 5, /*!< Date */ + OrthancPluginValueRepresentation_DS = 6, /*!< Decimal String */ + OrthancPluginValueRepresentation_DT = 7, /*!< Date Time */ + OrthancPluginValueRepresentation_FD = 8, /*!< Floating Point Double */ + OrthancPluginValueRepresentation_FL = 9, /*!< Floating Point Single */ + OrthancPluginValueRepresentation_IS = 10, /*!< Integer String */ + OrthancPluginValueRepresentation_LO = 11, /*!< Long String */ + OrthancPluginValueRepresentation_LT = 12, /*!< Long Text */ + OrthancPluginValueRepresentation_OB = 13, /*!< Other Byte String */ + OrthancPluginValueRepresentation_OF = 14, /*!< Other Float String */ + OrthancPluginValueRepresentation_OW = 15, /*!< Other Word String */ + OrthancPluginValueRepresentation_PN = 16, /*!< Person Name */ + OrthancPluginValueRepresentation_SH = 17, /*!< Short String */ + OrthancPluginValueRepresentation_SL = 18, /*!< Signed Long */ + OrthancPluginValueRepresentation_SQ = 19, /*!< Sequence of Items */ + OrthancPluginValueRepresentation_SS = 20, /*!< Signed Short */ + OrthancPluginValueRepresentation_ST = 21, /*!< Short Text */ + OrthancPluginValueRepresentation_TM = 22, /*!< Time */ + OrthancPluginValueRepresentation_UI = 23, /*!< Unique Identifier (UID) */ + OrthancPluginValueRepresentation_UL = 24, /*!< Unsigned Long */ + OrthancPluginValueRepresentation_UN = 25, /*!< Unknown */ + OrthancPluginValueRepresentation_US = 26, /*!< Unsigned Short */ + OrthancPluginValueRepresentation_UT = 27, /*!< Unlimited Text */ + + _OrthancPluginValueRepresentation_INTERNAL = 0x7fffffff + } OrthancPluginValueRepresentation; + + + /** + * The possible output formats for a DICOM-to-JSON conversion. + * @ingroup Toolbox + * @see OrthancPluginDicomToJson() + **/ + typedef enum + { + OrthancPluginDicomToJsonFormat_Full = 1, /*!< Full output, with most details */ + OrthancPluginDicomToJsonFormat_Short = 2, /*!< Tags output as hexadecimal numbers */ + OrthancPluginDicomToJsonFormat_Human = 3, /*!< Human-readable JSON */ + + _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff + } OrthancPluginDicomToJsonFormat; + + + /** + * Flags to customize a DICOM-to-JSON conversion. By default, binary + * tags are formatted using Data URI scheme. + * @ingroup Toolbox + **/ + typedef enum + { + OrthancPluginDicomToJsonFlags_None = 0, + OrthancPluginDicomToJsonFlags_IncludeBinary = (1 << 0), /*!< Include the binary tags */ + OrthancPluginDicomToJsonFlags_IncludePrivateTags = (1 << 1), /*!< Include the private tags */ + OrthancPluginDicomToJsonFlags_IncludeUnknownTags = (1 << 2), /*!< Include the tags unknown by the dictionary */ + OrthancPluginDicomToJsonFlags_IncludePixelData = (1 << 3), /*!< Include the pixel data */ + OrthancPluginDicomToJsonFlags_ConvertBinaryToAscii = (1 << 4), /*!< Output binary tags as-is, dropping non-ASCII */ + OrthancPluginDicomToJsonFlags_ConvertBinaryToNull = (1 << 5), /*!< Signal binary tags as null values */ + OrthancPluginDicomToJsonFlags_StopAfterPixelData = (1 << 6), /*!< Stop processing after pixel data (new in 1.9.1) */ + OrthancPluginDicomToJsonFlags_SkipGroupLengths = (1 << 7), /*!< Skip tags whose element is zero (new in 1.9.1) */ + + _OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff + } OrthancPluginDicomToJsonFlags; + + + /** + * Flags to the creation of a DICOM file. + * @ingroup Toolbox + * @see OrthancPluginCreateDicom() + **/ + typedef enum + { + OrthancPluginCreateDicomFlags_None = 0, + OrthancPluginCreateDicomFlags_DecodeDataUriScheme = (1 << 0), /*!< Decode fields encoded using data URI scheme */ + OrthancPluginCreateDicomFlags_GenerateIdentifiers = (1 << 1), /*!< Automatically generate DICOM identifiers */ + + _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff + } OrthancPluginCreateDicomFlags; + + + /** + * The constraints on the DICOM identifiers that must be supported + * by the database plugins. + * @deprecated Plugins using OrthancPluginConstraintType will be faster + **/ + typedef enum + { + OrthancPluginIdentifierConstraint_Equal = 1, /*!< Equal */ + OrthancPluginIdentifierConstraint_SmallerOrEqual = 2, /*!< Less or equal */ + OrthancPluginIdentifierConstraint_GreaterOrEqual = 3, /*!< More or equal */ + OrthancPluginIdentifierConstraint_Wildcard = 4, /*!< Case-sensitive wildcard matching (with * and ?) */ + + _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff + } OrthancPluginIdentifierConstraint; + + + /** + * The constraints on the tags (main DICOM tags and identifier tags) + * that must be supported by the database plugins. + **/ + typedef enum + { + OrthancPluginConstraintType_Equal = 1, /*!< Equal */ + OrthancPluginConstraintType_SmallerOrEqual = 2, /*!< Less or equal */ + OrthancPluginConstraintType_GreaterOrEqual = 3, /*!< More or equal */ + OrthancPluginConstraintType_Wildcard = 4, /*!< Wildcard matching */ + OrthancPluginConstraintType_List = 5, /*!< List of values */ + + _OrthancPluginConstraintType_INTERNAL = 0x7fffffff + } OrthancPluginConstraintType; + + + /** + * The origin of a DICOM instance that has been received by Orthanc. + **/ + typedef enum + { + OrthancPluginInstanceOrigin_Unknown = 1, /*!< Unknown origin */ + OrthancPluginInstanceOrigin_DicomProtocol = 2, /*!< Instance received through DICOM protocol */ + OrthancPluginInstanceOrigin_RestApi = 3, /*!< Instance received through REST API of Orthanc */ + OrthancPluginInstanceOrigin_Plugin = 4, /*!< Instance added to Orthanc by a plugin */ + OrthancPluginInstanceOrigin_Lua = 5, /*!< Instance added to Orthanc by a Lua script */ + OrthancPluginInstanceOrigin_WebDav = 6, /*!< Instance received through WebDAV (new in 1.8.0) */ + + _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff + } OrthancPluginInstanceOrigin; + + + /** + * The possible status for one single step of a job. + **/ + typedef enum + { + OrthancPluginJobStepStatus_Success = 1, /*!< The job has successfully executed all its steps */ + OrthancPluginJobStepStatus_Failure = 2, /*!< The job has failed while executing this step */ + OrthancPluginJobStepStatus_Continue = 3 /*!< The job has still data to process after this step */ + } OrthancPluginJobStepStatus; + + + /** + * Explains why the job should stop and release the resources it has + * allocated. This is especially important to disambiguate between + * the "paused" condition and the "final" conditions (success, + * failure, or canceled). + **/ + typedef enum + { + OrthancPluginJobStopReason_Success = 1, /*!< The job has succeeded */ + OrthancPluginJobStopReason_Paused = 2, /*!< The job was paused, and will be resumed later */ + OrthancPluginJobStopReason_Failure = 3, /*!< The job has failed, and might be resubmitted later */ + OrthancPluginJobStopReason_Canceled = 4 /*!< The job was canceled, and might be resubmitted later */ + } OrthancPluginJobStopReason; + + + /** + * The available types of metrics. + **/ + typedef enum + { + OrthancPluginMetricsType_Default = 0, /*!< Default metrics */ + + /** + * This metrics represents a time duration. Orthanc will keep the + * maximum value of the metrics over a sliding window of ten + * seconds, which is useful if the metrics is sampled frequently. + **/ + OrthancPluginMetricsType_Timer = 1 + } OrthancPluginMetricsType; + + + /** + * The available modes to export a binary DICOM tag into a DICOMweb + * JSON or XML document. + **/ + typedef enum + { + OrthancPluginDicomWebBinaryMode_Ignore = 0, /*!< Don't include binary tags */ + OrthancPluginDicomWebBinaryMode_InlineBinary = 1, /*!< Inline encoding using Base64 */ + OrthancPluginDicomWebBinaryMode_BulkDataUri = 2 /*!< Use a bulk data URI field */ + } OrthancPluginDicomWebBinaryMode; + + + /** + * The available values for the Failure Reason (0008,1197) during + * storage commitment. + * http://dicom.nema.org/medical/dicom/2019e/output/chtml/part03/sect_C.14.html#sect_C.14.1.1 + **/ + typedef enum + { + OrthancPluginStorageCommitmentFailureReason_Success = 0, + /*!< Success: The DICOM instance is properly stored in the SCP */ + + OrthancPluginStorageCommitmentFailureReason_ProcessingFailure = 1, + /*!< 0110H: A general failure in processing the operation was encountered */ + + OrthancPluginStorageCommitmentFailureReason_NoSuchObjectInstance = 2, + /*!< 0112H: One or more of the elements in the Referenced SOP + Instance Sequence was not available */ + + OrthancPluginStorageCommitmentFailureReason_ResourceLimitation = 3, + /*!< 0213H: The SCP does not currently have enough resources to + store the requested SOP Instance(s) */ + + OrthancPluginStorageCommitmentFailureReason_ReferencedSOPClassNotSupported = 4, + /*!< 0122H: Storage Commitment has been requested for a SOP + Instance with a SOP Class that is not supported by the SCP */ + + OrthancPluginStorageCommitmentFailureReason_ClassInstanceConflict = 5, + /*!< 0119H: The SOP Class of an element in the Referenced SOP + Instance Sequence did not correspond to the SOP class registered + for this SOP Instance at the SCP */ + + OrthancPluginStorageCommitmentFailureReason_DuplicateTransactionUID = 6 + /*!< 0131H: The Transaction UID of the Storage Commitment Request + is already in use */ + } OrthancPluginStorageCommitmentFailureReason; + + + /** + * The action to be taken after ReceivedInstanceCallback is triggered + **/ + typedef enum + { + OrthancPluginReceivedInstanceAction_KeepAsIs = 1, /*!< Keep the instance as is */ + OrthancPluginReceivedInstanceAction_Modify = 2, /*!< Modify the instance */ + OrthancPluginReceivedInstanceAction_Discard = 3, /*!< Discard the instance */ + + _OrthancPluginReceivedInstanceAction_INTERNAL = 0x7fffffff + } OrthancPluginReceivedInstanceAction; + + + /** + * @brief A 32-bit memory buffer allocated by the core system of Orthanc. + * + * A memory buffer allocated by the core system of Orthanc. When the + * content of the buffer is not useful anymore, it must be free by a + * call to ::OrthancPluginFreeMemoryBuffer(). + **/ + typedef struct + { + /** + * @brief The content of the buffer. + **/ + void* data; + + /** + * @brief The number of bytes in the buffer. + **/ + uint32_t size; + } OrthancPluginMemoryBuffer; + + + + /** + * @brief A 64-bit memory buffer allocated by the core system of Orthanc. + * + * A memory buffer allocated by the core system of Orthanc. When the + * content of the buffer is not useful anymore, it must be free by a + * call to ::OrthancPluginFreeMemoryBuffer64(). + **/ + typedef struct + { + /** + * @brief The content of the buffer. + **/ + void* data; + + /** + * @brief The number of bytes in the buffer. + **/ + uint64_t size; + } OrthancPluginMemoryBuffer64; + + + + + /** + * @brief Opaque structure that represents the HTTP connection to the client application. + * @ingroup Callbacks + **/ + typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput; + + + + /** + * @brief Opaque structure that represents a DICOM instance that is managed by the Orthanc core. + * @ingroup DicomInstance + **/ + typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance; + + + + /** + * @brief Opaque structure that represents an image that is uncompressed in memory. + * @ingroup Images + **/ + typedef struct _OrthancPluginImage_t OrthancPluginImage; + + + + /** + * @brief Opaque structure that represents the storage area that is actually used by Orthanc. + * @ingroup Images + **/ + typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea; + + + + /** + * @brief Opaque structure to an object that represents a C-Find query for worklists. + * @ingroup DicomCallbacks + **/ + typedef struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery; + + + + /** + * @brief Opaque structure to an object that represents the answers to a C-Find query for worklists. + * @ingroup DicomCallbacks + **/ + typedef struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers; + + + + /** + * @brief Opaque structure to an object that represents a C-Find query. + * @ingroup DicomCallbacks + **/ + typedef struct _OrthancPluginFindQuery_t OrthancPluginFindQuery; + + + + /** + * @brief Opaque structure to an object that represents the answers to a C-Find query for worklists. + * @ingroup DicomCallbacks + **/ + typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers; + + + + /** + * @brief Opaque structure to an object that can be used to check whether a DICOM instance matches a C-Find query. + * @ingroup Toolbox + **/ + typedef struct _OrthancPluginFindMatcher_t OrthancPluginFindMatcher; + + + + /** + * @brief Opaque structure to the set of remote Orthanc Peers that are known to the local Orthanc server. + * @ingroup Toolbox + **/ + typedef struct _OrthancPluginPeers_t OrthancPluginPeers; + + + + /** + * @brief Opaque structure to a job to be executed by Orthanc. + * @ingroup Toolbox + **/ + typedef struct _OrthancPluginJob_t OrthancPluginJob; + + + + /** + * @brief Opaque structure that represents a node in a JSON or XML + * document used in DICOMweb. + * @ingroup Toolbox + **/ + typedef struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode; + + + + /** + * @brief Signature of a callback function that answers to a REST request. + * @ingroup Callbacks + **/ + typedef OrthancPluginErrorCode (*OrthancPluginRestCallback) ( + OrthancPluginRestOutput* output, + const char* url, + const OrthancPluginHttpRequest* request); + + + + /** + * @brief Signature of a callback function that is triggered when Orthanc stores a new DICOM instance. + * @ingroup Callbacks + **/ + typedef OrthancPluginErrorCode (*OrthancPluginOnStoredInstanceCallback) ( + const OrthancPluginDicomInstance* instance, + const char* instanceId); + + + + /** + * @brief Signature of a callback function that is triggered when a change happens to some DICOM resource. + * @ingroup Callbacks + **/ + typedef OrthancPluginErrorCode (*OrthancPluginOnChangeCallback) ( + OrthancPluginChangeType changeType, + OrthancPluginResourceType resourceType, + const char* resourceId); + + + + /** + * @brief Signature of a callback function to decode a DICOM instance as an image. + * @ingroup Callbacks + **/ + typedef OrthancPluginErrorCode (*OrthancPluginDecodeImageCallback) ( + OrthancPluginImage** target, + const void* dicom, + const uint32_t size, + uint32_t frameIndex); + + + + /** + * @brief Signature of a function to free dynamic memory. + * @ingroup Callbacks + **/ + typedef void (*OrthancPluginFree) (void* buffer); + + + + /** + * @brief Signature of a function to set the content of a node + * encoding a binary DICOM tag, into a JSON or XML document + * generated for DICOMweb. + * @ingroup Callbacks + **/ + typedef void (*OrthancPluginDicomWebSetBinaryNode) ( + OrthancPluginDicomWebNode* node, + OrthancPluginDicomWebBinaryMode mode, + const char* bulkDataUri); + + + + /** + * @brief Callback for writing to the storage area. + * + * Signature of a callback function that is triggered when Orthanc writes a file to the storage area. + * + * @param uuid The UUID of the file. + * @param content The content of the file. + * @param size The size of the file. + * @param type The content type corresponding to this file. + * @return 0 if success, other value if error. + * @ingroup Callbacks + **/ + typedef OrthancPluginErrorCode (*OrthancPluginStorageCreate) ( + const char* uuid, + const void* content, + int64_t size, + OrthancPluginContentType type); + + + + /** + * @brief Callback for reading from the storage area. + * + * Signature of a callback function that is triggered when Orthanc reads a file from the storage area. + * + * @param content The content of the file (output). + * @param size The size of the file (output). + * @param uuid The UUID of the file of interest. + * @param type The content type corresponding to this file. + * @return 0 if success, other value if error. + * @ingroup Callbacks + * @deprecated New plugins should use OrthancPluginStorageRead2 + * + * @warning The "content" buffer *must* have been allocated using + * the "malloc()" function of your C standard library (i.e. nor + * "new[]", neither a pointer to a buffer). The "free()" function of + * your C standard library will automatically be invoked on the + * "content" pointer. + **/ + typedef OrthancPluginErrorCode (*OrthancPluginStorageRead) ( + void** content, + int64_t* size, + const char* uuid, + OrthancPluginContentType type); + + + + /** + * @brief Callback for reading a whole file from the storage area. + * + * Signature of a callback function that is triggered when Orthanc + * reads a whole file from the storage area. + * + * @param target Memory buffer where to store the content of the file. It must be allocated by the + * plugin using OrthancPluginCreateMemoryBuffer64(). The core of Orthanc will free it. + * @param uuid The UUID of the file of interest. + * @param type The content type corresponding to this file. + * @ingroup Callbacks + **/ + typedef OrthancPluginErrorCode (*OrthancPluginStorageReadWhole) ( + OrthancPluginMemoryBuffer64* target, + const char* uuid, + OrthancPluginContentType type); + + + + /** + * @brief Callback for reading a range of a file from the storage area. + * + * Signature of a callback function that is triggered when Orthanc + * reads a portion of a file from the storage area. Orthanc + * indicates the start position and the length of the range. + * + * @param target Memory buffer where to store the content of the range. + * The memory buffer is allocated and freed by Orthanc. The length of the range + * of interest corresponds to the size of this buffer. + * @param uuid The UUID of the file of interest. + * @param type The content type corresponding to this file. + * @param rangeStart Start position of the requested range in the file. + * @return 0 if success, other value if error. + * @ingroup Callbacks + **/ + typedef OrthancPluginErrorCode (*OrthancPluginStorageReadRange) ( + OrthancPluginMemoryBuffer64* target, + const char* uuid, + OrthancPluginContentType type, + uint64_t rangeStart); + + + + /** + * @brief Callback for removing a file from the storage area. + * + * Signature of a callback function that is triggered when Orthanc deletes a file from the storage area. + * + * @param uuid The UUID of the file to be removed. + * @param type The content type corresponding to this file. + * @return 0 if success, other value if error. + * @ingroup Callbacks + **/ + typedef OrthancPluginErrorCode (*OrthancPluginStorageRemove) ( + const char* uuid, + OrthancPluginContentType type); + + + + /** + * @brief Callback to handle the C-Find SCP requests for worklists. + * + * Signature of a callback function that is triggered when Orthanc + * receives a C-Find SCP request against modality worklists. + * + * @param answers The target structure where answers must be stored. + * @param query The worklist query. + * @param issuerAet The Application Entity Title (AET) of the modality from which the request originates. + * @param calledAet The Application Entity Title (AET) of the modality that is called by the request. + * @return 0 if success, other value if error. + * @ingroup DicomCallbacks + **/ + typedef OrthancPluginErrorCode (*OrthancPluginWorklistCallback) ( + OrthancPluginWorklistAnswers* answers, + const OrthancPluginWorklistQuery* query, + const char* issuerAet, + const char* calledAet); + + + + /** + * @brief Callback to filter incoming HTTP requests received by Orthanc. + * + * Signature of a callback function that is triggered whenever + * Orthanc receives an HTTP/REST request, and that answers whether + * this request should be allowed. If the callback returns "0" + * ("false"), the server answers with HTTP status code 403 + * (Forbidden). + * + * Pay attention to the fact that this function may be invoked + * concurrently by different threads of the Web server of + * Orthanc. You must implement proper locking if applicable. + * + * @param method The HTTP method used by the request. + * @param uri The URI of interest. + * @param ip The IP address of the HTTP client. + * @param headersCount The number of HTTP headers. + * @param headersKeys The keys of the HTTP headers (always converted to low-case). + * @param headersValues The values of the HTTP headers. + * @return 0 if forbidden access, 1 if allowed access, -1 if error. + * @ingroup Callbacks + * @deprecated Please instead use OrthancPluginIncomingHttpRequestFilter2() + **/ + typedef int32_t (*OrthancPluginIncomingHttpRequestFilter) ( + OrthancPluginHttpMethod method, + const char* uri, + const char* ip, + uint32_t headersCount, + const char* const* headersKeys, + const char* const* headersValues); + + + + /** + * @brief Callback to filter incoming HTTP requests received by Orthanc. + * + * Signature of a callback function that is triggered whenever + * Orthanc receives an HTTP/REST request, and that answers whether + * this request should be allowed. If the callback returns "0" + * ("false"), the server answers with HTTP status code 403 + * (Forbidden). + * + * Pay attention to the fact that this function may be invoked + * concurrently by different threads of the Web server of + * Orthanc. You must implement proper locking if applicable. + * + * @param method The HTTP method used by the request. + * @param uri The URI of interest. + * @param ip The IP address of the HTTP client. + * @param headersCount The number of HTTP headers. + * @param headersKeys The keys of the HTTP headers (always converted to low-case). + * @param headersValues The values of the HTTP headers. + * @param getArgumentsCount The number of GET arguments (only for the GET HTTP method). + * @param getArgumentsKeys The keys of the GET arguments (only for the GET HTTP method). + * @param getArgumentsValues The values of the GET arguments (only for the GET HTTP method). + * @return 0 if forbidden access, 1 if allowed access, -1 if error. + * @ingroup Callbacks + **/ + typedef int32_t (*OrthancPluginIncomingHttpRequestFilter2) ( + OrthancPluginHttpMethod method, + const char* uri, + const char* ip, + uint32_t headersCount, + const char* const* headersKeys, + const char* const* headersValues, + uint32_t getArgumentsCount, + const char* const* getArgumentsKeys, + const char* const* getArgumentsValues); + + + + /** + * @brief Callback to handle incoming C-Find SCP requests. + * + * Signature of a callback function that is triggered whenever + * Orthanc receives a C-Find SCP request not concerning modality + * worklists. + * + * @param answers The target structure where answers must be stored. + * @param query The worklist query. + * @param issuerAet The Application Entity Title (AET) of the modality from which the request originates. + * @param calledAet The Application Entity Title (AET) of the modality that is called by the request. + * @return 0 if success, other value if error. + * @ingroup DicomCallbacks + **/ + typedef OrthancPluginErrorCode (*OrthancPluginFindCallback) ( + OrthancPluginFindAnswers* answers, + const OrthancPluginFindQuery* query, + const char* issuerAet, + const char* calledAet); + + + + /** + * @brief Callback to handle incoming C-Move SCP requests. + * + * Signature of a callback function that is triggered whenever + * Orthanc receives a C-Move SCP request. The callback receives the + * type of the resource of interest (study, series, instance...) + * together with the DICOM tags containing its identifiers. In turn, + * the plugin must create a driver object that will be responsible + * for driving the successive move suboperations. + * + * @param resourceType The type of the resource of interest. Note + * that this might be set to ResourceType_None if the + * QueryRetrieveLevel (0008,0052) tag was not provided by the + * issuer (i.e. the originator modality). + * @param patientId Content of the PatientID (0x0010, 0x0020) tag of the resource of interest. Might be NULL. + * @param accessionNumber Content of the AccessionNumber (0x0008, 0x0050) tag. Might be NULL. + * @param studyInstanceUid Content of the StudyInstanceUID (0x0020, 0x000d) tag. Might be NULL. + * @param seriesInstanceUid Content of the SeriesInstanceUID (0x0020, 0x000e) tag. Might be NULL. + * @param sopInstanceUid Content of the SOPInstanceUID (0x0008, 0x0018) tag. Might be NULL. + * @param originatorAet The Application Entity Title (AET) of the + * modality from which the request originates. + * @param sourceAet The Application Entity Title (AET) of the + * modality that should send its DICOM files to another modality. + * @param targetAet The Application Entity Title (AET) of the + * modality that should receive the DICOM files. + * @param originatorId The Message ID issued by the originator modality, + * as found in tag (0000,0110) of the DICOM query emitted by the issuer. + * + * @return The NULL value if the plugin cannot deal with this query, + * or a pointer to the driver object that is responsible for + * handling the successive move suboperations. + * + * @note If targetAet equals sourceAet, this is actually a query/retrieve operation. + * @ingroup DicomCallbacks + **/ + typedef void* (*OrthancPluginMoveCallback) ( + OrthancPluginResourceType resourceType, + const char* patientId, + const char* accessionNumber, + const char* studyInstanceUid, + const char* seriesInstanceUid, + const char* sopInstanceUid, + const char* originatorAet, + const char* sourceAet, + const char* targetAet, + uint16_t originatorId); + + + /** + * @brief Callback to read the size of a C-Move driver. + * + * Signature of a callback function that returns the number of + * C-Move suboperations that are to be achieved by the given C-Move + * driver. This driver is the return value of a previous call to the + * OrthancPluginMoveCallback() callback. + * + * @param moveDriver The C-Move driver of interest. + * @return The number of suboperations. + * @ingroup DicomCallbacks + **/ + typedef uint32_t (*OrthancPluginGetMoveSize) (void* moveDriver); + + + /** + * @brief Callback to apply one C-Move suboperation. + * + * Signature of a callback function that applies the next C-Move + * suboperation that os to be achieved by the given C-Move + * driver. This driver is the return value of a previous call to the + * OrthancPluginMoveCallback() callback. + * + * @param moveDriver The C-Move driver of interest. + * @return 0 if success, or the error code if failure. + * @ingroup DicomCallbacks + **/ + typedef OrthancPluginErrorCode (*OrthancPluginApplyMove) (void* moveDriver); + + + /** + * @brief Callback to free one C-Move driver. + * + * Signature of a callback function that releases the resources + * allocated by the given C-Move driver. This driver is the return + * value of a previous call to the OrthancPluginMoveCallback() + * callback. + * + * @param moveDriver The C-Move driver of interest. + * @ingroup DicomCallbacks + **/ + typedef void (*OrthancPluginFreeMove) (void* moveDriver); + + + /** + * @brief Callback to finalize one custom job. + * + * Signature of a callback function that releases all the resources + * allocated by the given job. This job is the argument provided to + * OrthancPluginCreateJob(). + * + * @param job The job of interest. + * @ingroup Toolbox + **/ + typedef void (*OrthancPluginJobFinalize) (void* job); + + + /** + * @brief Callback to check the progress of one custom job. + * + * Signature of a callback function that returns the progress of the + * job. + * + * @param job The job of interest. + * @return The progress, as a floating-point number ranging from 0 to 1. + * @ingroup Toolbox + **/ + typedef float (*OrthancPluginJobGetProgress) (void* job); + + + /** + * @brief Callback to retrieve the content of one custom job. + * + * Signature of a callback function that returns human-readable + * statistics about the job. This statistics must be formatted as a + * JSON object. This information is notably displayed in the "Jobs" + * tab of "Orthanc Explorer". + * + * @param job The job of interest. + * @return The statistics, as a JSON object encoded as a string. + * @ingroup Toolbox + **/ + typedef const char* (*OrthancPluginJobGetContent) (void* job); + + + /** + * @brief Callback to serialize one custom job. + * + * Signature of a callback function that returns a serialized + * version of the job, formatted as a JSON object. This + * serialization is stored in the Orthanc database, and is used to + * reload the job on the restart of Orthanc. The "unserialization" + * callback (with OrthancPluginJobsUnserializer signature) will + * receive this serialized object. + * + * @param job The job of interest. + * @return The serialized job, as a JSON object encoded as a string. + * @see OrthancPluginRegisterJobsUnserializer() + * @ingroup Toolbox + **/ + typedef const char* (*OrthancPluginJobGetSerialized) (void* job); + + + /** + * @brief Callback to execute one step of a custom job. + * + * Signature of a callback function that executes one step in the + * job. The jobs engine of Orthanc will make successive calls to + * this method, as long as it returns + * OrthancPluginJobStepStatus_Continue. + * + * @param job The job of interest. + * @return The status of execution. + * @ingroup Toolbox + **/ + typedef OrthancPluginJobStepStatus (*OrthancPluginJobStep) (void* job); + + + /** + * @brief Callback executed once one custom job leaves the "running" state. + * + * Signature of a callback function that is invoked once a job + * leaves the "running" state. This can happen if the previous call + * to OrthancPluginJobStep has failed/succeeded, if the host Orthanc + * server is being stopped, or if the user manually tags the job as + * paused/canceled. This callback allows the plugin to free + * resources allocated for running this custom job (e.g. to stop + * threads, or to remove temporary files). + * + * Note that handling pauses might involves a specific treatment + * (such a stopping threads, but keeping temporary files on the + * disk). This "paused" situation can be checked by looking at the + * "reason" parameter. + * + * @param job The job of interest. + * @param reason The reason for leaving the "running" state. + * @return 0 if success, or the error code if failure. + * @ingroup Toolbox + **/ + typedef OrthancPluginErrorCode (*OrthancPluginJobStop) (void* job, + OrthancPluginJobStopReason reason); + + + /** + * @brief Callback executed once one stopped custom job is started again. + * + * Signature of a callback function that is invoked once a job + * leaves the "failure/canceled" state, to be started again. This + * function will typically reset the progress to zero. Note that + * before being actually executed, the job would first be tagged as + * "pending" in the Orthanc jobs engine. + * + * @param job The job of interest. + * @return 0 if success, or the error code if failure. + * @ingroup Toolbox + **/ + typedef OrthancPluginErrorCode (*OrthancPluginJobReset) (void* job); + + + /** + * @brief Callback executed to unserialize a custom job. + * + * Signature of a callback function that unserializes a job that was + * saved in the Orthanc database. + * + * @param jobType The type of the job, as provided to OrthancPluginCreateJob(). + * @param serialized The serialization of the job, as provided by OrthancPluginJobGetSerialized. + * @return The unserialized job (as created by OrthancPluginCreateJob()), or NULL + * if this unserializer cannot handle this job type. + * @see OrthancPluginRegisterJobsUnserializer() + * @ingroup Callbacks + **/ + typedef OrthancPluginJob* (*OrthancPluginJobsUnserializer) (const char* jobType, + const char* serialized); + + + + /** + * @brief Callback executed to update the metrics of the plugin. + * + * Signature of a callback function that is called by Orthanc + * whenever a monitoring tool (such as Prometheus) asks the current + * values of the metrics. This callback gives the plugin a chance to + * update its metrics, by calling OrthancPluginSetMetricsValue(). + * This is typically useful for metrics that are expensive to + * acquire. + * + * @see OrthancPluginRegisterRefreshMetrics() + * @ingroup Callbacks + **/ + typedef void (*OrthancPluginRefreshMetricsCallback) (); + + + + /** + * @brief Callback executed to encode a binary tag in DICOMweb. + * + * Signature of a callback function that is called by Orthanc + * whenever a DICOM tag that contains a binary value must be written + * to a JSON or XML node, while a DICOMweb document is being + * generated. The value representation (VR) of the DICOM tag can be + * OB, OD, OF, OL, OW, or UN. + * + * @see OrthancPluginEncodeDicomWebJson() and OrthancPluginEncodeDicomWebXml() + * @param node The node being generated, as provided by Orthanc. + * @param setter The setter to be used to encode the content of the node. If + * the setter is not called, the binary tag is not written to the output document. + * @param levelDepth The depth of the node in the DICOM hierarchy of sequences. + * This parameter gives the number of elements in the "levelTagGroup", + * "levelTagElement", and "levelIndex" arrays. + * @param levelTagGroup The group of the parent DICOM tags in the hierarchy. + * @param levelTagElement The element of the parent DICOM tags in the hierarchy. + * @param levelIndex The index of the node in the parent sequences of the hierarchy. + * @param tagGroup The group of the DICOM tag of interest. + * @param tagElement The element of the DICOM tag of interest. + * @param vr The value representation of the binary DICOM node. + * @ingroup Callbacks + **/ + typedef void (*OrthancPluginDicomWebBinaryCallback) ( + OrthancPluginDicomWebNode* node, + OrthancPluginDicomWebSetBinaryNode setter, + uint32_t levelDepth, + const uint16_t* levelTagGroup, + const uint16_t* levelTagElement, + const uint32_t* levelIndex, + uint16_t tagGroup, + uint16_t tagElement, + OrthancPluginValueRepresentation vr); + + + + /** + * @brief Callback executed to encode a binary tag in DICOMweb. + * + * Signature of a callback function that is called by Orthanc + * whenever a DICOM tag that contains a binary value must be written + * to a JSON or XML node, while a DICOMweb document is being + * generated. The value representation (VR) of the DICOM tag can be + * OB, OD, OF, OL, OW, or UN. + * + * @see OrthancPluginEncodeDicomWebJson() and OrthancPluginEncodeDicomWebXml() + * @param node The node being generated, as provided by Orthanc. + * @param setter The setter to be used to encode the content of the node. If + * the setter is not called, the binary tag is not written to the output document. + * @param levelDepth The depth of the node in the DICOM hierarchy of sequences. + * This parameter gives the number of elements in the "levelTagGroup", + * "levelTagElement", and "levelIndex" arrays. + * @param levelTagGroup The group of the parent DICOM tags in the hierarchy. + * @param levelTagElement The element of the parent DICOM tags in the hierarchy. + * @param levelIndex The index of the node in the parent sequences of the hierarchy. + * @param tagGroup The group of the DICOM tag of interest. + * @param tagElement The element of the DICOM tag of interest. + * @param vr The value representation of the binary DICOM node. + * @param payload The user payload. + * @ingroup Callbacks + **/ + typedef void (*OrthancPluginDicomWebBinaryCallback2) ( + OrthancPluginDicomWebNode* node, + OrthancPluginDicomWebSetBinaryNode setter, + uint32_t levelDepth, + const uint16_t* levelTagGroup, + const uint16_t* levelTagElement, + const uint32_t* levelIndex, + uint16_t tagGroup, + uint16_t tagElement, + OrthancPluginValueRepresentation vr, + void* payload); + + + + /** + * @brief Data structure that contains information about the Orthanc core. + **/ + typedef struct _OrthancPluginContext_t + { + void* pluginsManager; + const char* orthancVersion; + OrthancPluginFree Free; + OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context, + _OrthancPluginService service, + const void* params); + } OrthancPluginContext; + + + + /** + * @brief An entry in the dictionary of DICOM tags. + **/ + typedef struct + { + uint16_t group; /*!< The group of the tag */ + uint16_t element; /*!< The element of the tag */ + OrthancPluginValueRepresentation vr; /*!< The value representation of the tag */ + uint32_t minMultiplicity; /*!< The minimum multiplicity of the tag */ + uint32_t maxMultiplicity; /*!< The maximum multiplicity of the tag (0 means arbitrary) */ + } OrthancPluginDictionaryEntry; + + + + /** + * @brief Free a string. + * + * Free a string that was allocated by the core system of Orthanc. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param str The string to be freed. + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString( + OrthancPluginContext* context, + char* str) + { + if (str != NULL) + { + context->Free(str); + } + } + + + /** + * @brief Check that the version of the hosting Orthanc is above a given version. + * + * This function checks whether the version of the Orthanc server + * running this plugin, is above the given version. Contrarily to + * OrthancPluginCheckVersion(), it is up to the developer of the + * plugin to make sure that all the Orthanc SDK services called by + * the plugin are actually implemented in the given version of + * Orthanc. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param expectedMajor Expected major version. + * @param expectedMinor Expected minor version. + * @param expectedRevision Expected revision. + * @return 1 if and only if the versions are compatible. If the + * result is 0, the initialization of the plugin should fail. + * @see OrthancPluginCheckVersion + * @ingroup Callbacks + **/ + ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersionAdvanced( + OrthancPluginContext* context, + int expectedMajor, + int expectedMinor, + int expectedRevision) + { + int major, minor, revision; + + if (sizeof(int32_t) != sizeof(OrthancPluginErrorCode) || + sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) || + sizeof(int32_t) != sizeof(_OrthancPluginService) || + sizeof(int32_t) != sizeof(_OrthancPluginProperty) || + sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) || + sizeof(int32_t) != sizeof(OrthancPluginContentType) || + sizeof(int32_t) != sizeof(OrthancPluginResourceType) || + sizeof(int32_t) != sizeof(OrthancPluginChangeType) || + sizeof(int32_t) != sizeof(OrthancPluginCompressionType) || + sizeof(int32_t) != sizeof(OrthancPluginImageFormat) || + sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) || + sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) || + sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) || + sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) || + sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) || + sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin) || + sizeof(int32_t) != sizeof(OrthancPluginJobStepStatus) || + sizeof(int32_t) != sizeof(OrthancPluginConstraintType) || + sizeof(int32_t) != sizeof(OrthancPluginMetricsType) || + sizeof(int32_t) != sizeof(OrthancPluginDicomWebBinaryMode) || + sizeof(int32_t) != sizeof(OrthancPluginStorageCommitmentFailureReason) || + sizeof(int32_t) != sizeof(OrthancPluginReceivedInstanceAction)) + { + /* Mismatch in the size of the enumerations */ + return 0; + } + + /* Assume compatibility with the mainline */ + if (!strcmp(context->orthancVersion, "mainline")) + { + return 1; + } + + /* Parse the version of the Orthanc core */ + if ( +#ifdef _MSC_VER + sscanf_s +#else + sscanf +#endif + (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3) + { + return 0; + } + + /* Check the major number of the version */ + + if (major > expectedMajor) + { + return 1; + } + + if (major < expectedMajor) + { + return 0; + } + + /* Check the minor number of the version */ + + if (minor > expectedMinor) + { + return 1; + } + + if (minor < expectedMinor) + { + return 0; + } + + /* Check the revision number of the version */ + + if (revision >= expectedRevision) + { + return 1; + } + else + { + return 0; + } + } + + + /** + * @brief Check the compatibility of the plugin wrt. the version of its hosting Orthanc. + * + * This function checks whether the version of the Orthanc server + * running this plugin, is above the version of the current Orthanc + * SDK header. This guarantees that the plugin is compatible with + * the hosting Orthanc (i.e. it will not call unavailable services). + * The result of this function should always be checked in the + * OrthancPluginInitialize() entry point of the plugin. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @return 1 if and only if the versions are compatible. If the + * result is 0, the initialization of the plugin should fail. + * @see OrthancPluginCheckVersionAdvanced + * @ingroup Callbacks + **/ + ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersion( + OrthancPluginContext* context) + { + return OrthancPluginCheckVersionAdvanced( + context, + ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER, + ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER, + ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER); + } + + + /** + * @brief Free a memory buffer. + * + * Free a memory buffer that was allocated by the core system of Orthanc. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param buffer The memory buffer to release. + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer( + OrthancPluginContext* context, + OrthancPluginMemoryBuffer* buffer) + { + context->Free(buffer->data); + } + + + /** + * @brief Free a memory buffer. + * + * Free a memory buffer that was allocated by the core system of Orthanc. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param buffer The memory buffer to release. + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer64( + OrthancPluginContext* context, + OrthancPluginMemoryBuffer64* buffer) + { + context->Free(buffer->data); + } + + + /** + * @brief Log an error. + * + * Log an error message using the Orthanc logging system. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param message The message to be logged. + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginLogError( + OrthancPluginContext* context, + const char* message) + { + context->InvokeService(context, _OrthancPluginService_LogError, message); + } + + + /** + * @brief Log a warning. + * + * Log a warning message using the Orthanc logging system. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param message The message to be logged. + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning( + OrthancPluginContext* context, + const char* message) + { + context->InvokeService(context, _OrthancPluginService_LogWarning, message); + } + + + /** + * @brief Log an information. + * + * Log an information message using the Orthanc logging system. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param message The message to be logged. + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo( + OrthancPluginContext* context, + const char* message) + { + context->InvokeService(context, _OrthancPluginService_LogInfo, message); + } + + + + typedef struct + { + const char* pathRegularExpression; + OrthancPluginRestCallback callback; + } _OrthancPluginRestCallback; + + /** + * @brief Register a REST callback. + * + * This function registers a REST callback against a regular + * expression for a URI. This function must be called during the + * initialization of the plugin, i.e. inside the + * OrthancPluginInitialize() public function. + * + * Each REST callback is guaranteed to run in mutual exclusion. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param pathRegularExpression Regular expression for the URI. May contain groups. + * @param callback The callback function to handle the REST call. + * @see OrthancPluginRegisterRestCallbackNoLock() + * + * @note + * The regular expression is case sensitive and must follow the + * [Perl syntax](https://www.boost.org/doc/libs/1_67_0/libs/regex/doc/html/boost_regex/syntax/perl_syntax.html). + * + * @ingroup Callbacks + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback( + OrthancPluginContext* context, + const char* pathRegularExpression, + OrthancPluginRestCallback callback) + { + _OrthancPluginRestCallback params; + params.pathRegularExpression = pathRegularExpression; + params.callback = callback; + context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, ¶ms); + } + + + + /** + * @brief Register a REST callback, without locking. + * + * This function registers a REST callback against a regular + * expression for a URI. This function must be called during the + * initialization of the plugin, i.e. inside the + * OrthancPluginInitialize() public function. + * + * Contrarily to OrthancPluginRegisterRestCallback(), the callback + * will NOT be invoked in mutual exclusion. This can be useful for + * high-performance plugins that must handle concurrent requests + * (Orthanc uses a pool of threads, one thread being assigned to + * each incoming HTTP request). Of course, if using this function, + * it is up to the plugin to implement the required locking + * mechanisms. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param pathRegularExpression Regular expression for the URI. May contain groups. + * @param callback The callback function to handle the REST call. + * @see OrthancPluginRegisterRestCallback() + * + * @note + * The regular expression is case sensitive and must follow the + * [Perl syntax](https://www.boost.org/doc/libs/1_67_0/libs/regex/doc/html/boost_regex/syntax/perl_syntax.html). + * + * @ingroup Callbacks + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallbackNoLock( + OrthancPluginContext* context, + const char* pathRegularExpression, + OrthancPluginRestCallback callback) + { + _OrthancPluginRestCallback params; + params.pathRegularExpression = pathRegularExpression; + params.callback = callback; + context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, ¶ms); + } + + + + typedef struct + { + OrthancPluginOnStoredInstanceCallback callback; + } _OrthancPluginOnStoredInstanceCallback; + + /** + * @brief Register a callback for received instances. + * + * This function registers a callback function that is called + * whenever a new DICOM instance is stored into the Orthanc core. + * + * @warning Your callback function will be called synchronously with + * the core of Orthanc. This implies that deadlocks might emerge if + * you call other core primitives of Orthanc in your callback (such + * deadlocks are particularly visible in the presence of other plugins + * or Lua scripts). It is thus strongly advised to avoid any call to + * the REST API of Orthanc in the callback. If you have to call + * other primitives of Orthanc, you should make these calls in a + * separate thread, passing the pending events to be processed + * through a message queue. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param callback The callback function. + * @ingroup Callbacks + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnStoredInstanceCallback( + OrthancPluginContext* context, + OrthancPluginOnStoredInstanceCallback callback) + { + _OrthancPluginOnStoredInstanceCallback params; + params.callback = callback; + + context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, ¶ms); + } + + + + typedef struct + { + OrthancPluginRestOutput* output; + const void* answer; + uint32_t answerSize; + const char* mimeType; + } _OrthancPluginAnswerBuffer; + + /** + * @brief Answer to a REST request. + * + * This function answers to a REST request with the content of a memory buffer. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param output The HTTP connection to the client application. + * @param answer Pointer to the memory buffer containing the answer. + * @param answerSize Number of bytes of the answer. + * @param mimeType The MIME type of the answer. + * @ingroup REST + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer( + OrthancPluginContext* context, + OrthancPluginRestOutput* output, + const void* answer, + uint32_t answerSize, + const char* mimeType) + { + _OrthancPluginAnswerBuffer params; + params.output = output; + params.answer = answer; + params.answerSize = answerSize; + params.mimeType = mimeType; + context->InvokeService(context, _OrthancPluginService_AnswerBuffer, ¶ms); + } + + + typedef struct + { + OrthancPluginRestOutput* output; + OrthancPluginPixelFormat format; + uint32_t width; + uint32_t height; + uint32_t pitch; + const void* buffer; + } _OrthancPluginCompressAndAnswerPngImage; + + typedef struct + { + OrthancPluginRestOutput* output; + OrthancPluginImageFormat imageFormat; + OrthancPluginPixelFormat pixelFormat; + uint32_t width; + uint32_t height; + uint32_t pitch; + const void* buffer; + uint8_t quality; + } _OrthancPluginCompressAndAnswerImage; + + + /** + * @brief Answer to a REST request with a PNG image. + * + * This function answers to a REST request with a PNG image. The + * parameters of this function describe a memory buffer that + * contains an uncompressed image. The image will be automatically compressed + * as a PNG image by the core system of Orthanc. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param output The HTTP connection to the client application. + * @param format The memory layout of the uncompressed image. + * @param width The width of the image. + * @param height The height of the image. + * @param pitch The pitch of the image (i.e. the number of bytes + * between 2 successive lines of the image in the memory buffer). + * @param buffer The memory buffer containing the uncompressed image. + * @ingroup REST + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage( + OrthancPluginContext* context, + OrthancPluginRestOutput* output, + OrthancPluginPixelFormat format, + uint32_t width, + uint32_t height, + uint32_t pitch, + const void* buffer) + { + _OrthancPluginCompressAndAnswerImage params; + params.output = output; + params.imageFormat = OrthancPluginImageFormat_Png; + params.pixelFormat = format; + params.width = width; + params.height = height; + params.pitch = pitch; + params.buffer = buffer; + params.quality = 0; /* No quality for PNG */ + context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, ¶ms); + } + + + + typedef struct + { + OrthancPluginMemoryBuffer* target; + const char* instanceId; + } _OrthancPluginGetDicomForInstance; + + /** + * @brief Retrieve a DICOM instance using its Orthanc identifier. + * + * Retrieve a DICOM instance using its Orthanc identifier. The DICOM + * file is stored into a newly allocated memory buffer. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer(). + * @param instanceId The Orthanc identifier of the DICOM instance of interest. + * @return 0 if success, or the error code if failure. + * @ingroup Orthanc + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginGetDicomForInstance( + OrthancPluginContext* context, + OrthancPluginMemoryBuffer* target, + const char* instanceId) + { + _OrthancPluginGetDicomForInstance params; + params.target = target; + params.instanceId = instanceId; + return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, ¶ms); + } + + + + typedef struct + { + OrthancPluginMemoryBuffer* target; + const char* uri; + } _OrthancPluginRestApiGet; + + /** + * @brief Make a GET call to the built-in Orthanc REST API. + * + * Make a GET call to the built-in Orthanc REST API. The result to + * the query is stored into a newly allocated memory buffer. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer(). + * @param uri The URI in the built-in Orthanc API. + * @return 0 if success, or the error code if failure. + * @note If the resource is not existing (error 404), the error code will be OrthancPluginErrorCode_UnknownResource. + * @see OrthancPluginRestApiGetAfterPlugins + * @ingroup Orthanc + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRestApiGet( + OrthancPluginContext* context, + OrthancPluginMemoryBuffer* target, + const char* uri) + { + _OrthancPluginRestApiGet params; + params.target = target; + params.uri = uri; + return context->InvokeService(context, _OrthancPluginService_RestApiGet, ¶ms); + } + + + + /** + * @brief Make a GET call to the REST API, as tainted by the plugins. + * + * Make a GET call to the Orthanc REST API, after all the plugins + * are applied. In other words, if some plugin overrides or adds the + * called URI to the built-in Orthanc REST API, this call will + * return the result provided by this plugin. The result to the + * query is stored into a newly allocated memory buffer. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer(). + * @param uri The URI in the built-in Orthanc API. + * @return 0 if success, or the error code if failure. + * @note If the resource is not existing (error 404), the error code will be OrthancPluginErrorCode_UnknownResource. + * @see OrthancPluginRestApiGet + * @ingroup Orthanc + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRestApiGetAfterPlugins( + OrthancPluginContext* context, + OrthancPluginMemoryBuffer* target, + const char* uri) + { + _OrthancPluginRestApiGet params; + params.target = target; + params.uri = uri; + return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, ¶ms); + } + + + + typedef struct + { + OrthancPluginMemoryBuffer* target; + const char* uri; + const void* body; + uint32_t bodySize; + } _OrthancPluginRestApiPostPut; + + /** + * @brief Make a POST call to the built-in Orthanc REST API. + * + * Make a POST call to the built-in Orthanc REST API. The result to + * the query is stored into a newly allocated memory buffer. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer(). + * @param uri The URI in the built-in Orthanc API. + * @param body The body of the POST request. + * @param bodySize The size of the body. + * @return 0 if success, or the error code if failure. + * @note If the resource is not existing (error 404), the error code will be OrthancPluginErrorCode_UnknownResource. + * @see OrthancPluginRestApiPostAfterPlugins + * @ingroup Orthanc + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRestApiPost( + OrthancPluginContext* context, + OrthancPluginMemoryBuffer* target, + const char* uri, + const void* body, + uint32_t bodySize) + { + _OrthancPluginRestApiPostPut params; + params.target = target; + params.uri = uri; + params.body = body; + params.bodySize = bodySize; + return context->InvokeService(context, _OrthancPluginService_RestApiPost, ¶ms); + } + + + /** + * @brief Make a POST call to the REST API, as tainted by the plugins. + * + * Make a POST call to the Orthanc REST API, after all the plugins + * are applied. In other words, if some plugin overrides or adds the + * called URI to the built-in Orthanc REST API, this call will + * return the result provided by this plugin. The result to the + * query is stored into a newly allocated memory buffer. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer(). + * @param uri The URI in the built-in Orthanc API. + * @param body The body of the POST request. + * @param bodySize The size of the body. + * @return 0 if success, or the error code if failure. + * @note If the resource is not existing (error 404), the error code will be OrthancPluginErrorCode_UnknownResource. + * @see OrthancPluginRestApiPost + * @ingroup Orthanc + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRestApiPostAfterPlugins( + OrthancPluginContext* context, + OrthancPluginMemoryBuffer* target, + const char* uri, + const void* body, + uint32_t bodySize) + { + _OrthancPluginRestApiPostPut params; + params.target = target; + params.uri = uri; + params.body = body; + params.bodySize = bodySize; + return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, ¶ms); + } + + + + /** + * @brief Make a DELETE call to the built-in Orthanc REST API. + * + * Make a DELETE call to the built-in Orthanc REST API. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param uri The URI to delete in the built-in Orthanc API. + * @return 0 if success, or the error code if failure. + * @note If the resource is not existing (error 404), the error code will be OrthancPluginErrorCode_UnknownResource. + * @see OrthancPluginRestApiDeleteAfterPlugins + * @ingroup Orthanc + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRestApiDelete( + OrthancPluginContext* context, + const char* uri) + { + return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri); + } + + + /** + * @brief Make a DELETE call to the REST API, as tainted by the plugins. + * + * Make a DELETE call to the Orthanc REST API, after all the plugins + * are applied. In other words, if some plugin overrides or adds the + * called URI to the built-in Orthanc REST API, this call will + * return the result provided by this plugin. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param uri The URI to delete in the built-in Orthanc API. + * @return 0 if success, or the error code if failure. + * @note If the resource is not existing (error 404), the error code will be OrthancPluginErrorCode_UnknownResource. + * @see OrthancPluginRestApiDelete + * @ingroup Orthanc + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins( + OrthancPluginContext* context, + const char* uri) + { + return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri); + } + + + + /** + * @brief Make a PUT call to the built-in Orthanc REST API. + * + * Make a PUT call to the built-in Orthanc REST API. The result to + * the query is stored into a newly allocated memory buffer. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer(). + * @param uri The URI in the built-in Orthanc API. + * @param body The body of the PUT request. + * @param bodySize The size of the body. + * @return 0 if success, or the error code if failure. + * @note If the resource is not existing (error 404), the error code will be OrthancPluginErrorCode_UnknownResource. + * @see OrthancPluginRestApiPutAfterPlugins + * @ingroup Orthanc + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRestApiPut( + OrthancPluginContext* context, + OrthancPluginMemoryBuffer* target, + const char* uri, + const void* body, + uint32_t bodySize) + { + _OrthancPluginRestApiPostPut params; + params.target = target; + params.uri = uri; + params.body = body; + params.bodySize = bodySize; + return context->InvokeService(context, _OrthancPluginService_RestApiPut, ¶ms); + } + + + + /** + * @brief Make a PUT call to the REST API, as tainted by the plugins. + * + * Make a PUT call to the Orthanc REST API, after all the plugins + * are applied. In other words, if some plugin overrides or adds the + * called URI to the built-in Orthanc REST API, this call will + * return the result provided by this plugin. The result to the + * query is stored into a newly allocated memory buffer. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer(). + * @param uri The URI in the built-in Orthanc API. + * @param body The body of the PUT request. + * @param bodySize The size of the body. + * @return 0 if success, or the error code if failure. + * @note If the resource is not existing (error 404), the error code will be OrthancPluginErrorCode_UnknownResource. + * @see OrthancPluginRestApiPut + * @ingroup Orthanc + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRestApiPutAfterPlugins( + OrthancPluginContext* context, + OrthancPluginMemoryBuffer* target, + const char* uri, + const void* body, + uint32_t bodySize) + { + _OrthancPluginRestApiPostPut params; + params.target = target; + params.uri = uri; + params.body = body; + params.bodySize = bodySize; + return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, ¶ms); + } + + + + typedef struct + { + OrthancPluginRestOutput* output; + const char* argument; + } _OrthancPluginOutputPlusArgument; + + /** + * @brief Redirect a REST request. + * + * This function answers to a REST request by redirecting the user + * to another URI using HTTP status 301. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param output The HTTP connection to the client application. + * @param redirection Where to redirect. + * @ingroup REST + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect( + OrthancPluginContext* context, + OrthancPluginRestOutput* output, + const char* redirection) + { + _OrthancPluginOutputPlusArgument params; + params.output = output; + params.argument = redirection; + context->InvokeService(context, _OrthancPluginService_Redirect, ¶ms); + } + + + + typedef struct + { + char** result; + const char* argument; + } _OrthancPluginRetrieveDynamicString; + + /** + * @brief Look for a patient. + * + * Look for a patient stored in Orthanc, using its Patient ID tag (0x0010, 0x0020). + * This function uses the database index to run as fast as possible (it does not loop + * over all the stored patients). + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param patientID The Patient ID of interest. + * @return The NULL value if the patient is non-existent, or a string containing the + * Orthanc ID of the patient. This string must be freed by OrthancPluginFreeString(). + * @ingroup Orthanc + **/ + ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient( + OrthancPluginContext* context, + const char* patientID) + { + char* result; + + _OrthancPluginRetrieveDynamicString params; + params.result = &result; + params.argument = patientID; + + if (context->InvokeService(context, _OrthancPluginService_LookupPatient, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + + /** + * @brief Look for a study. + * + * Look for a study stored in Orthanc, using its Study Instance UID tag (0x0020, 0x000d). + * This function uses the database index to run as fast as possible (it does not loop + * over all the stored studies). + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param studyUID The Study Instance UID of interest. + * @return The NULL value if the study is non-existent, or a string containing the + * Orthanc ID of the study. This string must be freed by OrthancPluginFreeString(). + * @ingroup Orthanc + **/ + ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy( + OrthancPluginContext* context, + const char* studyUID) + { + char* result; + + _OrthancPluginRetrieveDynamicString params; + params.result = &result; + params.argument = studyUID; + + if (context->InvokeService(context, _OrthancPluginService_LookupStudy, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + + /** + * @brief Look for a study, using the accession number. + * + * Look for a study stored in Orthanc, using its Accession Number tag (0x0008, 0x0050). + * This function uses the database index to run as fast as possible (it does not loop + * over all the stored studies). + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param accessionNumber The Accession Number of interest. + * @return The NULL value if the study is non-existent, or a string containing the + * Orthanc ID of the study. This string must be freed by OrthancPluginFreeString(). + * @ingroup Orthanc + **/ + ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudyWithAccessionNumber( + OrthancPluginContext* context, + const char* accessionNumber) + { + char* result; + + _OrthancPluginRetrieveDynamicString params; + params.result = &result; + params.argument = accessionNumber; + + if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + + /** + * @brief Look for a series. + * + * Look for a series stored in Orthanc, using its Series Instance UID tag (0x0020, 0x000e). + * This function uses the database index to run as fast as possible (it does not loop + * over all the stored series). + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param seriesUID The Series Instance UID of interest. + * @return The NULL value if the series is non-existent, or a string containing the + * Orthanc ID of the series. This string must be freed by OrthancPluginFreeString(). + * @ingroup Orthanc + **/ + ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries( + OrthancPluginContext* context, + const char* seriesUID) + { + char* result; + + _OrthancPluginRetrieveDynamicString params; + params.result = &result; + params.argument = seriesUID; + + if (context->InvokeService(context, _OrthancPluginService_LookupSeries, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + + /** + * @brief Look for an instance. + * + * Look for an instance stored in Orthanc, using its SOP Instance UID tag (0x0008, 0x0018). + * This function uses the database index to run as fast as possible (it does not loop + * over all the stored instances). + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param sopInstanceUID The SOP Instance UID of interest. + * @return The NULL value if the instance is non-existent, or a string containing the + * Orthanc ID of the instance. This string must be freed by OrthancPluginFreeString(). + * @ingroup Orthanc + **/ + ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance( + OrthancPluginContext* context, + const char* sopInstanceUID) + { + char* result; + + _OrthancPluginRetrieveDynamicString params; + params.result = &result; + params.argument = sopInstanceUID; + + if (context->InvokeService(context, _OrthancPluginService_LookupInstance, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + + + typedef struct + { + OrthancPluginRestOutput* output; + uint16_t status; + } _OrthancPluginSendHttpStatusCode; + + /** + * @brief Send a HTTP status code. + * + * This function answers to a REST request by sending a HTTP status + * code (such as "400 - Bad Request"). Note that: + * - Successful requests (status 200) must use ::OrthancPluginAnswerBuffer(). + * - Redirections (status 301) must use ::OrthancPluginRedirect(). + * - Unauthorized access (status 401) must use ::OrthancPluginSendUnauthorized(). + * - Methods not allowed (status 405) must use ::OrthancPluginSendMethodNotAllowed(). + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param output The HTTP connection to the client application. + * @param status The HTTP status code to be sent. + * @ingroup REST + * @see OrthancPluginSendHttpStatus() + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode( + OrthancPluginContext* context, + OrthancPluginRestOutput* output, + uint16_t status) + { + _OrthancPluginSendHttpStatusCode params; + params.output = output; + params.status = status; + context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, ¶ms); + } + + + /** + * @brief Signal that a REST request is not authorized. + * + * This function answers to a REST request by signaling that it is + * not authorized. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param output The HTTP connection to the client application. + * @param realm The realm for the authorization process. + * @ingroup REST + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized( + OrthancPluginContext* context, + OrthancPluginRestOutput* output, + const char* realm) + { + _OrthancPluginOutputPlusArgument params; + params.output = output; + params.argument = realm; + context->InvokeService(context, _OrthancPluginService_SendUnauthorized, ¶ms); + } + + + /** + * @brief Signal that this URI does not support this HTTP method. + * + * This function answers to a REST request by signaling that the + * queried URI does not support this method. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param output The HTTP connection to the client application. + * @param allowedMethods The allowed methods for this URI (e.g. "GET,POST" after a PUT or a POST request). + * @ingroup REST + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed( + OrthancPluginContext* context, + OrthancPluginRestOutput* output, + const char* allowedMethods) + { + _OrthancPluginOutputPlusArgument params; + params.output = output; + params.argument = allowedMethods; + context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, ¶ms); + } + + + typedef struct + { + OrthancPluginRestOutput* output; + const char* key; + const char* value; + } _OrthancPluginSetHttpHeader; + + /** + * @brief Set a cookie. + * + * This function sets a cookie in the HTTP client. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param output The HTTP connection to the client application. + * @param cookie The cookie to be set. + * @param value The value of the cookie. + * @ingroup REST + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie( + OrthancPluginContext* context, + OrthancPluginRestOutput* output, + const char* cookie, + const char* value) + { + _OrthancPluginSetHttpHeader params; + params.output = output; + params.key = cookie; + params.value = value; + context->InvokeService(context, _OrthancPluginService_SetCookie, ¶ms); + } + + + /** + * @brief Set some HTTP header. + * + * This function sets a HTTP header in the HTTP answer. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param output The HTTP connection to the client application. + * @param key The HTTP header to be set. + * @param value The value of the HTTP header. + * @ingroup REST + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader( + OrthancPluginContext* context, + OrthancPluginRestOutput* output, + const char* key, + const char* value) + { + _OrthancPluginSetHttpHeader params; + params.output = output; + params.key = key; + params.value = value; + context->InvokeService(context, _OrthancPluginService_SetHttpHeader, ¶ms); + } + + + typedef struct + { + char** resultStringToFree; + const char** resultString; + int64_t* resultInt64; + const char* key; + const OrthancPluginDicomInstance* instance; + OrthancPluginInstanceOrigin* resultOrigin; /* New in Orthanc 0.9.5 SDK */ + } _OrthancPluginAccessDicomInstance; + + + /** + * @brief Get the AET of a DICOM instance. + * + * This function returns the Application Entity Title (AET) of the + * DICOM modality from which a DICOM instance originates. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param instance The instance of interest. + * @return The AET if success, NULL if error. + * @ingroup DicomInstance + **/ + ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet( + OrthancPluginContext* context, + const OrthancPluginDicomInstance* instance) + { + const char* result; + + _OrthancPluginAccessDicomInstance params; + memset(¶ms, 0, sizeof(params)); + params.resultString = &result; + params.instance = instance; + + if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + + /** + * @brief Get the size of a DICOM file. + * + * This function returns the number of bytes of the given DICOM instance. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param instance The instance of interest. + * @return The size of the file, -1 in case of error. + * @ingroup DicomInstance + **/ + ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize( + OrthancPluginContext* context, + const OrthancPluginDicomInstance* instance) + { + int64_t size; + + _OrthancPluginAccessDicomInstance params; + memset(¶ms, 0, sizeof(params)); + params.resultInt64 = &size; + params.instance = instance; + + if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return -1; + } + else + { + return size; + } + } + + + /** + * @brief Get the data of a DICOM file. + * + * This function returns a pointer to the content of the given DICOM instance. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param instance The instance of interest. + * @return The pointer to the DICOM data, NULL in case of error. + * @ingroup DicomInstance + **/ + ORTHANC_PLUGIN_INLINE const void* OrthancPluginGetInstanceData( + OrthancPluginContext* context, + const OrthancPluginDicomInstance* instance) + { + const char* result; + + _OrthancPluginAccessDicomInstance params; + memset(¶ms, 0, sizeof(params)); + params.resultString = &result; + params.instance = instance; + + if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + + /** + * @brief Get the DICOM tag hierarchy as a JSON file. + * + * This function returns a pointer to a newly created string + * containing a JSON file. This JSON file encodes the tag hierarchy + * of the given DICOM instance. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param instance The instance of interest. + * @return The NULL value in case of error, or a string containing the JSON file. + * This string must be freed by OrthancPluginFreeString(). + * @ingroup DicomInstance + **/ + ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson( + OrthancPluginContext* context, + const OrthancPluginDicomInstance* instance) + { + char* result; + + _OrthancPluginAccessDicomInstance params; + memset(¶ms, 0, sizeof(params)); + params.resultStringToFree = &result; + params.instance = instance; + + if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + + /** + * @brief Get the DICOM tag hierarchy as a JSON file (with simplification). + * + * This function returns a pointer to a newly created string + * containing a JSON file. This JSON file encodes the tag hierarchy + * of the given DICOM instance. In contrast with + * ::OrthancPluginGetInstanceJson(), the returned JSON file is in + * its simplified version. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param instance The instance of interest. + * @return The NULL value in case of error, or a string containing the JSON file. + * This string must be freed by OrthancPluginFreeString(). + * @ingroup DicomInstance + **/ + ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson( + OrthancPluginContext* context, + const OrthancPluginDicomInstance* instance) + { + char* result; + + _OrthancPluginAccessDicomInstance params; + memset(¶ms, 0, sizeof(params)); + params.resultStringToFree = &result; + params.instance = instance; + + if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + + /** + * @brief Check whether a DICOM instance is associated with some metadata. + * + * This function checks whether the DICOM instance of interest is + * associated with some metadata. As of Orthanc 0.8.1, in the + * callbacks registered by + * ::OrthancPluginRegisterOnStoredInstanceCallback(), the only + * possibly available metadata are "ReceptionDate", "RemoteAET" and + * "IndexInSeries". + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param instance The instance of interest. + * @param metadata The metadata of interest. + * @return 1 if the metadata is present, 0 if it is absent, -1 in case of error. + * @ingroup DicomInstance + **/ + ORTHANC_PLUGIN_INLINE int OrthancPluginHasInstanceMetadata( + OrthancPluginContext* context, + const OrthancPluginDicomInstance* instance, + const char* metadata) + { + int64_t result; + + _OrthancPluginAccessDicomInstance params; + memset(¶ms, 0, sizeof(params)); + params.resultInt64 = &result; + params.instance = instance; + params.key = metadata; + + if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return -1; + } + else + { + return (result != 0); + } + } + + + /** + * @brief Get the value of some metadata associated with a given DICOM instance. + * + * This functions returns the value of some metadata that is associated with the DICOM instance of interest. + * Before calling this function, the existence of the metadata must have been checked with + * ::OrthancPluginHasInstanceMetadata(). + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param instance The instance of interest. + * @param metadata The metadata of interest. + * @return The metadata value if success, NULL if error. Please note that the + * returned string belongs to the instance object and must NOT be + * deallocated. Please make a copy of the string if you wish to access + * it later. + * @ingroup DicomInstance + **/ + ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata( + OrthancPluginContext* context, + const OrthancPluginDicomInstance* instance, + const char* metadata) + { + const char* result; + + _OrthancPluginAccessDicomInstance params; + memset(¶ms, 0, sizeof(params)); + params.resultString = &result; + params.instance = instance; + params.key = metadata; + + if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + + + typedef struct + { + OrthancPluginStorageCreate create; + OrthancPluginStorageRead read; + OrthancPluginStorageRemove remove; + OrthancPluginFree free; + } _OrthancPluginRegisterStorageArea; + + /** + * @brief Register a custom storage area. + * + * This function registers a custom storage area, to replace the + * built-in way Orthanc stores its files on the filesystem. This + * function must be called during the initialization of the plugin, + * i.e. inside the OrthancPluginInitialize() public function. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param create The callback function to store a file on the custom storage area. + * @param read The callback function to read a file from the custom storage area. + * @param remove The callback function to remove a file from the custom storage area. + * @ingroup Callbacks + * @deprecated Please use OrthancPluginRegisterStorageArea2() + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea( + OrthancPluginContext* context, + OrthancPluginStorageCreate create, + OrthancPluginStorageRead read, + OrthancPluginStorageRemove remove) + { + _OrthancPluginRegisterStorageArea params; + params.create = create; + params.read = read; + params.remove = remove; + +#ifdef __cplusplus + params.free = ::free; +#else + params.free = free; +#endif + + context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, ¶ms); + } + + + + /** + * @brief Return the path to the Orthanc executable. + * + * This function returns the path to the Orthanc executable. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @return NULL in the case of an error, or a newly allocated string + * containing the path. This string must be freed by + * OrthancPluginFreeString(). + **/ + ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context) + { + char* result; + + _OrthancPluginRetrieveDynamicString params; + params.result = &result; + params.argument = NULL; + + if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + + /** + * @brief Return the directory containing the Orthanc. + * + * This function returns the path to the directory containing the Orthanc executable. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @return NULL in the case of an error, or a newly allocated string + * containing the path. This string must be freed by + * OrthancPluginFreeString(). + **/ + ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context) + { + char* result; + + _OrthancPluginRetrieveDynamicString params; + params.result = &result; + params.argument = NULL; + + if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + + /** + * @brief Return the path to the configuration file(s). + * + * This function returns the path to the configuration file(s) that + * was specified when starting Orthanc. Since version 0.9.1, this + * path can refer to a folder that stores a set of configuration + * files. This function is deprecated in favor of + * OrthancPluginGetConfiguration(). + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @return NULL in the case of an error, or a newly allocated string + * containing the path. This string must be freed by + * OrthancPluginFreeString(). + * @see OrthancPluginGetConfiguration() + **/ + ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context) + { + char* result; + + _OrthancPluginRetrieveDynamicString params; + params.result = &result; + params.argument = NULL; + + if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + + + typedef struct + { + OrthancPluginOnChangeCallback callback; + } _OrthancPluginOnChangeCallback; + + /** + * @brief Register a callback to monitor changes. + * + * This function registers a callback function that is called + * whenever a change happens to some DICOM resource. + * + * @warning Your callback function will be called synchronously with + * the core of Orthanc. This implies that deadlocks might emerge if + * you call other core primitives of Orthanc in your callback (such + * deadlocks are particularly visible in the presence of other plugins + * or Lua scripts). It is thus strongly advised to avoid any call to + * the REST API of Orthanc in the callback. If you have to call + * other primitives of Orthanc, you should make these calls in a + * separate thread, passing the pending events to be processed + * through a message queue. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param callback The callback function. + * @ingroup Callbacks + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback( + OrthancPluginContext* context, + OrthancPluginOnChangeCallback callback) + { + _OrthancPluginOnChangeCallback params; + params.callback = callback; + + context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, ¶ms); + } + + + + typedef struct + { + const char* plugin; + _OrthancPluginProperty property; + const char* value; + } _OrthancPluginSetPluginProperty; + + + /** + * @brief Set the URI where the plugin provides its Web interface. + * + * For plugins that come with a Web interface, this function + * declares the entry path where to find this interface. This + * information is notably used in the "Plugins" page of Orthanc + * Explorer. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param uri The root URI for this plugin. + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri( + OrthancPluginContext* context, + const char* uri) + { + _OrthancPluginSetPluginProperty params; + params.plugin = OrthancPluginGetName(); + params.property = _OrthancPluginProperty_RootUri; + params.value = uri; + + context->InvokeService(context, _OrthancPluginService_SetPluginProperty, ¶ms); + } + + + /** + * @brief Set a description for this plugin. + * + * Set a description for this plugin. It is displayed in the + * "Plugins" page of Orthanc Explorer. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param description The description. + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription( + OrthancPluginContext* context, + const char* description) + { + _OrthancPluginSetPluginProperty params; + params.plugin = OrthancPluginGetName(); + params.property = _OrthancPluginProperty_Description; + params.value = description; + + context->InvokeService(context, _OrthancPluginService_SetPluginProperty, ¶ms); + } + + + /** + * @brief Extend the JavaScript code of Orthanc Explorer. + * + * Add JavaScript code to customize the default behavior of Orthanc + * Explorer. This can for instance be used to add new buttons. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param javascript The custom JavaScript code. + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer( + OrthancPluginContext* context, + const char* javascript) + { + _OrthancPluginSetPluginProperty params; + params.plugin = OrthancPluginGetName(); + params.property = _OrthancPluginProperty_OrthancExplorer; + params.value = javascript; + + context->InvokeService(context, _OrthancPluginService_SetPluginProperty, ¶ms); + } + + + typedef struct + { + char** result; + int32_t property; + const char* value; + } _OrthancPluginGlobalProperty; + + + /** + * @brief Get the value of a global property. + * + * Get the value of a global property that is stored in the Orthanc database. Global + * properties whose index is below 1024 are reserved by Orthanc. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param property The global property of interest. + * @param defaultValue The value to return, if the global property is unset. + * @return The value of the global property, or NULL in the case of an error. This + * string must be freed by OrthancPluginFreeString(). + * @ingroup Orthanc + **/ + ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty( + OrthancPluginContext* context, + int32_t property, + const char* defaultValue) + { + char* result; + + _OrthancPluginGlobalProperty params; + params.result = &result; + params.property = property; + params.value = defaultValue; + + if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + + /** + * @brief Set the value of a global property. + * + * Set the value of a global property into the Orthanc + * database. Setting a global property can be used by plugins to + * save their internal parameters. Plugins are only allowed to set + * properties whose index are above or equal to 1024 (properties + * below 1024 are read-only and reserved by Orthanc). + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param property The global property of interest. + * @param value The value to be set in the global property. + * @return 0 if success, or the error code if failure. + * @ingroup Orthanc + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginSetGlobalProperty( + OrthancPluginContext* context, + int32_t property, + const char* value) + { + _OrthancPluginGlobalProperty params; + params.result = NULL; + params.property = property; + params.value = value; + + return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, ¶ms); + } + + + + typedef struct + { + int32_t *resultInt32; + uint32_t *resultUint32; + int64_t *resultInt64; + uint64_t *resultUint64; + } _OrthancPluginReturnSingleValue; + + /** + * @brief Get the number of command-line arguments. + * + * Retrieve the number of command-line arguments that were used to launch Orthanc. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @return The number of arguments. + **/ + ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount( + OrthancPluginContext* context) + { + uint32_t count = 0; + + _OrthancPluginReturnSingleValue params; + memset(¶ms, 0, sizeof(params)); + params.resultUint32 = &count; + + if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return 0; + } + else + { + return count; + } + } + + + + /** + * @brief Get the value of a command-line argument. + * + * Get the value of one of the command-line arguments that were used + * to launch Orthanc. The number of available arguments can be + * retrieved by OrthancPluginGetCommandLineArgumentsCount(). + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param argument The index of the argument. + * @return The value of the argument, or NULL in the case of an error. This + * string must be freed by OrthancPluginFreeString(). + **/ + ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument( + OrthancPluginContext* context, + uint32_t argument) + { + char* result; + + _OrthancPluginGlobalProperty params; + params.result = &result; + params.property = (int32_t) argument; + params.value = NULL; + + if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + + /** + * @brief Get the expected version of the database schema. + * + * Retrieve the expected version of the database schema. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @return The version. + * @ingroup Callbacks + **/ + ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion( + OrthancPluginContext* context) + { + uint32_t count = 0; + + _OrthancPluginReturnSingleValue params; + memset(¶ms, 0, sizeof(params)); + params.resultUint32 = &count; + + if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return 0; + } + else + { + return count; + } + } + + + + /** + * @brief Return the content of the configuration file(s). + * + * This function returns the content of the configuration that is + * used by Orthanc, formatted as a JSON string. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @return NULL in the case of an error, or a newly allocated string + * containing the configuration. This string must be freed by + * OrthancPluginFreeString(). + **/ + ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context) + { + char* result; + + _OrthancPluginRetrieveDynamicString params; + params.result = &result; + params.argument = NULL; + + if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + + + typedef struct + { + OrthancPluginRestOutput* output; + const char* subType; + const char* contentType; + } _OrthancPluginStartMultipartAnswer; + + /** + * @brief Start an HTTP multipart answer. + * + * Initiates a HTTP multipart answer, as the result of a REST request. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param output The HTTP connection to the client application. + * @param subType The sub-type of the multipart answer ("mixed" or "related"). + * @param contentType The MIME type of the items in the multipart answer. + * @return 0 if success, or the error code if failure. + * @see OrthancPluginSendMultipartItem(), OrthancPluginSendMultipartItem2() + * @ingroup REST + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginStartMultipartAnswer( + OrthancPluginContext* context, + OrthancPluginRestOutput* output, + const char* subType, + const char* contentType) + { + _OrthancPluginStartMultipartAnswer params; + params.output = output; + params.subType = subType; + params.contentType = contentType; + return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, ¶ms); + } + + + /** + * @brief Send an item as a part of some HTTP multipart answer. + * + * This function sends an item as a part of some HTTP multipart + * answer that was initiated by OrthancPluginStartMultipartAnswer(). + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param output The HTTP connection to the client application. + * @param answer Pointer to the memory buffer containing the item. + * @param answerSize Number of bytes of the item. + * @return 0 if success, or the error code if failure (this notably happens + * if the connection is closed by the client). + * @see OrthancPluginSendMultipartItem2() + * @ingroup REST + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginSendMultipartItem( + OrthancPluginContext* context, + OrthancPluginRestOutput* output, + const void* answer, + uint32_t answerSize) + { + _OrthancPluginAnswerBuffer params; + params.output = output; + params.answer = answer; + params.answerSize = answerSize; + params.mimeType = NULL; + return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, ¶ms); + } + + + + typedef struct + { + OrthancPluginMemoryBuffer* target; + const void* source; + uint32_t size; + OrthancPluginCompressionType compression; + uint8_t uncompress; + } _OrthancPluginBufferCompression; + + + /** + * @brief Compress or decompress a buffer. + * + * This function compresses or decompresses a buffer, using the + * version of the zlib library that is used by the Orthanc core. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer(). + * @param source The source buffer. + * @param size The size in bytes of the source buffer. + * @param compression The compression algorithm. + * @param uncompress If set to "0", the buffer must be compressed. + * If set to "1", the buffer must be uncompressed. + * @return 0 if success, or the error code if failure. + * @ingroup Images + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginBufferCompression( + OrthancPluginContext* context, + OrthancPluginMemoryBuffer* target, + const void* source, + uint32_t size, + OrthancPluginCompressionType compression, + uint8_t uncompress) + { + _OrthancPluginBufferCompression params; + params.target = target; + params.source = source; + params.size = size; + params.compression = compression; + params.uncompress = uncompress; + + return context->InvokeService(context, _OrthancPluginService_BufferCompression, ¶ms); + } + + + + typedef struct + { + OrthancPluginMemoryBuffer* target; + const char* path; + } _OrthancPluginReadFile; + + /** + * @brief Read a file. + * + * Read the content of a file on the filesystem, and returns it into + * a newly allocated memory buffer. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer(). + * @param path The path of the file to be read. + * @return 0 if success, or the error code if failure. + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginReadFile( + OrthancPluginContext* context, + OrthancPluginMemoryBuffer* target, + const char* path) + { + _OrthancPluginReadFile params; + params.target = target; + params.path = path; + return context->InvokeService(context, _OrthancPluginService_ReadFile, ¶ms); + } + + + + typedef struct + { + const char* path; + const void* data; + uint32_t size; + } _OrthancPluginWriteFile; + + /** + * @brief Write a file. + * + * Write the content of a memory buffer to the filesystem. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param path The path of the file to be written. + * @param data The content of the memory buffer. + * @param size The size of the memory buffer. + * @return 0 if success, or the error code if failure. + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginWriteFile( + OrthancPluginContext* context, + const char* path, + const void* data, + uint32_t size) + { + _OrthancPluginWriteFile params; + params.path = path; + params.data = data; + params.size = size; + return context->InvokeService(context, _OrthancPluginService_WriteFile, ¶ms); + } + + + + typedef struct + { + const char** target; + OrthancPluginErrorCode error; + } _OrthancPluginGetErrorDescription; + + /** + * @brief Get the description of a given error code. + * + * This function returns the description of a given error code. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param error The error code of interest. + * @return The error description. This is a statically-allocated + * string, do not free it. + **/ + ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription( + OrthancPluginContext* context, + OrthancPluginErrorCode error) + { + const char* result = NULL; + + _OrthancPluginGetErrorDescription params; + params.target = &result; + params.error = error; + + if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, ¶ms) != OrthancPluginErrorCode_Success || + result == NULL) + { + return "Unknown error code"; + } + else + { + return result; + } + } + + + + typedef struct + { + OrthancPluginRestOutput* output; + uint16_t status; + const void* body; + uint32_t bodySize; + } _OrthancPluginSendHttpStatus; + + /** + * @brief Send a HTTP status, with a custom body. + * + * This function answers to a HTTP request by sending a HTTP status + * code (such as "400 - Bad Request"), together with a body + * describing the error. The body will only be returned if the + * configuration option "HttpDescribeErrors" of Orthanc is set to "true". + * + * Note that: + * - Successful requests (status 200) must use ::OrthancPluginAnswerBuffer(). + * - Redirections (status 301) must use ::OrthancPluginRedirect(). + * - Unauthorized access (status 401) must use ::OrthancPluginSendUnauthorized(). + * - Methods not allowed (status 405) must use ::OrthancPluginSendMethodNotAllowed(). + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param output The HTTP connection to the client application. + * @param status The HTTP status code to be sent. + * @param body The body of the answer. + * @param bodySize The size of the body. + * @see OrthancPluginSendHttpStatusCode() + * @ingroup REST + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus( + OrthancPluginContext* context, + OrthancPluginRestOutput* output, + uint16_t status, + const void* body, + uint32_t bodySize) + { + _OrthancPluginSendHttpStatus params; + params.output = output; + params.status = status; + params.body = body; + params.bodySize = bodySize; + context->InvokeService(context, _OrthancPluginService_SendHttpStatus, ¶ms); + } + + + + typedef struct + { + const OrthancPluginImage* image; + uint32_t* resultUint32; + OrthancPluginPixelFormat* resultPixelFormat; + void** resultBuffer; + } _OrthancPluginGetImageInfo; + + + /** + * @brief Return the pixel format of an image. + * + * This function returns the type of memory layout for the pixels of the given image. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param image The image of interest. + * @return The pixel format. + * @ingroup Images + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat( + OrthancPluginContext* context, + const OrthancPluginImage* image) + { + OrthancPluginPixelFormat target; + + _OrthancPluginGetImageInfo params; + memset(¶ms, 0, sizeof(params)); + params.image = image; + params.resultPixelFormat = ⌖ + + if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, ¶ms) != OrthancPluginErrorCode_Success) + { + return OrthancPluginPixelFormat_Unknown; + } + else + { + return (OrthancPluginPixelFormat) target; + } + } + + + + /** + * @brief Return the width of an image. + * + * This function returns the width of the given image. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param image The image of interest. + * @return The width. + * @ingroup Images + **/ + ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth( + OrthancPluginContext* context, + const OrthancPluginImage* image) + { + uint32_t width; + + _OrthancPluginGetImageInfo params; + memset(¶ms, 0, sizeof(params)); + params.image = image; + params.resultUint32 = &width; + + if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, ¶ms) != OrthancPluginErrorCode_Success) + { + return 0; + } + else + { + return width; + } + } + + + + /** + * @brief Return the height of an image. + * + * This function returns the height of the given image. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param image The image of interest. + * @return The height. + * @ingroup Images + **/ + ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight( + OrthancPluginContext* context, + const OrthancPluginImage* image) + { + uint32_t height; + + _OrthancPluginGetImageInfo params; + memset(¶ms, 0, sizeof(params)); + params.image = image; + params.resultUint32 = &height; + + if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, ¶ms) != OrthancPluginErrorCode_Success) + { + return 0; + } + else + { + return height; + } + } + + + + /** + * @brief Return the pitch of an image. + * + * This function returns the pitch of the given image. The pitch is + * defined as the number of bytes between 2 successive lines of the + * image in the memory buffer. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param image The image of interest. + * @return The pitch. + * @ingroup Images + **/ + ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch( + OrthancPluginContext* context, + const OrthancPluginImage* image) + { + uint32_t pitch; + + _OrthancPluginGetImageInfo params; + memset(¶ms, 0, sizeof(params)); + params.image = image; + params.resultUint32 = &pitch; + + if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, ¶ms) != OrthancPluginErrorCode_Success) + { + return 0; + } + else + { + return pitch; + } + } + + + + /** + * @brief Return a pointer to the content of an image. + * + * This function returns a pointer to the memory buffer that + * contains the pixels of the image. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param image The image of interest. + * @return The pointer. + * @ingroup Images + **/ + ORTHANC_PLUGIN_INLINE void* OrthancPluginGetImageBuffer( + OrthancPluginContext* context, + const OrthancPluginImage* image) + { + void* target = NULL; + + _OrthancPluginGetImageInfo params; + memset(¶ms, 0, sizeof(params)); + params.resultBuffer = ⌖ + params.image = image; + + if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, ¶ms) != OrthancPluginErrorCode_Success) + { + return NULL; + } + else + { + return target; + } + } + + + typedef struct + { + OrthancPluginImage** target; + const void* data; + uint32_t size; + OrthancPluginImageFormat format; + } _OrthancPluginUncompressImage; + + + /** + * @brief Decode a compressed image. + * + * This function decodes a compressed image from a memory buffer. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param data Pointer to a memory buffer containing the compressed image. + * @param size Size of the memory buffer containing the compressed image. + * @param format The file format of the compressed image. + * @return The uncompressed image. It must be freed with OrthancPluginFreeImage(). + * @ingroup Images + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginImage *OrthancPluginUncompressImage( + OrthancPluginContext* context, + const void* data, + uint32_t size, + OrthancPluginImageFormat format) + { + OrthancPluginImage* target = NULL; + + _OrthancPluginUncompressImage params; + memset(¶ms, 0, sizeof(params)); + params.target = ⌖ + params.data = data; + params.size = size; + params.format = format; + + if (context->InvokeService(context, _OrthancPluginService_UncompressImage, ¶ms) != OrthancPluginErrorCode_Success) + { + return NULL; + } + else + { + return target; + } + } + + + + + typedef struct + { + OrthancPluginImage* image; + } _OrthancPluginFreeImage; + + /** + * @brief Free an image. + * + * This function frees an image that was decoded with OrthancPluginUncompressImage(). + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param image The image. + * @ingroup Images + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage( + OrthancPluginContext* context, + OrthancPluginImage* image) + { + _OrthancPluginFreeImage params; + params.image = image; + + context->InvokeService(context, _OrthancPluginService_FreeImage, ¶ms); + } + + + + + typedef struct + { + OrthancPluginMemoryBuffer* target; + OrthancPluginImageFormat imageFormat; + OrthancPluginPixelFormat pixelFormat; + uint32_t width; + uint32_t height; + uint32_t pitch; + const void* buffer; + uint8_t quality; + } _OrthancPluginCompressImage; + + + /** + * @brief Encode a PNG image. + * + * This function compresses the given memory buffer containing an + * image using the PNG specification, and stores the result of the + * compression into a newly allocated memory buffer. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer(). + * @param format The memory layout of the uncompressed image. + * @param width The width of the image. + * @param height The height of the image. + * @param pitch The pitch of the image (i.e. the number of bytes + * between 2 successive lines of the image in the memory buffer). + * @param buffer The memory buffer containing the uncompressed image. + * @return 0 if success, or the error code if failure. + * @see OrthancPluginCompressAndAnswerPngImage() + * @ingroup Images + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginCompressPngImage( + OrthancPluginContext* context, + OrthancPluginMemoryBuffer* target, + OrthancPluginPixelFormat format, + uint32_t width, + uint32_t height, + uint32_t pitch, + const void* buffer) + { + _OrthancPluginCompressImage params; + memset(¶ms, 0, sizeof(params)); + params.target = target; + params.imageFormat = OrthancPluginImageFormat_Png; + params.pixelFormat = format; + params.width = width; + params.height = height; + params.pitch = pitch; + params.buffer = buffer; + params.quality = 0; /* Unused for PNG */ + + return context->InvokeService(context, _OrthancPluginService_CompressImage, ¶ms); + } + + + /** + * @brief Encode a JPEG image. + * + * This function compresses the given memory buffer containing an + * image using the JPEG specification, and stores the result of the + * compression into a newly allocated memory buffer. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer(). + * @param format The memory layout of the uncompressed image. + * @param width The width of the image. + * @param height The height of the image. + * @param pitch The pitch of the image (i.e. the number of bytes + * between 2 successive lines of the image in the memory buffer). + * @param buffer The memory buffer containing the uncompressed image. + * @param quality The quality of the JPEG encoding, between 1 (worst + * quality, best compression) and 100 (best quality, worst + * compression). + * @return 0 if success, or the error code if failure. + * @ingroup Images + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginCompressJpegImage( + OrthancPluginContext* context, + OrthancPluginMemoryBuffer* target, + OrthancPluginPixelFormat format, + uint32_t width, + uint32_t height, + uint32_t pitch, + const void* buffer, + uint8_t quality) + { + _OrthancPluginCompressImage params; + memset(¶ms, 0, sizeof(params)); + params.target = target; + params.imageFormat = OrthancPluginImageFormat_Jpeg; + params.pixelFormat = format; + params.width = width; + params.height = height; + params.pitch = pitch; + params.buffer = buffer; + params.quality = quality; + + return context->InvokeService(context, _OrthancPluginService_CompressImage, ¶ms); + } + + + + /** + * @brief Answer to a REST request with a JPEG image. + * + * This function answers to a REST request with a JPEG image. The + * parameters of this function describe a memory buffer that + * contains an uncompressed image. The image will be automatically compressed + * as a JPEG image by the core system of Orthanc. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param output The HTTP connection to the client application. + * @param format The memory layout of the uncompressed image. + * @param width The width of the image. + * @param height The height of the image. + * @param pitch The pitch of the image (i.e. the number of bytes + * between 2 successive lines of the image in the memory buffer). + * @param buffer The memory buffer containing the uncompressed image. + * @param quality The quality of the JPEG encoding, between 1 (worst + * quality, best compression) and 100 (best quality, worst + * compression). + * @ingroup REST + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerJpegImage( + OrthancPluginContext* context, + OrthancPluginRestOutput* output, + OrthancPluginPixelFormat format, + uint32_t width, + uint32_t height, + uint32_t pitch, + const void* buffer, + uint8_t quality) + { + _OrthancPluginCompressAndAnswerImage params; + params.output = output; + params.imageFormat = OrthancPluginImageFormat_Jpeg; + params.pixelFormat = format; + params.width = width; + params.height = height; + params.pitch = pitch; + params.buffer = buffer; + params.quality = quality; + context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, ¶ms); + } + + + + + typedef struct + { + OrthancPluginMemoryBuffer* target; + OrthancPluginHttpMethod method; + const char* url; + const char* username; + const char* password; + const void* body; + uint32_t bodySize; + } _OrthancPluginCallHttpClient; + + + /** + * @brief Issue a HTTP GET call. + * + * Make a HTTP GET call to the given URL. The result to the query is + * stored into a newly allocated memory buffer. Favor + * OrthancPluginRestApiGet() if calling the built-in REST API of the + * Orthanc instance that hosts this plugin. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer(). + * @param url The URL of interest. + * @param username The username (can be NULL if no password protection). + * @param password The password (can be NULL if no password protection). + * @return 0 if success, or the error code if failure. + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginHttpGet( + OrthancPluginContext* context, + OrthancPluginMemoryBuffer* target, + const char* url, + const char* username, + const char* password) + { + _OrthancPluginCallHttpClient params; + memset(¶ms, 0, sizeof(params)); + + params.target = target; + params.method = OrthancPluginHttpMethod_Get; + params.url = url; + params.username = username; + params.password = password; + + return context->InvokeService(context, _OrthancPluginService_CallHttpClient, ¶ms); + } + + + /** + * @brief Issue a HTTP POST call. + * + * Make a HTTP POST call to the given URL. The result to the query + * is stored into a newly allocated memory buffer. Favor + * OrthancPluginRestApiPost() if calling the built-in REST API of + * the Orthanc instance that hosts this plugin. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer(). + * @param url The URL of interest. + * @param body The content of the body of the request. + * @param bodySize The size of the body of the request. + * @param username The username (can be NULL if no password protection). + * @param password The password (can be NULL if no password protection). + * @return 0 if success, or the error code if failure. + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginHttpPost( + OrthancPluginContext* context, + OrthancPluginMemoryBuffer* target, + const char* url, + const void* body, + uint32_t bodySize, + const char* username, + const char* password) + { + _OrthancPluginCallHttpClient params; + memset(¶ms, 0, sizeof(params)); + + params.target = target; + params.method = OrthancPluginHttpMethod_Post; + params.url = url; + params.body = body; + params.bodySize = bodySize; + params.username = username; + params.password = password; + + return context->InvokeService(context, _OrthancPluginService_CallHttpClient, ¶ms); + } + + + /** + * @brief Issue a HTTP PUT call. + * + * Make a HTTP PUT call to the given URL. The result to the query is + * stored into a newly allocated memory buffer. Favor + * OrthancPluginRestApiPut() if calling the built-in REST API of the + * Orthanc instance that hosts this plugin. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer(). + * @param url The URL of interest. + * @param body The content of the body of the request. + * @param bodySize The size of the body of the request. + * @param username The username (can be NULL if no password protection). + * @param password The password (can be NULL if no password protection). + * @return 0 if success, or the error code if failure. + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginHttpPut( + OrthancPluginContext* context, + OrthancPluginMemoryBuffer* target, + const char* url, + const void* body, + uint32_t bodySize, + const char* username, + const char* password) + { + _OrthancPluginCallHttpClient params; + memset(¶ms, 0, sizeof(params)); + + params.target = target; + params.method = OrthancPluginHttpMethod_Put; + params.url = url; + params.body = body; + params.bodySize = bodySize; + params.username = username; + params.password = password; + + return context->InvokeService(context, _OrthancPluginService_CallHttpClient, ¶ms); + } + + + /** + * @brief Issue a HTTP DELETE call. + * + * Make a HTTP DELETE call to the given URL. Favor + * OrthancPluginRestApiDelete() if calling the built-in REST API of + * the Orthanc instance that hosts this plugin. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param url The URL of interest. + * @param username The username (can be NULL if no password protection). + * @param password The password (can be NULL if no password protection). + * @return 0 if success, or the error code if failure. + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginHttpDelete( + OrthancPluginContext* context, + const char* url, + const char* username, + const char* password) + { + _OrthancPluginCallHttpClient params; + memset(¶ms, 0, sizeof(params)); + + params.method = OrthancPluginHttpMethod_Delete; + params.url = url; + params.username = username; + params.password = password; + + return context->InvokeService(context, _OrthancPluginService_CallHttpClient, ¶ms); + } + + + + typedef struct + { + OrthancPluginImage** target; + const OrthancPluginImage* source; + OrthancPluginPixelFormat targetFormat; + } _OrthancPluginConvertPixelFormat; + + + /** + * @brief Change the pixel format of an image. + * + * This function creates a new image, changing the memory layout of the pixels. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param source The source image. + * @param targetFormat The target pixel format. + * @return The resulting image. It must be freed with OrthancPluginFreeImage(). + * @ingroup Images + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginImage *OrthancPluginConvertPixelFormat( + OrthancPluginContext* context, + const OrthancPluginImage* source, + OrthancPluginPixelFormat targetFormat) + { + OrthancPluginImage* target = NULL; + + _OrthancPluginConvertPixelFormat params; + params.target = ⌖ + params.source = source; + params.targetFormat = targetFormat; + + if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, ¶ms) != OrthancPluginErrorCode_Success) + { + return NULL; + } + else + { + return target; + } + } + + + + /** + * @brief Return the number of available fonts. + * + * This function returns the number of fonts that are built in the + * Orthanc core. These fonts can be used to draw texts on images + * through OrthancPluginDrawText(). + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @return The number of fonts. + * @ingroup Images + **/ + ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount( + OrthancPluginContext* context) + { + uint32_t count = 0; + + _OrthancPluginReturnSingleValue params; + memset(¶ms, 0, sizeof(params)); + params.resultUint32 = &count; + + if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return 0; + } + else + { + return count; + } + } + + + + + typedef struct + { + uint32_t fontIndex; /* in */ + const char** name; /* out */ + uint32_t* size; /* out */ + } _OrthancPluginGetFontInfo; + + /** + * @brief Return the name of a font. + * + * This function returns the name of a font that is built in the Orthanc core. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param fontIndex The index of the font. This value must be less than OrthancPluginGetFontsCount(). + * @return The font name. This is a statically-allocated string, do not free it. + * @ingroup Images + **/ + ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName( + OrthancPluginContext* context, + uint32_t fontIndex) + { + const char* result = NULL; + + _OrthancPluginGetFontInfo params; + memset(¶ms, 0, sizeof(params)); + params.name = &result; + params.fontIndex = fontIndex; + + if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, ¶ms) != OrthancPluginErrorCode_Success) + { + return NULL; + } + else + { + return result; + } + } + + + /** + * @brief Return the size of a font. + * + * This function returns the size of a font that is built in the Orthanc core. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param fontIndex The index of the font. This value must be less than OrthancPluginGetFontsCount(). + * @return The font size. + * @ingroup Images + **/ + ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize( + OrthancPluginContext* context, + uint32_t fontIndex) + { + uint32_t result; + + _OrthancPluginGetFontInfo params; + memset(¶ms, 0, sizeof(params)); + params.size = &result; + params.fontIndex = fontIndex; + + if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, ¶ms) != OrthancPluginErrorCode_Success) + { + return 0; + } + else + { + return result; + } + } + + + + typedef struct + { + OrthancPluginImage* image; + uint32_t fontIndex; + const char* utf8Text; + int32_t x; + int32_t y; + uint8_t r; + uint8_t g; + uint8_t b; + } _OrthancPluginDrawText; + + + /** + * @brief Draw text on an image. + * + * This function draws some text on some image. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param image The image upon which to draw the text. + * @param fontIndex The index of the font. This value must be less than OrthancPluginGetFontsCount(). + * @param utf8Text The text to be drawn, encoded as an UTF-8 zero-terminated string. + * @param x The X position of the text over the image. + * @param y The Y position of the text over the image. + * @param r The value of the red color channel of the text. + * @param g The value of the green color channel of the text. + * @param b The value of the blue color channel of the text. + * @return 0 if success, other value if error. + * @ingroup Images + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginDrawText( + OrthancPluginContext* context, + OrthancPluginImage* image, + uint32_t fontIndex, + const char* utf8Text, + int32_t x, + int32_t y, + uint8_t r, + uint8_t g, + uint8_t b) + { + _OrthancPluginDrawText params; + memset(¶ms, 0, sizeof(params)); + params.image = image; + params.fontIndex = fontIndex; + params.utf8Text = utf8Text; + params.x = x; + params.y = y; + params.r = r; + params.g = g; + params.b = b; + + return context->InvokeService(context, _OrthancPluginService_DrawText, ¶ms); + } + + + + typedef struct + { + OrthancPluginStorageArea* storageArea; + const char* uuid; + const void* content; + uint64_t size; + OrthancPluginContentType type; + } _OrthancPluginStorageAreaCreate; + + + /** + * @brief Create a file inside the storage area. + * + * This function creates a new file inside the storage area that is + * currently used by Orthanc. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param storageArea The storage area. + * @param uuid The identifier of the file to be created. + * @param content The content to store in the newly created file. + * @param size The size of the content. + * @param type The type of the file content. + * @return 0 if success, other value if error. + * @ingroup Callbacks + * @deprecated This function should not be used anymore. Use "OrthancPluginRestApiPut()" on + * "/{patients|studies|series|instances}/{id}/attachments/{name}" instead. + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginStorageAreaCreate( + OrthancPluginContext* context, + OrthancPluginStorageArea* storageArea, + const char* uuid, + const void* content, + uint64_t size, + OrthancPluginContentType type) + { + _OrthancPluginStorageAreaCreate params; + params.storageArea = storageArea; + params.uuid = uuid; + params.content = content; + params.size = size; + params.type = type; + + return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, ¶ms); + } + + + typedef struct + { + OrthancPluginMemoryBuffer* target; + OrthancPluginStorageArea* storageArea; + const char* uuid; + OrthancPluginContentType type; + } _OrthancPluginStorageAreaRead; + + + /** + * @brief Read a file from the storage area. + * + * This function reads the content of a given file from the storage + * area that is currently used by Orthanc. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer(). + * @param storageArea The storage area. + * @param uuid The identifier of the file to be read. + * @param type The type of the file content. + * @return 0 if success, other value if error. + * @ingroup Callbacks + * @deprecated This function should not be used anymore. Use "OrthancPluginRestApiGet()" on + * "/{patients|studies|series|instances}/{id}/attachments/{name}" instead. + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginStorageAreaRead( + OrthancPluginContext* context, + OrthancPluginMemoryBuffer* target, + OrthancPluginStorageArea* storageArea, + const char* uuid, + OrthancPluginContentType type) + { + _OrthancPluginStorageAreaRead params; + params.target = target; + params.storageArea = storageArea; + params.uuid = uuid; + params.type = type; + + return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, ¶ms); + } + + + typedef struct + { + OrthancPluginStorageArea* storageArea; + const char* uuid; + OrthancPluginContentType type; + } _OrthancPluginStorageAreaRemove; + + /** + * @brief Remove a file from the storage area. + * + * This function removes a given file from the storage area that is + * currently used by Orthanc. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param storageArea The storage area. + * @param uuid The identifier of the file to be removed. + * @param type The type of the file content. + * @return 0 if success, other value if error. + * @ingroup Callbacks + * @deprecated This function should not be used anymore. Use "OrthancPluginRestApiDelete()" on + * "/{patients|studies|series|instances}/{id}/attachments/{name}" instead. + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginStorageAreaRemove( + OrthancPluginContext* context, + OrthancPluginStorageArea* storageArea, + const char* uuid, + OrthancPluginContentType type) + { + _OrthancPluginStorageAreaRemove params; + params.storageArea = storageArea; + params.uuid = uuid; + params.type = type; + + return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, ¶ms); + } + + + + typedef struct + { + OrthancPluginErrorCode* target; + int32_t code; + uint16_t httpStatus; + const char* message; + } _OrthancPluginRegisterErrorCode; + + /** + * @brief Declare a custom error code for this plugin. + * + * This function declares a custom error code that can be generated + * by this plugin. This declaration is used to enrich the body of + * the HTTP answer in the case of an error, and to set the proper + * HTTP status code. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param code The error code that is internal to this plugin. + * @param httpStatus The HTTP status corresponding to this error. + * @param message The description of the error. + * @return The error code that has been assigned inside the Orthanc core. + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRegisterErrorCode( + OrthancPluginContext* context, + int32_t code, + uint16_t httpStatus, + const char* message) + { + OrthancPluginErrorCode target; + + _OrthancPluginRegisterErrorCode params; + params.target = ⌖ + params.code = code; + params.httpStatus = httpStatus; + params.message = message; + + if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, ¶ms) == OrthancPluginErrorCode_Success) + { + return target; + } + else + { + /* There was an error while assigned the error. Use a generic code. */ + return OrthancPluginErrorCode_Plugin; + } + } + + + + typedef struct + { + uint16_t group; + uint16_t element; + OrthancPluginValueRepresentation vr; + const char* name; + uint32_t minMultiplicity; + uint32_t maxMultiplicity; + } _OrthancPluginRegisterDictionaryTag; + + /** + * @brief Register a new tag into the DICOM dictionary. + * + * This function declares a new public tag in the dictionary of + * DICOM tags that are known to Orthanc. This function should be + * used in the OrthancPluginInitialize() callback. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param group The group of the tag. + * @param element The element of the tag. + * @param vr The value representation of the tag. + * @param name The nickname of the tag. + * @param minMultiplicity The minimum multiplicity of the tag (must be above 0). + * @param maxMultiplicity The maximum multiplicity of the tag. A value of 0 means + * an arbitrary multiplicity ("n"). + * @return 0 if success, other value if error. + * @see OrthancPluginRegisterPrivateDictionaryTag() + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRegisterDictionaryTag( + OrthancPluginContext* context, + uint16_t group, + uint16_t element, + OrthancPluginValueRepresentation vr, + const char* name, + uint32_t minMultiplicity, + uint32_t maxMultiplicity) + { + _OrthancPluginRegisterDictionaryTag params; + params.group = group; + params.element = element; + params.vr = vr; + params.name = name; + params.minMultiplicity = minMultiplicity; + params.maxMultiplicity = maxMultiplicity; + + return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, ¶ms); + } + + + + typedef struct + { + uint16_t group; + uint16_t element; + OrthancPluginValueRepresentation vr; + const char* name; + uint32_t minMultiplicity; + uint32_t maxMultiplicity; + const char* privateCreator; + } _OrthancPluginRegisterPrivateDictionaryTag; + + /** + * @brief Register a new private tag into the DICOM dictionary. + * + * This function declares a new private tag in the dictionary of + * DICOM tags that are known to Orthanc. This function should be + * used in the OrthancPluginInitialize() callback. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param group The group of the tag. + * @param element The element of the tag. + * @param vr The value representation of the tag. + * @param name The nickname of the tag. + * @param minMultiplicity The minimum multiplicity of the tag (must be above 0). + * @param maxMultiplicity The maximum multiplicity of the tag. A value of 0 means + * an arbitrary multiplicity ("n"). + * @param privateCreator The private creator of this private tag. + * @return 0 if success, other value if error. + * @see OrthancPluginRegisterDictionaryTag() + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRegisterPrivateDictionaryTag( + OrthancPluginContext* context, + uint16_t group, + uint16_t element, + OrthancPluginValueRepresentation vr, + const char* name, + uint32_t minMultiplicity, + uint32_t maxMultiplicity, + const char* privateCreator) + { + _OrthancPluginRegisterPrivateDictionaryTag params; + params.group = group; + params.element = element; + params.vr = vr; + params.name = name; + params.minMultiplicity = minMultiplicity; + params.maxMultiplicity = maxMultiplicity; + params.privateCreator = privateCreator; + + return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, ¶ms); + } + + + + typedef struct + { + OrthancPluginStorageArea* storageArea; + OrthancPluginResourceType level; + } _OrthancPluginReconstructMainDicomTags; + + /** + * @brief Reconstruct the main DICOM tags. + * + * This function requests the Orthanc core to reconstruct the main + * DICOM tags of all the resources of the given type. This function + * can only be used as a part of the upgrade of a custom database + * back-end. A database transaction will be automatically setup. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param storageArea The storage area. + * @param level The type of the resources of interest. + * @return 0 if success, other value if error. + * @ingroup Callbacks + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags( + OrthancPluginContext* context, + OrthancPluginStorageArea* storageArea, + OrthancPluginResourceType level) + { + _OrthancPluginReconstructMainDicomTags params; + params.level = level; + params.storageArea = storageArea; + + return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, ¶ms); + } + + + typedef struct + { + char** result; + const char* instanceId; + const void* buffer; + uint32_t size; + OrthancPluginDicomToJsonFormat format; + OrthancPluginDicomToJsonFlags flags; + uint32_t maxStringLength; + } _OrthancPluginDicomToJson; + + + /** + * @brief Format a DICOM memory buffer as a JSON string. + * + * This function takes as input a memory buffer containing a DICOM + * file, and outputs a JSON string representing the tags of this + * DICOM file. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param buffer The memory buffer containing the DICOM file. + * @param size The size of the memory buffer. + * @param format The output format. + * @param flags Flags governing the output. + * @param maxStringLength The maximum length of a field. Too long fields will + * be output as "null". The 0 value means no maximum length. + * @return The NULL value if the case of an error, or the JSON + * string. This string must be freed by OrthancPluginFreeString(). + * @ingroup Toolbox + * @see OrthancPluginDicomInstanceToJson + **/ + ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson( + OrthancPluginContext* context, + const void* buffer, + uint32_t size, + OrthancPluginDicomToJsonFormat format, + OrthancPluginDicomToJsonFlags flags, + uint32_t maxStringLength) + { + char* result; + + _OrthancPluginDicomToJson params; + memset(¶ms, 0, sizeof(params)); + params.result = &result; + params.buffer = buffer; + params.size = size; + params.format = format; + params.flags = flags; + params.maxStringLength = maxStringLength; + + if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + + /** + * @brief Format a DICOM instance as a JSON string. + * + * This function formats a DICOM instance that is stored in Orthanc, + * and outputs a JSON string representing the tags of this DICOM + * instance. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param instanceId The Orthanc identifier of the instance. + * @param format The output format. + * @param flags Flags governing the output. + * @param maxStringLength The maximum length of a field. Too long fields will + * be output as "null". The 0 value means no maximum length. + * @return The NULL value if the case of an error, or the JSON + * string. This string must be freed by OrthancPluginFreeString(). + * @ingroup Toolbox + * @see OrthancPluginDicomInstanceToJson + **/ + ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson( + OrthancPluginContext* context, + const char* instanceId, + OrthancPluginDicomToJsonFormat format, + OrthancPluginDicomToJsonFlags flags, + uint32_t maxStringLength) + { + char* result; + + _OrthancPluginDicomToJson params; + memset(¶ms, 0, sizeof(params)); + params.result = &result; + params.instanceId = instanceId; + params.format = format; + params.flags = flags; + params.maxStringLength = maxStringLength; + + if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + + typedef struct + { + OrthancPluginMemoryBuffer* target; + const char* uri; + uint32_t headersCount; + const char* const* headersKeys; + const char* const* headersValues; + int32_t afterPlugins; + } _OrthancPluginRestApiGet2; + + /** + * @brief Make a GET call to the Orthanc REST API, with custom HTTP headers. + * + * Make a GET call to the Orthanc REST API with extended + * parameters. The result to the query is stored into a newly + * allocated memory buffer. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer(). + * @param uri The URI in the built-in Orthanc API. + * @param headersCount The number of HTTP headers. + * @param headersKeys Array containing the keys of the HTTP headers (can be NULL if no header). + * @param headersValues Array containing the values of the HTTP headers (can be NULL if no header). + * @param afterPlugins If 0, the built-in API of Orthanc is used. + * If 1, the API is tainted by the plugins. + * @return 0 if success, or the error code if failure. + * @see OrthancPluginRestApiGet, OrthancPluginRestApiGetAfterPlugins + * @ingroup Orthanc + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRestApiGet2( + OrthancPluginContext* context, + OrthancPluginMemoryBuffer* target, + const char* uri, + uint32_t headersCount, + const char* const* headersKeys, + const char* const* headersValues, + int32_t afterPlugins) + { + _OrthancPluginRestApiGet2 params; + params.target = target; + params.uri = uri; + params.headersCount = headersCount; + params.headersKeys = headersKeys; + params.headersValues = headersValues; + params.afterPlugins = afterPlugins; + + return context->InvokeService(context, _OrthancPluginService_RestApiGet2, ¶ms); + } + + + + typedef struct + { + OrthancPluginWorklistCallback callback; + } _OrthancPluginWorklistCallback; + + /** + * @brief Register a callback to handle modality worklists requests. + * + * This function registers a callback to handle C-Find SCP requests + * on modality worklists. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param callback The callback. + * @return 0 if success, other value if error. + * @ingroup DicomCallbacks + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback( + OrthancPluginContext* context, + OrthancPluginWorklistCallback callback) + { + _OrthancPluginWorklistCallback params; + params.callback = callback; + + return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, ¶ms); + } + + + + typedef struct + { + OrthancPluginWorklistAnswers* answers; + const OrthancPluginWorklistQuery* query; + const void* dicom; + uint32_t size; + } _OrthancPluginWorklistAnswersOperation; + + /** + * @brief Add one answer to some modality worklist request. + * + * This function adds one worklist (encoded as a DICOM file) to the + * set of answers corresponding to some C-Find SCP request against + * modality worklists. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param answers The set of answers. + * @param query The worklist query, as received by the callback. + * @param dicom The worklist to answer, encoded as a DICOM file. + * @param size The size of the DICOM file. + * @return 0 if success, other value if error. + * @ingroup DicomCallbacks + * @see OrthancPluginCreateDicom() + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginWorklistAddAnswer( + OrthancPluginContext* context, + OrthancPluginWorklistAnswers* answers, + const OrthancPluginWorklistQuery* query, + const void* dicom, + uint32_t size) + { + _OrthancPluginWorklistAnswersOperation params; + params.answers = answers; + params.query = query; + params.dicom = dicom; + params.size = size; + + return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, ¶ms); + } + + + /** + * @brief Mark the set of worklist answers as incomplete. + * + * This function marks as incomplete the set of answers + * corresponding to some C-Find SCP request against modality + * worklists. This must be used if canceling the handling of a + * request when too many answers are to be returned. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param answers The set of answers. + * @return 0 if success, other value if error. + * @ingroup DicomCallbacks + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete( + OrthancPluginContext* context, + OrthancPluginWorklistAnswers* answers) + { + _OrthancPluginWorklistAnswersOperation params; + params.answers = answers; + params.query = NULL; + params.dicom = NULL; + params.size = 0; + + return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, ¶ms); + } + + + typedef struct + { + const OrthancPluginWorklistQuery* query; + const void* dicom; + uint32_t size; + int32_t* isMatch; + OrthancPluginMemoryBuffer* target; + } _OrthancPluginWorklistQueryOperation; + + /** + * @brief Test whether a worklist matches the query. + * + * This function checks whether one worklist (encoded as a DICOM + * file) matches the C-Find SCP query against modality + * worklists. This function must be called before adding the + * worklist as an answer through OrthancPluginWorklistAddAnswer(). + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param query The worklist query, as received by the callback. + * @param dicom The worklist to answer, encoded as a DICOM file. + * @param size The size of the DICOM file. + * @return 1 if the worklist matches the query, 0 otherwise. + * @ingroup DicomCallbacks + **/ + ORTHANC_PLUGIN_INLINE int32_t OrthancPluginWorklistIsMatch( + OrthancPluginContext* context, + const OrthancPluginWorklistQuery* query, + const void* dicom, + uint32_t size) + { + int32_t isMatch = 0; + + _OrthancPluginWorklistQueryOperation params; + params.query = query; + params.dicom = dicom; + params.size = size; + params.isMatch = &isMatch; + params.target = NULL; + + if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, ¶ms) == OrthancPluginErrorCode_Success) + { + return isMatch; + } + else + { + /* Error: Assume non-match */ + return 0; + } + } + + + /** + * @brief Retrieve the worklist query as a DICOM file. + * + * This function retrieves the DICOM file that underlies a C-Find + * SCP query against modality worklists. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param target Memory buffer where to store the DICOM file. It must be freed with OrthancPluginFreeMemoryBuffer(). + * @param query The worklist query, as received by the callback. + * @return 0 if success, other value if error. + * @ingroup DicomCallbacks + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery( + OrthancPluginContext* context, + OrthancPluginMemoryBuffer* target, + const OrthancPluginWorklistQuery* query) + { + _OrthancPluginWorklistQueryOperation params; + params.query = query; + params.dicom = NULL; + params.size = 0; + params.isMatch = NULL; + params.target = target; + + return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, ¶ms); + } + + + /** + * @brief Get the origin of a DICOM file. + * + * This function returns the origin of a DICOM instance that has been received by Orthanc. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param instance The instance of interest. + * @return The origin of the instance. + * @ingroup DicomInstance + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin( + OrthancPluginContext* context, + const OrthancPluginDicomInstance* instance) + { + OrthancPluginInstanceOrigin origin; + + _OrthancPluginAccessDicomInstance params; + memset(¶ms, 0, sizeof(params)); + params.resultOrigin = &origin; + params.instance = instance; + + if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return OrthancPluginInstanceOrigin_Unknown; + } + else + { + return origin; + } + } + + + typedef struct + { + OrthancPluginMemoryBuffer* target; + const char* json; + const OrthancPluginImage* pixelData; + OrthancPluginCreateDicomFlags flags; + } _OrthancPluginCreateDicom; + + /** + * @brief Create a DICOM instance from a JSON string and an image. + * + * This function takes as input a string containing a JSON file + * describing the content of a DICOM instance. As an output, it + * writes the corresponding DICOM instance to a newly allocated + * memory buffer. Additionally, an image to be encoded within the + * DICOM instance can also be provided. + * + * Private tags will be associated with the private creator whose + * value is specified in the "DefaultPrivateCreator" configuration + * option of Orthanc. The function OrthancPluginCreateDicom2() can + * be used if another private creator must be used to create this + * instance. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer(). + * @param json The input JSON file. + * @param pixelData The image. Can be NULL, if the pixel data is encoded inside the JSON with the data URI scheme. + * @param flags Flags governing the output. + * @return 0 if success, other value if error. + * @ingroup Toolbox + * @see OrthancPluginCreateDicom2 + * @see OrthancPluginDicomBufferToJson + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginCreateDicom( + OrthancPluginContext* context, + OrthancPluginMemoryBuffer* target, + const char* json, + const OrthancPluginImage* pixelData, + OrthancPluginCreateDicomFlags flags) + { + _OrthancPluginCreateDicom params; + params.target = target; + params.json = json; + params.pixelData = pixelData; + params.flags = flags; + + return context->InvokeService(context, _OrthancPluginService_CreateDicom, ¶ms); + } + + + typedef struct + { + OrthancPluginDecodeImageCallback callback; + } _OrthancPluginDecodeImageCallback; + + /** + * @brief Register a callback to handle the decoding of DICOM images. + * + * This function registers a custom callback to decode DICOM images, + * extending the built-in decoder of Orthanc that uses + * DCMTK. Starting with Orthanc 1.7.0, the exact behavior is + * affected by the configuration option + * "BuiltinDecoderTranscoderOrder" of Orthanc. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param callback The callback. + * @return 0 if success, other value if error. + * @ingroup Callbacks + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback( + OrthancPluginContext* context, + OrthancPluginDecodeImageCallback callback) + { + _OrthancPluginDecodeImageCallback params; + params.callback = callback; + + return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, ¶ms); + } + + + + typedef struct + { + OrthancPluginImage** target; + OrthancPluginPixelFormat format; + uint32_t width; + uint32_t height; + uint32_t pitch; + void* buffer; + const void* constBuffer; + uint32_t bufferSize; + uint32_t frameIndex; + } _OrthancPluginCreateImage; + + + /** + * @brief Create an image. + * + * This function creates an image of given size and format. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param format The format of the pixels. + * @param width The width of the image. + * @param height The height of the image. + * @return The newly allocated image. It must be freed with OrthancPluginFreeImage(). + * @ingroup Images + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginImage* OrthancPluginCreateImage( + OrthancPluginContext* context, + OrthancPluginPixelFormat format, + uint32_t width, + uint32_t height) + { + OrthancPluginImage* target = NULL; + + _OrthancPluginCreateImage params; + memset(¶ms, 0, sizeof(params)); + params.target = ⌖ + params.format = format; + params.width = width; + params.height = height; + + if (context->InvokeService(context, _OrthancPluginService_CreateImage, ¶ms) != OrthancPluginErrorCode_Success) + { + return NULL; + } + else + { + return target; + } + } + + + /** + * @brief Create an image pointing to a memory buffer. + * + * This function creates an image whose content points to a memory + * buffer managed by the plugin. Note that the buffer is directly + * accessed, no memory is allocated and no data is copied. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param format The format of the pixels. + * @param width The width of the image. + * @param height The height of the image. + * @param pitch The pitch of the image (i.e. the number of bytes + * between 2 successive lines of the image in the memory buffer). + * @param buffer The memory buffer. + * @return The newly allocated image. It must be freed with OrthancPluginFreeImage(). + * @ingroup Images + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginImage* OrthancPluginCreateImageAccessor( + OrthancPluginContext* context, + OrthancPluginPixelFormat format, + uint32_t width, + uint32_t height, + uint32_t pitch, + void* buffer) + { + OrthancPluginImage* target = NULL; + + _OrthancPluginCreateImage params; + memset(¶ms, 0, sizeof(params)); + params.target = ⌖ + params.format = format; + params.width = width; + params.height = height; + params.pitch = pitch; + params.buffer = buffer; + + if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, ¶ms) != OrthancPluginErrorCode_Success) + { + return NULL; + } + else + { + return target; + } + } + + + + /** + * @brief Decode one frame from a DICOM instance. + * + * This function decodes one frame of a DICOM image that is stored + * in a memory buffer. This function will give the same result as + * OrthancPluginUncompressImage() for single-frame DICOM images. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param buffer Pointer to a memory buffer containing the DICOM image. + * @param bufferSize Size of the memory buffer containing the DICOM image. + * @param frameIndex The index of the frame of interest in a multi-frame image. + * @return The uncompressed image. It must be freed with OrthancPluginFreeImage(). + * @ingroup Images + * @see OrthancPluginGetInstanceDecodedFrame() + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginImage* OrthancPluginDecodeDicomImage( + OrthancPluginContext* context, + const void* buffer, + uint32_t bufferSize, + uint32_t frameIndex) + { + OrthancPluginImage* target = NULL; + + _OrthancPluginCreateImage params; + memset(¶ms, 0, sizeof(params)); + params.target = ⌖ + params.constBuffer = buffer; + params.bufferSize = bufferSize; + params.frameIndex = frameIndex; + + if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, ¶ms) != OrthancPluginErrorCode_Success) + { + return NULL; + } + else + { + return target; + } + } + + + + typedef struct + { + char** result; + const void* buffer; + uint32_t size; + } _OrthancPluginComputeHash; + + /** + * @brief Compute an MD5 hash. + * + * This functions computes the MD5 cryptographic hash of the given memory buffer. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param buffer The source memory buffer. + * @param size The size in bytes of the source buffer. + * @return The NULL value in case of error, or a string containing the cryptographic hash. + * This string must be freed by OrthancPluginFreeString(). + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5( + OrthancPluginContext* context, + const void* buffer, + uint32_t size) + { + char* result; + + _OrthancPluginComputeHash params; + params.result = &result; + params.buffer = buffer; + params.size = size; + + if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + + /** + * @brief Compute a SHA-1 hash. + * + * This functions computes the SHA-1 cryptographic hash of the given memory buffer. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param buffer The source memory buffer. + * @param size The size in bytes of the source buffer. + * @return The NULL value in case of error, or a string containing the cryptographic hash. + * This string must be freed by OrthancPluginFreeString(). + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1( + OrthancPluginContext* context, + const void* buffer, + uint32_t size) + { + char* result; + + _OrthancPluginComputeHash params; + params.result = &result; + params.buffer = buffer; + params.size = size; + + if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + + + typedef struct + { + OrthancPluginDictionaryEntry* target; + const char* name; + } _OrthancPluginLookupDictionary; + + /** + * @brief Get information about the given DICOM tag. + * + * This functions makes a lookup in the dictionary of DICOM tags + * that are known to Orthanc, and returns information about this + * tag. The tag can be specified using its human-readable name + * (e.g. "PatientName") or a set of two hexadecimal numbers + * (e.g. "0010-0020"). + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param target Where to store the information about the tag. + * @param name The name of the DICOM tag. + * @return 0 if success, other value if error. + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginLookupDictionary( + OrthancPluginContext* context, + OrthancPluginDictionaryEntry* target, + const char* name) + { + _OrthancPluginLookupDictionary params; + params.target = target; + params.name = name; + return context->InvokeService(context, _OrthancPluginService_LookupDictionary, ¶ms); + } + + + + typedef struct + { + OrthancPluginRestOutput* output; + const void* answer; + uint32_t answerSize; + uint32_t headersCount; + const char* const* headersKeys; + const char* const* headersValues; + } _OrthancPluginSendMultipartItem2; + + /** + * @brief Send an item as a part of some HTTP multipart answer, with custom headers. + * + * This function sends an item as a part of some HTTP multipart + * answer that was initiated by OrthancPluginStartMultipartAnswer(). In addition to + * OrthancPluginSendMultipartItem(), this function will set HTTP header associated + * with the item. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param output The HTTP connection to the client application. + * @param answer Pointer to the memory buffer containing the item. + * @param answerSize Number of bytes of the item. + * @param headersCount The number of HTTP headers. + * @param headersKeys Array containing the keys of the HTTP headers. + * @param headersValues Array containing the values of the HTTP headers. + * @return 0 if success, or the error code if failure (this notably happens + * if the connection is closed by the client). + * @see OrthancPluginSendMultipartItem() + * @ingroup REST + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginSendMultipartItem2( + OrthancPluginContext* context, + OrthancPluginRestOutput* output, + const void* answer, + uint32_t answerSize, + uint32_t headersCount, + const char* const* headersKeys, + const char* const* headersValues) + { + _OrthancPluginSendMultipartItem2 params; + params.output = output; + params.answer = answer; + params.answerSize = answerSize; + params.headersCount = headersCount; + params.headersKeys = headersKeys; + params.headersValues = headersValues; + + return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, ¶ms); + } + + + typedef struct + { + OrthancPluginIncomingHttpRequestFilter callback; + } _OrthancPluginIncomingHttpRequestFilter; + + /** + * @brief Register a callback to filter incoming HTTP requests. + * + * This function registers a custom callback to filter incoming HTTP/REST + * requests received by the HTTP server of Orthanc. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param callback The callback. + * @return 0 if success, other value if error. + * @ingroup Callbacks + * @deprecated Please instead use OrthancPluginRegisterIncomingHttpRequestFilter2() + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter( + OrthancPluginContext* context, + OrthancPluginIncomingHttpRequestFilter callback) + { + _OrthancPluginIncomingHttpRequestFilter params; + params.callback = callback; + + return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, ¶ms); + } + + + + typedef struct + { + OrthancPluginMemoryBuffer* answerBody; + OrthancPluginMemoryBuffer* answerHeaders; + uint16_t* httpStatus; + OrthancPluginHttpMethod method; + const char* url; + uint32_t headersCount; + const char* const* headersKeys; + const char* const* headersValues; + const void* body; + uint32_t bodySize; + const char* username; + const char* password; + uint32_t timeout; + const char* certificateFile; + const char* certificateKeyFile; + const char* certificateKeyPassword; + uint8_t pkcs11; + } _OrthancPluginCallHttpClient2; + + + + /** + * @brief Issue a HTTP call with full flexibility. + * + * Make a HTTP call to the given URL. The result to the query is + * stored into a newly allocated memory buffer. The HTTP request + * will be done accordingly to the global configuration of Orthanc + * (in particular, the options "HttpProxy", "HttpTimeout", + * "HttpsVerifyPeers", "HttpsCACertificates", and "Pkcs11" will be + * taken into account). + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param answerBody The target memory buffer (out argument). + * It must be freed with OrthancPluginFreeMemoryBuffer(). + * The value of this argument is ignored if the HTTP method is DELETE. + * @param answerHeaders The target memory buffer for the HTTP headers in the answers (out argument). + * The answer headers are formatted as a JSON object (associative array). + * The buffer must be freed with OrthancPluginFreeMemoryBuffer(). + * This argument can be set to NULL if the plugin has no interest in the HTTP headers. + * @param httpStatus The HTTP status after the execution of the request (out argument). + * @param method HTTP method to be used. + * @param url The URL of interest. + * @param headersCount The number of HTTP headers. + * @param headersKeys Array containing the keys of the HTTP headers (can be NULL if no header). + * @param headersValues Array containing the values of the HTTP headers (can be NULL if no header). + * @param username The username (can be NULL if no password protection). + * @param password The password (can be NULL if no password protection). + * @param body The HTTP body for a POST or PUT request. + * @param bodySize The size of the body. + * @param timeout Timeout in seconds (0 for default timeout). + * @param certificateFile Path to the client certificate for HTTPS, in PEM format + * (can be NULL if no client certificate or if not using HTTPS). + * @param certificateKeyFile Path to the key of the client certificate for HTTPS, in PEM format + * (can be NULL if no client certificate or if not using HTTPS). + * @param certificateKeyPassword Password to unlock the key of the client certificate + * (can be NULL if no client certificate or if not using HTTPS). + * @param pkcs11 Enable PKCS#11 client authentication for hardware security modules and smart cards. + * @return 0 if success, or the error code if failure. + * @see OrthancPluginCallPeerApi() + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginHttpClient( + OrthancPluginContext* context, + OrthancPluginMemoryBuffer* answerBody, + OrthancPluginMemoryBuffer* answerHeaders, + uint16_t* httpStatus, + OrthancPluginHttpMethod method, + const char* url, + uint32_t headersCount, + const char* const* headersKeys, + const char* const* headersValues, + const void* body, + uint32_t bodySize, + const char* username, + const char* password, + uint32_t timeout, + const char* certificateFile, + const char* certificateKeyFile, + const char* certificateKeyPassword, + uint8_t pkcs11) + { + _OrthancPluginCallHttpClient2 params; + memset(¶ms, 0, sizeof(params)); + + params.answerBody = answerBody; + params.answerHeaders = answerHeaders; + params.httpStatus = httpStatus; + params.method = method; + params.url = url; + params.headersCount = headersCount; + params.headersKeys = headersKeys; + params.headersValues = headersValues; + params.body = body; + params.bodySize = bodySize; + params.username = username; + params.password = password; + params.timeout = timeout; + params.certificateFile = certificateFile; + params.certificateKeyFile = certificateKeyFile; + params.certificateKeyPassword = certificateKeyPassword; + params.pkcs11 = pkcs11; + + return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, ¶ms); + } + + + /** + * @brief Generate an UUID. + * + * Generate a random GUID/UUID (globally unique identifier). + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @return NULL in the case of an error, or a newly allocated string + * containing the UUID. This string must be freed by OrthancPluginFreeString(). + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE char* OrthancPluginGenerateUuid( + OrthancPluginContext* context) + { + char* result; + + _OrthancPluginRetrieveDynamicString params; + params.result = &result; + params.argument = NULL; + + if (context->InvokeService(context, _OrthancPluginService_GenerateUuid, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + + + + typedef struct + { + OrthancPluginFindCallback callback; + } _OrthancPluginFindCallback; + + /** + * @brief Register a callback to handle C-Find requests. + * + * This function registers a callback to handle C-Find SCP requests + * that are not related to modality worklists. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param callback The callback. + * @return 0 if success, other value if error. + * @ingroup DicomCallbacks + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRegisterFindCallback( + OrthancPluginContext* context, + OrthancPluginFindCallback callback) + { + _OrthancPluginFindCallback params; + params.callback = callback; + + return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, ¶ms); + } + + + typedef struct + { + OrthancPluginFindAnswers *answers; + const OrthancPluginFindQuery *query; + const void *dicom; + uint32_t size; + uint32_t index; + uint32_t *resultUint32; + uint16_t *resultGroup; + uint16_t *resultElement; + char **resultString; + } _OrthancPluginFindOperation; + + /** + * @brief Add one answer to some C-Find request. + * + * This function adds one answer (encoded as a DICOM file) to the + * set of answers corresponding to some C-Find SCP request that is + * not related to modality worklists. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param answers The set of answers. + * @param dicom The answer to be added, encoded as a DICOM file. + * @param size The size of the DICOM file. + * @return 0 if success, other value if error. + * @ingroup DicomCallbacks + * @see OrthancPluginCreateDicom() + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginFindAddAnswer( + OrthancPluginContext* context, + OrthancPluginFindAnswers* answers, + const void* dicom, + uint32_t size) + { + _OrthancPluginFindOperation params; + memset(¶ms, 0, sizeof(params)); + params.answers = answers; + params.dicom = dicom; + params.size = size; + + return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, ¶ms); + } + + + /** + * @brief Mark the set of C-Find answers as incomplete. + * + * This function marks as incomplete the set of answers + * corresponding to some C-Find SCP request that is not related to + * modality worklists. This must be used if canceling the handling + * of a request when too many answers are to be returned. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param answers The set of answers. + * @return 0 if success, other value if error. + * @ingroup DicomCallbacks + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginFindMarkIncomplete( + OrthancPluginContext* context, + OrthancPluginFindAnswers* answers) + { + _OrthancPluginFindOperation params; + memset(¶ms, 0, sizeof(params)); + params.answers = answers; + + return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, ¶ms); + } + + + + /** + * @brief Get the number of tags in a C-Find query. + * + * This function returns the number of tags that are contained in + * the given C-Find query. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param query The C-Find query. + * @return The number of tags. + * @ingroup DicomCallbacks + **/ + ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFindQuerySize( + OrthancPluginContext* context, + const OrthancPluginFindQuery* query) + { + uint32_t count = 0; + + _OrthancPluginFindOperation params; + memset(¶ms, 0, sizeof(params)); + params.query = query; + params.resultUint32 = &count; + + if (context->InvokeService(context, _OrthancPluginService_GetFindQuerySize, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return 0; + } + else + { + return count; + } + } + + + /** + * @brief Get one tag in a C-Find query. + * + * This function returns the group and the element of one DICOM tag + * in the given C-Find query. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param group The group of the tag (output). + * @param element The element of the tag (output). + * @param query The C-Find query. + * @param index The index of the tag of interest. + * @return 0 if success, other value if error. + * @ingroup DicomCallbacks + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginGetFindQueryTag( + OrthancPluginContext* context, + uint16_t* group, + uint16_t* element, + const OrthancPluginFindQuery* query, + uint32_t index) + { + _OrthancPluginFindOperation params; + memset(¶ms, 0, sizeof(params)); + params.query = query; + params.index = index; + params.resultGroup = group; + params.resultElement = element; + + return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, ¶ms); + } + + + /** + * @brief Get the symbolic name of one tag in a C-Find query. + * + * This function returns the symbolic name of one DICOM tag in the + * given C-Find query. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param query The C-Find query. + * @param index The index of the tag of interest. + * @return The NULL value in case of error, or a string containing the name of the tag. + * @return 0 if success, other value if error. + * @ingroup DicomCallbacks + **/ + ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryTagName( + OrthancPluginContext* context, + const OrthancPluginFindQuery* query, + uint32_t index) + { + char* result; + + _OrthancPluginFindOperation params; + memset(¶ms, 0, sizeof(params)); + params.query = query; + params.index = index; + params.resultString = &result; + + if (context->InvokeService(context, _OrthancPluginService_GetFindQueryTagName, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + + /** + * @brief Get the value associated with one tag in a C-Find query. + * + * This function returns the value associated with one tag in the + * given C-Find query. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param query The C-Find query. + * @param index The index of the tag of interest. + * @return The NULL value in case of error, or a string containing the value of the tag. + * @return 0 if success, other value if error. + * @ingroup DicomCallbacks + **/ + ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryValue( + OrthancPluginContext* context, + const OrthancPluginFindQuery* query, + uint32_t index) + { + char* result; + + _OrthancPluginFindOperation params; + memset(¶ms, 0, sizeof(params)); + params.query = query; + params.index = index; + params.resultString = &result; + + if (context->InvokeService(context, _OrthancPluginService_GetFindQueryValue, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + + + + typedef struct + { + OrthancPluginMoveCallback callback; + OrthancPluginGetMoveSize getMoveSize; + OrthancPluginApplyMove applyMove; + OrthancPluginFreeMove freeMove; + } _OrthancPluginMoveCallback; + + /** + * @brief Register a callback to handle C-Move requests. + * + * This function registers a callback to handle C-Move SCP requests. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param callback The main callback. + * @param getMoveSize Callback to read the number of C-Move suboperations. + * @param applyMove Callback to apply one C-Move suboperation. + * @param freeMove Callback to free the C-Move driver. + * @return 0 if success, other value if error. + * @ingroup DicomCallbacks + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRegisterMoveCallback( + OrthancPluginContext* context, + OrthancPluginMoveCallback callback, + OrthancPluginGetMoveSize getMoveSize, + OrthancPluginApplyMove applyMove, + OrthancPluginFreeMove freeMove) + { + _OrthancPluginMoveCallback params; + params.callback = callback; + params.getMoveSize = getMoveSize; + params.applyMove = applyMove; + params.freeMove = freeMove; + + return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, ¶ms); + } + + + + typedef struct + { + OrthancPluginFindMatcher** target; + const void* query; + uint32_t size; + } _OrthancPluginCreateFindMatcher; + + + /** + * @brief Create a C-Find matcher. + * + * This function creates a "matcher" object that can be used to + * check whether a DICOM instance matches a C-Find query. The C-Find + * query must be expressed as a DICOM buffer. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param query The C-Find DICOM query. + * @param size The size of the DICOM query. + * @return The newly allocated matcher. It must be freed with OrthancPluginFreeFindMatcher(). + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginFindMatcher* OrthancPluginCreateFindMatcher( + OrthancPluginContext* context, + const void* query, + uint32_t size) + { + OrthancPluginFindMatcher* target = NULL; + + _OrthancPluginCreateFindMatcher params; + memset(¶ms, 0, sizeof(params)); + params.target = ⌖ + params.query = query; + params.size = size; + + if (context->InvokeService(context, _OrthancPluginService_CreateFindMatcher, ¶ms) != OrthancPluginErrorCode_Success) + { + return NULL; + } + else + { + return target; + } + } + + + typedef struct + { + OrthancPluginFindMatcher* matcher; + } _OrthancPluginFreeFindMatcher; + + /** + * @brief Free a C-Find matcher. + * + * This function frees a matcher that was created using OrthancPluginCreateFindMatcher(). + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param matcher The matcher of interest. + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginFreeFindMatcher( + OrthancPluginContext* context, + OrthancPluginFindMatcher* matcher) + { + _OrthancPluginFreeFindMatcher params; + params.matcher = matcher; + + context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, ¶ms); + } + + + typedef struct + { + const OrthancPluginFindMatcher* matcher; + const void* dicom; + uint32_t size; + int32_t* isMatch; + } _OrthancPluginFindMatcherIsMatch; + + /** + * @brief Test whether a DICOM instance matches a C-Find query. + * + * This function checks whether one DICOM instance matches C-Find + * matcher that was previously allocated using + * OrthancPluginCreateFindMatcher(). + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param matcher The matcher of interest. + * @param dicom The DICOM instance to be matched. + * @param size The size of the DICOM instance. + * @return 1 if the DICOM instance matches the query, 0 otherwise. + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE int32_t OrthancPluginFindMatcherIsMatch( + OrthancPluginContext* context, + const OrthancPluginFindMatcher* matcher, + const void* dicom, + uint32_t size) + { + int32_t isMatch = 0; + + _OrthancPluginFindMatcherIsMatch params; + params.matcher = matcher; + params.dicom = dicom; + params.size = size; + params.isMatch = &isMatch; + + if (context->InvokeService(context, _OrthancPluginService_FindMatcherIsMatch, ¶ms) == OrthancPluginErrorCode_Success) + { + return isMatch; + } + else + { + /* Error: Assume non-match */ + return 0; + } + } + + + typedef struct + { + OrthancPluginIncomingHttpRequestFilter2 callback; + } _OrthancPluginIncomingHttpRequestFilter2; + + /** + * @brief Register a callback to filter incoming HTTP requests. + * + * This function registers a custom callback to filter incoming HTTP/REST + * requests received by the HTTP server of Orthanc. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param callback The callback. + * @return 0 if success, other value if error. + * @ingroup Callbacks + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter2( + OrthancPluginContext* context, + OrthancPluginIncomingHttpRequestFilter2 callback) + { + _OrthancPluginIncomingHttpRequestFilter2 params; + params.callback = callback; + + return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, ¶ms); + } + + + + typedef struct + { + OrthancPluginPeers** peers; + } _OrthancPluginGetPeers; + + /** + * @brief Return the list of available Orthanc peers. + * + * This function returns the parameters of the Orthanc peers that are known to + * the Orthanc server hosting the plugin. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @return NULL if error, or a newly allocated opaque data structure containing the peers. + * This structure must be freed with OrthancPluginFreePeers(). + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginPeers* OrthancPluginGetPeers( + OrthancPluginContext* context) + { + OrthancPluginPeers* peers = NULL; + + _OrthancPluginGetPeers params; + memset(¶ms, 0, sizeof(params)); + params.peers = &peers; + + if (context->InvokeService(context, _OrthancPluginService_GetPeers, ¶ms) != OrthancPluginErrorCode_Success) + { + return NULL; + } + else + { + return peers; + } + } + + + typedef struct + { + OrthancPluginPeers* peers; + } _OrthancPluginFreePeers; + + /** + * @brief Free the list of available Orthanc peers. + * + * This function frees the data structure returned by OrthancPluginGetPeers(). + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param peers The data structure describing the Orthanc peers. + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginFreePeers( + OrthancPluginContext* context, + OrthancPluginPeers* peers) + { + _OrthancPluginFreePeers params; + params.peers = peers; + + context->InvokeService(context, _OrthancPluginService_FreePeers, ¶ms); + } + + + typedef struct + { + uint32_t* target; + const OrthancPluginPeers* peers; + } _OrthancPluginGetPeersCount; + + /** + * @brief Get the number of Orthanc peers. + * + * This function returns the number of Orthanc peers. + * + * This function is thread-safe: Several threads sharing the same + * OrthancPluginPeers object can simultaneously call this function. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param peers The data structure describing the Orthanc peers. + * @result The number of peers. + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetPeersCount( + OrthancPluginContext* context, + const OrthancPluginPeers* peers) + { + uint32_t target = 0; + + _OrthancPluginGetPeersCount params; + memset(¶ms, 0, sizeof(params)); + params.target = ⌖ + params.peers = peers; + + if (context->InvokeService(context, _OrthancPluginService_GetPeersCount, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return 0; + } + else + { + return target; + } + } + + + typedef struct + { + const char** target; + const OrthancPluginPeers* peers; + uint32_t peerIndex; + const char* userProperty; + } _OrthancPluginGetPeerProperty; + + /** + * @brief Get the symbolic name of an Orthanc peer. + * + * This function returns the symbolic name of the Orthanc peer, + * which corresponds to the key of the "OrthancPeers" configuration + * option of Orthanc. + * + * This function is thread-safe: Several threads sharing the same + * OrthancPluginPeers object can simultaneously call this function. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param peers The data structure describing the Orthanc peers. + * @param peerIndex The index of the peer of interest. + * This value must be lower than OrthancPluginGetPeersCount(). + * @result The symbolic name, or NULL in the case of an error. + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerName( + OrthancPluginContext* context, + const OrthancPluginPeers* peers, + uint32_t peerIndex) + { + const char* target = NULL; + + _OrthancPluginGetPeerProperty params; + memset(¶ms, 0, sizeof(params)); + params.target = ⌖ + params.peers = peers; + params.peerIndex = peerIndex; + params.userProperty = NULL; + + if (context->InvokeService(context, _OrthancPluginService_GetPeerName, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return target; + } + } + + + /** + * @brief Get the base URL of an Orthanc peer. + * + * This function returns the base URL to the REST API of some Orthanc peer. + * + * This function is thread-safe: Several threads sharing the same + * OrthancPluginPeers object can simultaneously call this function. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param peers The data structure describing the Orthanc peers. + * @param peerIndex The index of the peer of interest. + * This value must be lower than OrthancPluginGetPeersCount(). + * @result The URL, or NULL in the case of an error. + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUrl( + OrthancPluginContext* context, + const OrthancPluginPeers* peers, + uint32_t peerIndex) + { + const char* target = NULL; + + _OrthancPluginGetPeerProperty params; + memset(¶ms, 0, sizeof(params)); + params.target = ⌖ + params.peers = peers; + params.peerIndex = peerIndex; + params.userProperty = NULL; + + if (context->InvokeService(context, _OrthancPluginService_GetPeerUrl, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return target; + } + } + + + + /** + * @brief Get some user-defined property of an Orthanc peer. + * + * This function returns some user-defined property of some Orthanc + * peer. An user-defined property is a property that is associated + * with the peer in the Orthanc configuration file, but that is not + * recognized by the Orthanc core. + * + * This function is thread-safe: Several threads sharing the same + * OrthancPluginPeers object can simultaneously call this function. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param peers The data structure describing the Orthanc peers. + * @param peerIndex The index of the peer of interest. + * This value must be lower than OrthancPluginGetPeersCount(). + * @param userProperty The user property of interest. + * @result The value of the user property, or NULL if it is not defined. + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUserProperty( + OrthancPluginContext* context, + const OrthancPluginPeers* peers, + uint32_t peerIndex, + const char* userProperty) + { + const char* target = NULL; + + _OrthancPluginGetPeerProperty params; + memset(¶ms, 0, sizeof(params)); + params.target = ⌖ + params.peers = peers; + params.peerIndex = peerIndex; + params.userProperty = userProperty; + + if (context->InvokeService(context, _OrthancPluginService_GetPeerUserProperty, ¶ms) != OrthancPluginErrorCode_Success) + { + /* No such user property */ + return NULL; + } + else + { + return target; + } + } + + + + typedef struct + { + OrthancPluginMemoryBuffer* answerBody; + OrthancPluginMemoryBuffer* answerHeaders; + uint16_t* httpStatus; + const OrthancPluginPeers* peers; + uint32_t peerIndex; + OrthancPluginHttpMethod method; + const char* uri; + uint32_t additionalHeadersCount; + const char* const* additionalHeadersKeys; + const char* const* additionalHeadersValues; + const void* body; + uint32_t bodySize; + uint32_t timeout; + } _OrthancPluginCallPeerApi; + + /** + * @brief Call the REST API of an Orthanc peer. + * + * Make a REST call to the given URI in the REST API of a remote + * Orthanc peer. The result to the query is stored into a newly + * allocated memory buffer. The HTTP request will be done according + * to the "OrthancPeers" configuration option of Orthanc. + * + * This function is thread-safe: Several threads sharing the same + * OrthancPluginPeers object can simultaneously call this function. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param answerBody The target memory buffer (out argument). + * It must be freed with OrthancPluginFreeMemoryBuffer(). + * The value of this argument is ignored if the HTTP method is DELETE. + * @param answerHeaders The target memory buffer for the HTTP headers in the answers (out argument). + * The answer headers are formatted as a JSON object (associative array). + * The buffer must be freed with OrthancPluginFreeMemoryBuffer(). + * This argument can be set to NULL if the plugin has no interest in the HTTP headers. + * @param httpStatus The HTTP status after the execution of the request (out argument). + * @param peers The data structure describing the Orthanc peers. + * @param peerIndex The index of the peer of interest. + * This value must be lower than OrthancPluginGetPeersCount(). + * @param method HTTP method to be used. + * @param uri The URI of interest in the REST API. + * @param additionalHeadersCount The number of HTTP headers to be added to the + * HTTP headers provided in the global configuration of Orthanc. + * @param additionalHeadersKeys Array containing the keys of the HTTP headers (can be NULL if no header). + * @param additionalHeadersValues Array containing the values of the HTTP headers (can be NULL if no header). + * @param body The HTTP body for a POST or PUT request. + * @param bodySize The size of the body. + * @param timeout Timeout in seconds (0 for default timeout). + * @return 0 if success, or the error code if failure. + * @see OrthancPluginHttpClient() + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginCallPeerApi( + OrthancPluginContext* context, + OrthancPluginMemoryBuffer* answerBody, + OrthancPluginMemoryBuffer* answerHeaders, + uint16_t* httpStatus, + const OrthancPluginPeers* peers, + uint32_t peerIndex, + OrthancPluginHttpMethod method, + const char* uri, + uint32_t additionalHeadersCount, + const char* const* additionalHeadersKeys, + const char* const* additionalHeadersValues, + const void* body, + uint32_t bodySize, + uint32_t timeout) + { + _OrthancPluginCallPeerApi params; + memset(¶ms, 0, sizeof(params)); + + params.answerBody = answerBody; + params.answerHeaders = answerHeaders; + params.httpStatus = httpStatus; + params.peers = peers; + params.peerIndex = peerIndex; + params.method = method; + params.uri = uri; + params.additionalHeadersCount = additionalHeadersCount; + params.additionalHeadersKeys = additionalHeadersKeys; + params.additionalHeadersValues = additionalHeadersValues; + params.body = body; + params.bodySize = bodySize; + params.timeout = timeout; + + return context->InvokeService(context, _OrthancPluginService_CallPeerApi, ¶ms); + } + + + + + + typedef struct + { + OrthancPluginJob** target; + void *job; + OrthancPluginJobFinalize finalize; + const char *type; + OrthancPluginJobGetProgress getProgress; + OrthancPluginJobGetContent getContent; + OrthancPluginJobGetSerialized getSerialized; + OrthancPluginJobStep step; + OrthancPluginJobStop stop; + OrthancPluginJobReset reset; + } _OrthancPluginCreateJob; + + /** + * @brief Create a custom job. + * + * This function creates a custom job to be run by the jobs engine + * of Orthanc. + * + * Orthanc starts one dedicated thread per custom job that is + * running. It is guaranteed that all the callbacks will only be + * called from this single dedicated thread, in mutual exclusion: As + * a consequence, it is *not* mandatory to protect the various + * callbacks by mutexes. + * + * The custom job can nonetheless launch its own processing threads + * on the first call to the "step()" callback, and stop them once + * the "stop()" callback is called. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param job The job to be executed. + * @param finalize The finalization callback. + * @param type The type of the job, provided to the job unserializer. + * See OrthancPluginRegisterJobsUnserializer(). + * @param getProgress The progress callback. + * @param getContent The content callback. + * @param getSerialized The serialization callback. + * @param step The callback to execute the individual steps of the job. + * @param stop The callback that is invoked once the job leaves the "running" state. + * @param reset The callback that is invoked if a stopped job is started again. + * @return The newly allocated job. It must be freed with OrthancPluginFreeJob(), + * as long as it is not submitted with OrthancPluginSubmitJob(). + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginJob *OrthancPluginCreateJob( + OrthancPluginContext *context, + void *job, + OrthancPluginJobFinalize finalize, + const char *type, + OrthancPluginJobGetProgress getProgress, + OrthancPluginJobGetContent getContent, + OrthancPluginJobGetSerialized getSerialized, + OrthancPluginJobStep step, + OrthancPluginJobStop stop, + OrthancPluginJobReset reset) + { + OrthancPluginJob* target = NULL; + + _OrthancPluginCreateJob params; + memset(¶ms, 0, sizeof(params)); + + params.target = ⌖ + params.job = job; + params.finalize = finalize; + params.type = type; + params.getProgress = getProgress; + params.getContent = getContent; + params.getSerialized = getSerialized; + params.step = step; + params.stop = stop; + params.reset = reset; + + if (context->InvokeService(context, _OrthancPluginService_CreateJob, ¶ms) != OrthancPluginErrorCode_Success || + target == NULL) + { + /* Error */ + return NULL; + } + else + { + return target; + } + } + + + typedef struct + { + OrthancPluginJob* job; + } _OrthancPluginFreeJob; + + /** + * @brief Free a custom job. + * + * This function frees an image that was created with OrthancPluginCreateJob(). + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param job The job. + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginFreeJob( + OrthancPluginContext* context, + OrthancPluginJob* job) + { + _OrthancPluginFreeJob params; + params.job = job; + + context->InvokeService(context, _OrthancPluginService_FreeJob, ¶ms); + } + + + + typedef struct + { + char** resultId; + OrthancPluginJob *job; + int priority; + } _OrthancPluginSubmitJob; + + /** + * @brief Submit a new job to the jobs engine of Orthanc. + * + * This function adds the given job to the pending jobs of + * Orthanc. Orthanc will take take of freeing it by invoking the + * finalization callback provided to OrthancPluginCreateJob(). + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param job The job, as received by OrthancPluginCreateJob(). + * @param priority The priority of the job. + * @return ID of the newly-submitted job. This string must be freed by OrthancPluginFreeString(). + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE char *OrthancPluginSubmitJob( + OrthancPluginContext *context, + OrthancPluginJob *job, + int priority) + { + char* resultId = NULL; + + _OrthancPluginSubmitJob params; + memset(¶ms, 0, sizeof(params)); + + params.resultId = &resultId; + params.job = job; + params.priority = priority; + + if (context->InvokeService(context, _OrthancPluginService_SubmitJob, ¶ms) != OrthancPluginErrorCode_Success || + resultId == NULL) + { + /* Error */ + return NULL; + } + else + { + return resultId; + } + } + + + + typedef struct + { + OrthancPluginJobsUnserializer unserializer; + } _OrthancPluginJobsUnserializer; + + /** + * @brief Register an unserializer for custom jobs. + * + * This function registers an unserializer that decodes custom jobs + * from a JSON string. This callback is invoked when the jobs engine + * of Orthanc is started (on Orthanc initialization), for each job + * that is stored in the Orthanc database. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param unserializer The job unserializer. + * @ingroup Callbacks + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterJobsUnserializer( + OrthancPluginContext* context, + OrthancPluginJobsUnserializer unserializer) + { + _OrthancPluginJobsUnserializer params; + params.unserializer = unserializer; + + context->InvokeService(context, _OrthancPluginService_RegisterJobsUnserializer, ¶ms); + } + + + + typedef struct + { + OrthancPluginRestOutput* output; + const char* details; + uint8_t log; + } _OrthancPluginSetHttpErrorDetails; + + /** + * @brief Provide a detailed description for an HTTP error. + * + * This function sets the detailed description associated with an + * HTTP error. This description will be displayed in the "Details" + * field of the JSON body of the HTTP answer. It is only taken into + * consideration if the REST callback returns an error code that is + * different from "OrthancPluginErrorCode_Success", and if the + * "HttpDescribeErrors" configuration option of Orthanc is set to + * "true". + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param output The HTTP connection to the client application. + * @param details The details of the error message. + * @param log Whether to also write the detailed error to the Orthanc logs. + * @ingroup REST + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpErrorDetails( + OrthancPluginContext* context, + OrthancPluginRestOutput* output, + const char* details, + uint8_t log) + { + _OrthancPluginSetHttpErrorDetails params; + params.output = output; + params.details = details; + params.log = log; + context->InvokeService(context, _OrthancPluginService_SetHttpErrorDetails, ¶ms); + } + + + + typedef struct + { + const char** result; + const char* argument; + } _OrthancPluginRetrieveStaticString; + + /** + * @brief Detect the MIME type of a file. + * + * This function returns the MIME type of a file by inspecting its extension. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param path Path to the file. + * @return The MIME type. This is a statically-allocated + * string, do not free it. + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE const char* OrthancPluginAutodetectMimeType( + OrthancPluginContext* context, + const char* path) + { + const char* result = NULL; + + _OrthancPluginRetrieveStaticString params; + params.result = &result; + params.argument = path; + + if (context->InvokeService(context, _OrthancPluginService_AutodetectMimeType, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + + + typedef struct + { + const char* name; + float value; + OrthancPluginMetricsType type; + } _OrthancPluginSetMetricsValue; + + /** + * @brief Set the value of a metrics. + * + * This function sets the value of a metrics to monitor the behavior + * of the plugin through tools such as Prometheus. The values of all + * the metrics are stored within the Orthanc context. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param name The name of the metrics to be set. + * @param value The value of the metrics. + * @param type The type of the metrics. This parameter is only taken into consideration + * the first time this metrics is set. + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginSetMetricsValue( + OrthancPluginContext* context, + const char* name, + float value, + OrthancPluginMetricsType type) + { + _OrthancPluginSetMetricsValue params; + params.name = name; + params.value = value; + params.type = type; + context->InvokeService(context, _OrthancPluginService_SetMetricsValue, ¶ms); + } + + + + typedef struct + { + OrthancPluginRefreshMetricsCallback callback; + } _OrthancPluginRegisterRefreshMetricsCallback; + + /** + * @brief Register a callback to refresh the metrics. + * + * This function registers a callback to refresh the metrics. The + * callback must make calls to OrthancPluginSetMetricsValue(). + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param callback The callback function to handle the refresh. + * @ingroup Callbacks + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRefreshMetricsCallback( + OrthancPluginContext* context, + OrthancPluginRefreshMetricsCallback callback) + { + _OrthancPluginRegisterRefreshMetricsCallback params; + params.callback = callback; + context->InvokeService(context, _OrthancPluginService_RegisterRefreshMetricsCallback, ¶ms); + } + + + + + typedef struct + { + char** target; + const void* dicom; + uint32_t dicomSize; + OrthancPluginDicomWebBinaryCallback callback; + } _OrthancPluginEncodeDicomWeb; + + /** + * @brief Convert a DICOM instance to DICOMweb JSON. + * + * This function converts a memory buffer containing a DICOM instance, + * into its DICOMweb JSON representation. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param dicom Pointer to the DICOM instance. + * @param dicomSize Size of the DICOM instance. + * @param callback Callback to set the value of the binary tags. + * @see OrthancPluginCreateDicom() + * @return The NULL value in case of error, or the JSON document. This string must + * be freed by OrthancPluginFreeString(). + * @deprecated OrthancPluginEncodeDicomWebJson2() + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson( + OrthancPluginContext* context, + const void* dicom, + uint32_t dicomSize, + OrthancPluginDicomWebBinaryCallback callback) + { + char* target = NULL; + + _OrthancPluginEncodeDicomWeb params; + params.target = ⌖ + params.dicom = dicom; + params.dicomSize = dicomSize; + params.callback = callback; + + if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return target; + } + } + + + /** + * @brief Convert a DICOM instance to DICOMweb XML. + * + * This function converts a memory buffer containing a DICOM instance, + * into its DICOMweb XML representation. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param dicom Pointer to the DICOM instance. + * @param dicomSize Size of the DICOM instance. + * @param callback Callback to set the value of the binary tags. + * @return The NULL value in case of error, or the XML document. This string must + * be freed by OrthancPluginFreeString(). + * @see OrthancPluginCreateDicom() + * @deprecated OrthancPluginEncodeDicomWebXml2() + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml( + OrthancPluginContext* context, + const void* dicom, + uint32_t dicomSize, + OrthancPluginDicomWebBinaryCallback callback) + { + char* target = NULL; + + _OrthancPluginEncodeDicomWeb params; + params.target = ⌖ + params.dicom = dicom; + params.dicomSize = dicomSize; + params.callback = callback; + + if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return target; + } + } + + + + typedef struct + { + char** target; + const void* dicom; + uint32_t dicomSize; + OrthancPluginDicomWebBinaryCallback2 callback; + void* payload; + } _OrthancPluginEncodeDicomWeb2; + + /** + * @brief Convert a DICOM instance to DICOMweb JSON. + * + * This function converts a memory buffer containing a DICOM instance, + * into its DICOMweb JSON representation. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param dicom Pointer to the DICOM instance. + * @param dicomSize Size of the DICOM instance. + * @param callback Callback to set the value of the binary tags. + * @param payload User payload. + * @return The NULL value in case of error, or the JSON document. This string must + * be freed by OrthancPluginFreeString(). + * @see OrthancPluginCreateDicom() + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson2( + OrthancPluginContext* context, + const void* dicom, + uint32_t dicomSize, + OrthancPluginDicomWebBinaryCallback2 callback, + void* payload) + { + char* target = NULL; + + _OrthancPluginEncodeDicomWeb2 params; + params.target = ⌖ + params.dicom = dicom; + params.dicomSize = dicomSize; + params.callback = callback; + params.payload = payload; + + if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson2, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return target; + } + } + + + /** + * @brief Convert a DICOM instance to DICOMweb XML. + * + * This function converts a memory buffer containing a DICOM instance, + * into its DICOMweb XML representation. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param dicom Pointer to the DICOM instance. + * @param dicomSize Size of the DICOM instance. + * @param callback Callback to set the value of the binary tags. + * @param payload User payload. + * @return The NULL value in case of error, or the XML document. This string must + * be freed by OrthancPluginFreeString(). + * @see OrthancPluginCreateDicom() + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml2( + OrthancPluginContext* context, + const void* dicom, + uint32_t dicomSize, + OrthancPluginDicomWebBinaryCallback2 callback, + void* payload) + { + char* target = NULL; + + _OrthancPluginEncodeDicomWeb2 params; + params.target = ⌖ + params.dicom = dicom; + params.dicomSize = dicomSize; + params.callback = callback; + params.payload = payload; + + if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml2, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return target; + } + } + + + + /** + * @brief Callback executed when a HTTP header is received during a chunked transfer. + * + * Signature of a callback function that is called by Orthanc acting + * as a HTTP client during a chunked HTTP transfer, as soon as it + * receives one HTTP header from the answer of the remote HTTP + * server. + * + * @see OrthancPluginChunkedHttpClient() + * @param answer The user payload, as provided by the calling plugin. + * @param key The key of the HTTP header. + * @param value The value of the HTTP header. + * @return 0 if success, or the error code if failure. + * @ingroup Toolbox + **/ + typedef OrthancPluginErrorCode (*OrthancPluginChunkedClientAnswerAddHeader) ( + void* answer, + const char* key, + const char* value); + + + /** + * @brief Callback executed when an answer chunk is received during a chunked transfer. + * + * Signature of a callback function that is called by Orthanc acting + * as a HTTP client during a chunked HTTP transfer, as soon as it + * receives one data chunk from the answer of the remote HTTP + * server. + * + * @see OrthancPluginChunkedHttpClient() + * @param answer The user payload, as provided by the calling plugin. + * @param data The content of the data chunk. + * @param size The size of the data chunk. + * @return 0 if success, or the error code if failure. + * @ingroup Toolbox + **/ + typedef OrthancPluginErrorCode (*OrthancPluginChunkedClientAnswerAddChunk) ( + void* answer, + const void* data, + uint32_t size); + + + /** + * @brief Callback to know whether the request body is entirely read during a chunked transfer + * + * Signature of a callback function that is called by Orthanc acting + * as a HTTP client during a chunked HTTP transfer, while reading + * the body of a POST or PUT request. The plugin must answer "1" as + * soon as the body is entirely read: The "request" data structure + * must act as an iterator. + * + * @see OrthancPluginChunkedHttpClient() + * @param request The user payload, as provided by the calling plugin. + * @return "1" if the body is over, or "0" if there is still data to be read. + * @ingroup Toolbox + **/ + typedef uint8_t (*OrthancPluginChunkedClientRequestIsDone) (void* request); + + + /** + * @brief Callback to advance in the request body during a chunked transfer + * + * Signature of a callback function that is called by Orthanc acting + * as a HTTP client during a chunked HTTP transfer, while reading + * the body of a POST or PUT request. This function asks the plugin + * to advance to the next chunk of data of the request body: The + * "request" data structure must act as an iterator. + * + * @see OrthancPluginChunkedHttpClient() + * @param request The user payload, as provided by the calling plugin. + * @return 0 if success, or the error code if failure. + * @ingroup Toolbox + **/ + typedef OrthancPluginErrorCode (*OrthancPluginChunkedClientRequestNext) (void* request); + + + /** + * @brief Callback to read the current chunk of the request body during a chunked transfer + * + * Signature of a callback function that is called by Orthanc acting + * as a HTTP client during a chunked HTTP transfer, while reading + * the body of a POST or PUT request. The plugin must provide the + * content of the current chunk of data of the request body. + * + * @see OrthancPluginChunkedHttpClient() + * @param request The user payload, as provided by the calling plugin. + * @return The content of the current request chunk. + * @ingroup Toolbox + **/ + typedef const void* (*OrthancPluginChunkedClientRequestGetChunkData) (void* request); + + + /** + * @brief Callback to read the size of the current request chunk during a chunked transfer + * + * Signature of a callback function that is called by Orthanc acting + * as a HTTP client during a chunked HTTP transfer, while reading + * the body of a POST or PUT request. The plugin must provide the + * size of the current chunk of data of the request body. + * + * @see OrthancPluginChunkedHttpClient() + * @param request The user payload, as provided by the calling plugin. + * @return The size of the current request chunk. + * @ingroup Toolbox + **/ + typedef uint32_t (*OrthancPluginChunkedClientRequestGetChunkSize) (void* request); + + + typedef struct + { + void* answer; + OrthancPluginChunkedClientAnswerAddChunk answerAddChunk; + OrthancPluginChunkedClientAnswerAddHeader answerAddHeader; + uint16_t* httpStatus; + OrthancPluginHttpMethod method; + const char* url; + uint32_t headersCount; + const char* const* headersKeys; + const char* const* headersValues; + void* request; + OrthancPluginChunkedClientRequestIsDone requestIsDone; + OrthancPluginChunkedClientRequestGetChunkData requestChunkData; + OrthancPluginChunkedClientRequestGetChunkSize requestChunkSize; + OrthancPluginChunkedClientRequestNext requestNext; + const char* username; + const char* password; + uint32_t timeout; + const char* certificateFile; + const char* certificateKeyFile; + const char* certificateKeyPassword; + uint8_t pkcs11; + } _OrthancPluginChunkedHttpClient; + + + /** + * @brief Issue a HTTP call, using chunked HTTP transfers. + * + * Make a HTTP call to the given URL using chunked HTTP + * transfers. The request body is provided as an iterator over data + * chunks. The answer is provided as a sequence of function calls + * with the individual HTTP headers and answer chunks. + * + * Contrarily to OrthancPluginHttpClient() that entirely stores the + * request body and the answer body in memory buffers, this function + * uses chunked HTTP transfers. This results in a lower memory + * consumption. Pay attention to the fact that Orthanc servers with + * version <= 1.5.6 do not support chunked transfers: You must use + * OrthancPluginHttpClient() if contacting such older servers. + * + * The HTTP request will be done accordingly to the global + * configuration of Orthanc (in particular, the options "HttpProxy", + * "HttpTimeout", "HttpsVerifyPeers", "HttpsCACertificates", and + * "Pkcs11" will be taken into account). + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param answer The user payload for the answer body. It will be provided to the callbacks for the answer. + * @param answerAddChunk Callback function to report a data chunk from the answer body. + * @param answerAddHeader Callback function to report an HTTP header sent by the remote server. + * @param httpStatus The HTTP status after the execution of the request (out argument). + * @param method HTTP method to be used. + * @param url The URL of interest. + * @param headersCount The number of HTTP headers. + * @param headersKeys Array containing the keys of the HTTP headers (can be NULL if no header). + * @param headersValues Array containing the values of the HTTP headers (can be NULL if no header). + * @param request The user payload containing the request body, and acting as an iterator. + * It will be provided to the callbacks for the request. + * @param requestIsDone Callback function to tell whether the request body is entirely read. + * @param requestChunkData Callback function to get the content of the current data chunk of the request body. + * @param requestChunkSize Callback function to get the size of the current data chunk of the request body. + * @param requestNext Callback function to advance to the next data chunk of the request body. + * @param username The username (can be NULL if no password protection). + * @param password The password (can be NULL if no password protection). + * @param timeout Timeout in seconds (0 for default timeout). + * @param certificateFile Path to the client certificate for HTTPS, in PEM format + * (can be NULL if no client certificate or if not using HTTPS). + * @param certificateKeyFile Path to the key of the client certificate for HTTPS, in PEM format + * (can be NULL if no client certificate or if not using HTTPS). + * @param certificateKeyPassword Password to unlock the key of the client certificate + * (can be NULL if no client certificate or if not using HTTPS). + * @param pkcs11 Enable PKCS#11 client authentication for hardware security modules and smart cards. + * @return 0 if success, or the error code if failure. + * @see OrthancPluginHttpClient() + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginChunkedHttpClient( + OrthancPluginContext* context, + void* answer, + OrthancPluginChunkedClientAnswerAddChunk answerAddChunk, + OrthancPluginChunkedClientAnswerAddHeader answerAddHeader, + uint16_t* httpStatus, + OrthancPluginHttpMethod method, + const char* url, + uint32_t headersCount, + const char* const* headersKeys, + const char* const* headersValues, + void* request, + OrthancPluginChunkedClientRequestIsDone requestIsDone, + OrthancPluginChunkedClientRequestGetChunkData requestChunkData, + OrthancPluginChunkedClientRequestGetChunkSize requestChunkSize, + OrthancPluginChunkedClientRequestNext requestNext, + const char* username, + const char* password, + uint32_t timeout, + const char* certificateFile, + const char* certificateKeyFile, + const char* certificateKeyPassword, + uint8_t pkcs11) + { + _OrthancPluginChunkedHttpClient params; + memset(¶ms, 0, sizeof(params)); + + /* In common with OrthancPluginHttpClient() */ + params.httpStatus = httpStatus; + params.method = method; + params.url = url; + params.headersCount = headersCount; + params.headersKeys = headersKeys; + params.headersValues = headersValues; + params.username = username; + params.password = password; + params.timeout = timeout; + params.certificateFile = certificateFile; + params.certificateKeyFile = certificateKeyFile; + params.certificateKeyPassword = certificateKeyPassword; + params.pkcs11 = pkcs11; + + /* For chunked body/answer */ + params.answer = answer; + params.answerAddChunk = answerAddChunk; + params.answerAddHeader = answerAddHeader; + params.request = request; + params.requestIsDone = requestIsDone; + params.requestChunkData = requestChunkData; + params.requestChunkSize = requestChunkSize; + params.requestNext = requestNext; + + return context->InvokeService(context, _OrthancPluginService_ChunkedHttpClient, ¶ms); + } + + + + /** + * @brief Opaque structure that reads the content of a HTTP request body during a chunked HTTP transfer. + * @ingroup Callbacks + **/ + typedef struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader; + + + + /** + * @brief Callback to create a reader to handle incoming chunked HTTP transfers. + * + * Signature of a callback function that is called by Orthanc acting + * as a HTTP server that supports chunked HTTP transfers. This + * callback is only invoked if the HTTP method is POST or PUT. The + * callback must create an user-specific "reader" object that will + * be fed with the body of the incoming body. + * + * @see OrthancPluginRegisterChunkedRestCallback() + * @param reader Memory location that must be filled with the newly-created reader. + * @param url The URI that is accessed. + * @param request The body of the HTTP request. Note that "body" and "bodySize" are not used. + * @return 0 if success, or the error code if failure. + **/ + typedef OrthancPluginErrorCode (*OrthancPluginServerChunkedRequestReaderFactory) ( + OrthancPluginServerChunkedRequestReader** reader, + const char* url, + const OrthancPluginHttpRequest* request); + + + /** + * @brief Callback invoked whenever a new data chunk is available during a chunked transfer. + * + * Signature of a callback function that is called by Orthanc acting + * as a HTTP server that supports chunked HTTP transfers. This callback + * is invoked as soon as a new data chunk is available for the request body. + * + * @see OrthancPluginRegisterChunkedRestCallback() + * @param reader The user payload, as created by the OrthancPluginServerChunkedRequestReaderFactory() callback. + * @param data The content of the data chunk. + * @param size The size of the data chunk. + * @return 0 if success, or the error code if failure. + **/ + typedef OrthancPluginErrorCode (*OrthancPluginServerChunkedRequestReaderAddChunk) ( + OrthancPluginServerChunkedRequestReader* reader, + const void* data, + uint32_t size); + + + /** + * @brief Callback invoked whenever the request body is entirely received. + * + * Signature of a callback function that is called by Orthanc acting + * as a HTTP server that supports chunked HTTP transfers. This + * callback is invoked as soon as the full body of the HTTP request + * is available. The plugin can then send its answer thanks to the + * provided "output" object. + * + * @see OrthancPluginRegisterChunkedRestCallback() + * @param reader The user payload, as created by the OrthancPluginServerChunkedRequestReaderFactory() callback. + * @param output The HTTP connection to the client application. + * @return 0 if success, or the error code if failure. + **/ + typedef OrthancPluginErrorCode (*OrthancPluginServerChunkedRequestReaderExecute) ( + OrthancPluginServerChunkedRequestReader* reader, + OrthancPluginRestOutput* output); + + + /** + * @brief Callback invoked to release the resources associated with an incoming HTTP chunked transfer. + * + * Signature of a callback function that is called by Orthanc acting + * as a HTTP server that supports chunked HTTP transfers. This + * callback is invoked to release all the resources allocated by the + * given reader. Note that this function might be invoked even if + * the entire body was not read, to deal with client error or + * disconnection. + * + * @see OrthancPluginRegisterChunkedRestCallback() + * @param reader The user payload, as created by the OrthancPluginServerChunkedRequestReaderFactory() callback. + **/ + typedef void (*OrthancPluginServerChunkedRequestReaderFinalize) ( + OrthancPluginServerChunkedRequestReader* reader); + + typedef struct + { + const char* pathRegularExpression; + OrthancPluginRestCallback getHandler; + OrthancPluginServerChunkedRequestReaderFactory postHandler; + OrthancPluginRestCallback deleteHandler; + OrthancPluginServerChunkedRequestReaderFactory putHandler; + OrthancPluginServerChunkedRequestReaderAddChunk addChunk; + OrthancPluginServerChunkedRequestReaderExecute execute; + OrthancPluginServerChunkedRequestReaderFinalize finalize; + } _OrthancPluginChunkedRestCallback; + + + /** + * @brief Register a REST callback to handle chunked HTTP transfers. + * + * This function registers a REST callback against a regular + * expression for a URI. This function must be called during the + * initialization of the plugin, i.e. inside the + * OrthancPluginInitialize() public function. + * + * Contrarily to OrthancPluginRegisterRestCallback(), the callbacks + * will NOT be invoked in mutual exclusion, so it is up to the + * plugin to implement the required locking mechanisms. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param pathRegularExpression Regular expression for the URI. May contain groups. + * @param getHandler The callback function to handle REST calls using the GET HTTP method. + * @param postHandler The callback function to handle REST calls using the POST HTTP method. + * @param deleteHandler The callback function to handle REST calls using the DELETE HTTP method. + * @param putHandler The callback function to handle REST calls using the PUT HTTP method. + * @param addChunk The callback invoked when a new chunk is available for the request body of a POST or PUT call. + * @param execute The callback invoked once the entire body of a POST or PUT call is read. + * @param finalize The callback invoked to release the resources associated with a POST or PUT call. + * @see OrthancPluginRegisterRestCallbackNoLock() + * + * @note + * The regular expression is case sensitive and must follow the + * [Perl syntax](https://www.boost.org/doc/libs/1_67_0/libs/regex/doc/html/boost_regex/syntax/perl_syntax.html). + * + * @ingroup Callbacks + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterChunkedRestCallback( + OrthancPluginContext* context, + const char* pathRegularExpression, + OrthancPluginRestCallback getHandler, + OrthancPluginServerChunkedRequestReaderFactory postHandler, + OrthancPluginRestCallback deleteHandler, + OrthancPluginServerChunkedRequestReaderFactory putHandler, + OrthancPluginServerChunkedRequestReaderAddChunk addChunk, + OrthancPluginServerChunkedRequestReaderExecute execute, + OrthancPluginServerChunkedRequestReaderFinalize finalize) + { + _OrthancPluginChunkedRestCallback params; + params.pathRegularExpression = pathRegularExpression; + params.getHandler = getHandler; + params.postHandler = postHandler; + params.deleteHandler = deleteHandler; + params.putHandler = putHandler; + params.addChunk = addChunk; + params.execute = execute; + params.finalize = finalize; + + context->InvokeService(context, _OrthancPluginService_RegisterChunkedRestCallback, ¶ms); + } + + + + + + typedef struct + { + char** result; + uint16_t group; + uint16_t element; + const char* privateCreator; + } _OrthancPluginGetTagName; + + /** + * @brief Returns the symbolic name of a DICOM tag. + * + * This function makes a lookup to the dictionary of DICOM tags that + * are known to Orthanc, and returns the symbolic name of a DICOM tag. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param group The group of the tag. + * @param element The element of the tag. + * @param privateCreator For private tags, the name of the private creator (can be NULL). + * @return NULL in the case of an error, or a newly allocated string + * containing the path. This string must be freed by + * OrthancPluginFreeString(). + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE char* OrthancPluginGetTagName( + OrthancPluginContext* context, + uint16_t group, + uint16_t element, + const char* privateCreator) + { + char* result; + + _OrthancPluginGetTagName params; + params.result = &result; + params.group = group; + params.element = element; + params.privateCreator = privateCreator; + + if (context->InvokeService(context, _OrthancPluginService_GetTagName, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + + + /** + * @brief Callback executed by the storage commitment SCP. + * + * Signature of a factory function that creates an object to handle + * one incoming storage commitment request. + * + * @remark The factory receives the list of the SOP class/instance + * UIDs of interest to the remote storage commitment SCU. This gives + * the factory the possibility to start some prefetch process + * upfront in the background, before the handler object is actually + * queried about the status of these DICOM instances. + * + * @param handler Output variable where the factory puts the handler object it created. + * @param jobId ID of the Orthanc job that is responsible for handling + * the storage commitment request. This job will successively look for the + * status of all the individual queried DICOM instances. + * @param transactionUid UID of the storage commitment transaction + * provided by the storage commitment SCU. It contains the value of the + * (0008,1195) DICOM tag. + * @param sopClassUids Array of the SOP class UIDs (0008,0016) that are queried by the SCU. + * @param sopInstanceUids Array of the SOP instance UIDs (0008,0018) that are queried by the SCU. + * @param countInstances Number of DICOM instances that are queried. This is the size + * of the `sopClassUids` and `sopInstanceUids` arrays. + * @param remoteAet The AET of the storage commitment SCU. + * @param calledAet The AET used by the SCU to contact the storage commitment SCP (i.e. Orthanc). + * @return 0 if success, other value if error. + * @ingroup DicomCallbacks + **/ + typedef OrthancPluginErrorCode (*OrthancPluginStorageCommitmentFactory) ( + void** handler /* out */, + const char* jobId, + const char* transactionUid, + const char* const* sopClassUids, + const char* const* sopInstanceUids, + uint32_t countInstances, + const char* remoteAet, + const char* calledAet); + + + /** + * @brief Callback to free one storage commitment SCP handler. + * + * Signature of a callback function that releases the resources + * allocated by the factory of the storage commitment SCP. The + * handler is the return value of a previous call to the + * OrthancPluginStorageCommitmentFactory() callback. + * + * @param handler The handler object to be destructed. + * @ingroup DicomCallbacks + **/ + typedef void (*OrthancPluginStorageCommitmentDestructor) (void* handler); + + + /** + * @brief Callback to get the status of one DICOM instance in the + * storage commitment SCP. + * + * Signature of a callback function that is successively invoked for + * each DICOM instance that is queried by the remote storage + * commitment SCU. The function must be tought of as a method of + * the handler object that was created by a previous call to the + * OrthancPluginStorageCommitmentFactory() callback. After each call + * to this method, the progress of the associated Orthanc job is + * updated. + * + * @param target Output variable where to put the status for the queried instance. + * @param handler The handler object associated with this storage commitment request. + * @param sopClassUid The SOP class UID (0008,0016) of interest. + * @param sopInstanceUid The SOP instance UID (0008,0018) of interest. + * @ingroup DicomCallbacks + **/ + typedef OrthancPluginErrorCode (*OrthancPluginStorageCommitmentLookup) ( + OrthancPluginStorageCommitmentFailureReason* target, + void* handler, + const char* sopClassUid, + const char* sopInstanceUid); + + + typedef struct + { + OrthancPluginStorageCommitmentFactory factory; + OrthancPluginStorageCommitmentDestructor destructor; + OrthancPluginStorageCommitmentLookup lookup; + } _OrthancPluginRegisterStorageCommitmentScpCallback; + + /** + * @brief Register a callback to handle incoming requests to the storage commitment SCP. + * + * This function registers a callback to handle storage commitment SCP requests. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param factory Factory function that creates the handler object + * for incoming storage commitment requests. + * @param destructor Destructor function to destroy the handler object. + * @param lookup Callback function to get the status of one DICOM instance. + * @return 0 if success, other value if error. + * @ingroup DicomCallbacks + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRegisterStorageCommitmentScpCallback( + OrthancPluginContext* context, + OrthancPluginStorageCommitmentFactory factory, + OrthancPluginStorageCommitmentDestructor destructor, + OrthancPluginStorageCommitmentLookup lookup) + { + _OrthancPluginRegisterStorageCommitmentScpCallback params; + params.factory = factory; + params.destructor = destructor; + params.lookup = lookup; + return context->InvokeService(context, _OrthancPluginService_RegisterStorageCommitmentScpCallback, ¶ms); + } + + + + /** + * @brief Callback to filter incoming DICOM instances received by Orthanc. + * + * Signature of a callback function that is triggered whenever + * Orthanc receives a new DICOM instance (e.g. through REST API or + * DICOM protocol), and that answers whether this DICOM instance + * should be accepted or discarded by Orthanc. + * + * Note that the metadata information is not available + * (i.e. GetInstanceMetadata() should not be used on "instance"). + * + * @warning Your callback function will be called synchronously with + * the core of Orthanc. This implies that deadlocks might emerge if + * you call other core primitives of Orthanc in your callback (such + * deadlocks are particularly visible in the presence of other plugins + * or Lua scripts). It is thus strongly advised to avoid any call to + * the REST API of Orthanc in the callback. If you have to call + * other primitives of Orthanc, you should make these calls in a + * separate thread, passing the pending events to be processed + * through a message queue. + * + * @param instance The received DICOM instance. + * @return 0 to discard the instance, 1 to store the instance, -1 if error. + * @ingroup Callbacks + **/ + typedef int32_t (*OrthancPluginIncomingDicomInstanceFilter) ( + const OrthancPluginDicomInstance* instance); + + + typedef struct + { + OrthancPluginIncomingDicomInstanceFilter callback; + } _OrthancPluginIncomingDicomInstanceFilter; + + /** + * @brief Register a callback to filter incoming DICOM instances. + * + * This function registers a custom callback to filter incoming + * DICOM instances received by Orthanc (either through the REST API + * or through the DICOM protocol). + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param callback The callback. + * @return 0 if success, other value if error. + * @ingroup Callbacks + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRegisterIncomingDicomInstanceFilter( + OrthancPluginContext* context, + OrthancPluginIncomingDicomInstanceFilter callback) + { + _OrthancPluginIncomingDicomInstanceFilter params; + params.callback = callback; + + return context->InvokeService(context, _OrthancPluginService_RegisterIncomingDicomInstanceFilter, ¶ms); + } + + + /** + * @brief Callback to filter incoming DICOM instances received by + * Orthanc through C-STORE. + * + * Signature of a callback function that is triggered whenever + * Orthanc receives a new DICOM instance using DICOM C-STORE, and + * that answers whether this DICOM instance should be accepted or + * discarded by Orthanc. If the instance is discarded, the callback + * can specify the DIMSE error code answered by the Orthanc C-STORE + * SCP. + * + * Note that the metadata information is not available + * (i.e. GetInstanceMetadata() should not be used on "instance"). + * + * @warning Your callback function will be called synchronously with + * the core of Orthanc. This implies that deadlocks might emerge if + * you call other core primitives of Orthanc in your callback (such + * deadlocks are particularly visible in the presence of other plugins + * or Lua scripts). It is thus strongly advised to avoid any call to + * the REST API of Orthanc in the callback. If you have to call + * other primitives of Orthanc, you should make these calls in a + * separate thread, passing the pending events to be processed + * through a message queue. + * + * @param dimseStatus If the DICOM instance is discarded, + * DIMSE status to be sent by the C-STORE SCP of Orthanc + * @param instance The received DICOM instance. + * @return 0 to discard the instance, 1 to store the instance, -1 if error. + * @ingroup Callbacks + **/ + typedef int32_t (*OrthancPluginIncomingCStoreInstanceFilter) ( + uint16_t* dimseStatus /* out */, + const OrthancPluginDicomInstance* instance); + + + typedef struct + { + OrthancPluginIncomingCStoreInstanceFilter callback; + } _OrthancPluginIncomingCStoreInstanceFilter; + + /** + * @brief Register a callback to filter incoming DICOM instances + * received by Orthanc through C-STORE. + * + * This function registers a custom callback to filter incoming + * DICOM instances received by Orthanc through the DICOM protocol. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param callback The callback. + * @return 0 if success, other value if error. + * @ingroup Callbacks + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRegisterIncomingCStoreInstanceFilter( + OrthancPluginContext* context, + OrthancPluginIncomingCStoreInstanceFilter callback) + { + _OrthancPluginIncomingCStoreInstanceFilter params; + params.callback = callback; + + return context->InvokeService(context, _OrthancPluginService_RegisterIncomingCStoreInstanceFilter, ¶ms); + } + + /** + * @brief Callback to keep/discard/modify a DICOM instance received + * by Orthanc from any source (C-STORE or REST API) + * + * Signature of a callback function that is triggered whenever + * Orthanc receives a new DICOM instance (through DICOM protocol or + * REST API), and that specifies an action to be applied to this + * newly received instance. The instance can be kept as it is, can + * be modified by the plugin, or can be discarded. + * + * This callback is invoked immediately after reception, i.e. before + * transcoding and before filtering + * (cf. OrthancPluginRegisterIncomingDicomInstanceFilter()). + * + * @warning Your callback function will be called synchronously with + * the core of Orthanc. This implies that deadlocks might emerge if + * you call other core primitives of Orthanc in your callback (such + * deadlocks are particularly visible in the presence of other plugins + * or Lua scripts). It is thus strongly advised to avoid any call to + * the REST API of Orthanc in the callback. If you have to call + * other primitives of Orthanc, you should make these calls in a + * separate thread, passing the pending events to be processed + * through a message queue. + * + * @param modifiedDicomBuffer A buffer containing the modified DICOM (output). + * This buffer must be allocated using OrthancPluginCreateMemoryBuffer64() + * and will be freed by the Orthanc core. + * @param receivedDicomBuffer A buffer containing the received DICOM (input). + * @param receivedDicomBufferSize The size of the received DICOM (input). + * @param origin The origin of the DICOM instance (input). + * @return `OrthancPluginReceivedInstanceAction_KeepAsIs` to accept the instance as is,
+ * `OrthancPluginReceivedInstanceAction_Modify` to store the modified DICOM contained in `modifiedDicomBuffer`,
+ * `OrthancPluginReceivedInstanceAction_Discard` to tell Orthanc to discard the instance. + * @ingroup Callbacks + **/ + typedef OrthancPluginReceivedInstanceAction (*OrthancPluginReceivedInstanceCallback) ( + OrthancPluginMemoryBuffer64* modifiedDicomBuffer, + const void* receivedDicomBuffer, + uint64_t receivedDicomBufferSize, + OrthancPluginInstanceOrigin origin); + + + typedef struct + { + OrthancPluginReceivedInstanceCallback callback; + } _OrthancPluginReceivedInstanceCallback; + + /** + * @brief Register a callback to keep/discard/modify a DICOM instance received + * by Orthanc from any source (C-STORE or REST API) + * + * This function registers a custom callback to keep/discard/modify + * incoming DICOM instances received by Orthanc from any source + * (C-STORE or REST API). + * + * @warning Contrarily to + * OrthancPluginRegisterIncomingCStoreInstanceFilter() and + * OrthancPluginRegisterIncomingDicomInstanceFilter() that can be + * called by multiple plugins, + * OrthancPluginRegisterReceivedInstanceCallback() can only be used + * by one single plugin. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param callback The callback. + * @return 0 if success, other value if error. + * @ingroup Callbacks + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRegisterReceivedInstanceCallback( + OrthancPluginContext* context, + OrthancPluginReceivedInstanceCallback callback) + { + _OrthancPluginReceivedInstanceCallback params; + params.callback = callback; + + return context->InvokeService(context, _OrthancPluginService_RegisterReceivedInstanceCallback, ¶ms); + } + + /** + * @brief Get the transfer syntax of a DICOM file. + * + * This function returns a pointer to a newly created string that + * contains the transfer syntax UID of the DICOM instance. The empty + * string might be returned if this information is unknown. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param instance The instance of interest. + * @return The NULL value in case of error, or a string containing the + * transfer syntax UID. This string must be freed by OrthancPluginFreeString(). + * @ingroup DicomInstance + **/ + ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceTransferSyntaxUid( + OrthancPluginContext* context, + const OrthancPluginDicomInstance* instance) + { + char* result; + + _OrthancPluginAccessDicomInstance params; + memset(¶ms, 0, sizeof(params)); + params.resultStringToFree = &result; + params.instance = instance; + + if (context->InvokeService(context, _OrthancPluginService_GetInstanceTransferSyntaxUid, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + + /** + * @brief Check whether the DICOM file has pixel data. + * + * This function returns a Boolean value indicating whether the + * DICOM instance contains the pixel data (7FE0,0010) tag. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param instance The instance of interest. + * @return "1" if the DICOM instance contains pixel data, or "0" if + * the tag is missing, or "-1" in the case of an error. + * @ingroup DicomInstance + **/ + ORTHANC_PLUGIN_INLINE int32_t OrthancPluginHasInstancePixelData( + OrthancPluginContext* context, + const OrthancPluginDicomInstance* instance) + { + int64_t hasPixelData; + + _OrthancPluginAccessDicomInstance params; + memset(¶ms, 0, sizeof(params)); + params.resultInt64 = &hasPixelData; + params.instance = instance; + + if (context->InvokeService(context, _OrthancPluginService_HasInstancePixelData, ¶ms) != OrthancPluginErrorCode_Success || + hasPixelData < 0 || + hasPixelData > 1) + { + /* Error */ + return -1; + } + else + { + return (hasPixelData != 0); + } + } + + + + + + + typedef struct + { + OrthancPluginDicomInstance** target; + const void* buffer; + uint32_t size; + const char* transferSyntax; + } _OrthancPluginCreateDicomInstance; + + /** + * @brief Parse a DICOM instance. + * + * This function parses a memory buffer that contains a DICOM + * file. The function returns a new pointer to a data structure that + * is managed by the Orthanc core. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param buffer The memory buffer containing the DICOM instance. + * @param size The size of the memory buffer. + * @return The newly allocated DICOM instance. It must be freed with OrthancPluginFreeDicomInstance(). + * @ingroup DicomInstance + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginDicomInstance* OrthancPluginCreateDicomInstance( + OrthancPluginContext* context, + const void* buffer, + uint32_t size) + { + OrthancPluginDicomInstance* target = NULL; + + _OrthancPluginCreateDicomInstance params; + params.target = ⌖ + params.buffer = buffer; + params.size = size; + + if (context->InvokeService(context, _OrthancPluginService_CreateDicomInstance, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return target; + } + } + + typedef struct + { + OrthancPluginDicomInstance* dicom; + } _OrthancPluginFreeDicomInstance; + + /** + * @brief Free a DICOM instance. + * + * This function frees a DICOM instance that was parsed using + * OrthancPluginCreateDicomInstance(). + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param dicom The DICOM instance. + * @ingroup DicomInstance + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginFreeDicomInstance( + OrthancPluginContext* context, + OrthancPluginDicomInstance* dicom) + { + _OrthancPluginFreeDicomInstance params; + params.dicom = dicom; + + context->InvokeService(context, _OrthancPluginService_FreeDicomInstance, ¶ms); + } + + + typedef struct + { + uint32_t* targetUint32; + OrthancPluginMemoryBuffer* targetBuffer; + OrthancPluginImage** targetImage; + char** targetStringToFree; + const OrthancPluginDicomInstance* instance; + uint32_t frameIndex; + OrthancPluginDicomToJsonFormat format; + OrthancPluginDicomToJsonFlags flags; + uint32_t maxStringLength; + OrthancPluginDicomWebBinaryCallback2 dicomWebCallback; + void* dicomWebPayload; + } _OrthancPluginAccessDicomInstance2; + + /** + * @brief Get the number of frames in a DICOM instance. + * + * This function returns the number of frames that are part of a + * DICOM image managed by the Orthanc core. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param instance The instance of interest. + * @return The number of frames (will be zero in the case of an error). + * @ingroup DicomInstance + **/ + ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetInstanceFramesCount( + OrthancPluginContext* context, + const OrthancPluginDicomInstance* instance) + { + uint32_t count; + + _OrthancPluginAccessDicomInstance2 params; + memset(¶ms, 0, sizeof(params)); + params.targetUint32 = &count; + params.instance = instance; + + if (context->InvokeService(context, _OrthancPluginService_GetInstanceFramesCount, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return 0; + } + else + { + return count; + } + } + + + /** + * @brief Get the raw content of a frame in a DICOM instance. + * + * This function returns a memory buffer containing the raw content + * of a frame in a DICOM instance that is managed by the Orthanc + * core. This is notably useful for compressed transfer syntaxes, as + * it gives access to the embedded files (such as JPEG, JPEG-LS or + * JPEG2k). The Orthanc core transparently reassembles the fragments + * to extract the raw frame. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer(). + * @param instance The instance of interest. + * @param frameIndex The index of the frame of interest. + * @return 0 if success, or the error code if failure. + * @ingroup DicomInstance + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginGetInstanceRawFrame( + OrthancPluginContext* context, + OrthancPluginMemoryBuffer* target, + const OrthancPluginDicomInstance* instance, + uint32_t frameIndex) + { + _OrthancPluginAccessDicomInstance2 params; + memset(¶ms, 0, sizeof(params)); + params.targetBuffer = target; + params.instance = instance; + params.frameIndex = frameIndex; + + return context->InvokeService(context, _OrthancPluginService_GetInstanceRawFrame, ¶ms); + } + + + /** + * @brief Decode one frame from a DICOM instance. + * + * This function decodes one frame of a DICOM image that is managed + * by the Orthanc core. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param instance The instance of interest. + * @param frameIndex The index of the frame of interest. + * @return The uncompressed image. It must be freed with OrthancPluginFreeImage(). + * @ingroup DicomInstance + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginImage* OrthancPluginGetInstanceDecodedFrame( + OrthancPluginContext* context, + const OrthancPluginDicomInstance* instance, + uint32_t frameIndex) + { + OrthancPluginImage* target = NULL; + + _OrthancPluginAccessDicomInstance2 params; + memset(¶ms, 0, sizeof(params)); + params.targetImage = ⌖ + params.instance = instance; + params.frameIndex = frameIndex; + + if (context->InvokeService(context, _OrthancPluginService_GetInstanceDecodedFrame, ¶ms) != OrthancPluginErrorCode_Success) + { + return NULL; + } + else + { + return target; + } + } + + + /** + * @brief Parse and transcode a DICOM instance. + * + * This function parses a memory buffer that contains a DICOM file, + * then transcodes it to the given transfer syntax. The function + * returns a new pointer to a data structure that is managed by the + * Orthanc core. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param buffer The memory buffer containing the DICOM instance. + * @param size The size of the memory buffer. + * @param transferSyntax The transfer syntax UID for the transcoding. + * @return The newly allocated DICOM instance. It must be freed with OrthancPluginFreeDicomInstance(). + * @ingroup DicomInstance + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginDicomInstance* OrthancPluginTranscodeDicomInstance( + OrthancPluginContext* context, + const void* buffer, + uint32_t size, + const char* transferSyntax) + { + OrthancPluginDicomInstance* target = NULL; + + _OrthancPluginCreateDicomInstance params; + params.target = ⌖ + params.buffer = buffer; + params.size = size; + params.transferSyntax = transferSyntax; + + if (context->InvokeService(context, _OrthancPluginService_TranscodeDicomInstance, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return target; + } + } + + /** + * @brief Writes a DICOM instance to a memory buffer. + * + * This function returns a memory buffer containing the + * serialization of a DICOM instance that is managed by the Orthanc + * core. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer(). + * @param instance The instance of interest. + * @return 0 if success, or the error code if failure. + * @ingroup DicomInstance + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginSerializeDicomInstance( + OrthancPluginContext* context, + OrthancPluginMemoryBuffer* target, + const OrthancPluginDicomInstance* instance) + { + _OrthancPluginAccessDicomInstance2 params; + memset(¶ms, 0, sizeof(params)); + params.targetBuffer = target; + params.instance = instance; + + return context->InvokeService(context, _OrthancPluginService_SerializeDicomInstance, ¶ms); + } + + + /** + * @brief Format a DICOM memory buffer as a JSON string. + * + * This function takes as DICOM instance managed by the Orthanc + * core, and outputs a JSON string representing the tags of this + * DICOM file. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param instance The DICOM instance of interest. + * @param format The output format. + * @param flags Flags governing the output. + * @param maxStringLength The maximum length of a field. Too long fields will + * be output as "null". The 0 value means no maximum length. + * @return The NULL value if the case of an error, or the JSON + * string. This string must be freed by OrthancPluginFreeString(). + * @ingroup DicomInstance + * @see OrthancPluginDicomBufferToJson + **/ + ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceAdvancedJson( + OrthancPluginContext* context, + const OrthancPluginDicomInstance* instance, + OrthancPluginDicomToJsonFormat format, + OrthancPluginDicomToJsonFlags flags, + uint32_t maxStringLength) + { + char* result = NULL; + + _OrthancPluginAccessDicomInstance2 params; + memset(¶ms, 0, sizeof(params)); + params.targetStringToFree = &result; + params.instance = instance; + params.format = format; + params.flags = flags; + params.maxStringLength = maxStringLength; + + if (context->InvokeService(context, _OrthancPluginService_GetInstanceAdvancedJson, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + + /** + * @brief Convert a DICOM instance to DICOMweb JSON. + * + * This function converts a DICOM instance that is managed by the + * Orthanc core, into its DICOMweb JSON representation. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param instance The DICOM instance of interest. + * @param callback Callback to set the value of the binary tags. + * @param payload User payload. + * @return The NULL value in case of error, or the JSON document. This string must + * be freed by OrthancPluginFreeString(). + * @ingroup DicomInstance + **/ + ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebJson( + OrthancPluginContext* context, + const OrthancPluginDicomInstance* instance, + OrthancPluginDicomWebBinaryCallback2 callback, + void* payload) + { + char* target = NULL; + + _OrthancPluginAccessDicomInstance2 params; + params.targetStringToFree = ⌖ + params.instance = instance; + params.dicomWebCallback = callback; + params.dicomWebPayload = payload; + + if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebJson, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return target; + } + } + + + /** + * @brief Convert a DICOM instance to DICOMweb XML. + * + * This function converts a DICOM instance that is managed by the + * Orthanc core, into its DICOMweb XML representation. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param instance The DICOM instance of interest. + * @param callback Callback to set the value of the binary tags. + * @param payload User payload. + * @return The NULL value in case of error, or the XML document. This string must + * be freed by OrthancPluginFreeString(). + * @ingroup DicomInstance + **/ + ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebXml( + OrthancPluginContext* context, + const OrthancPluginDicomInstance* instance, + OrthancPluginDicomWebBinaryCallback2 callback, + void* payload) + { + char* target = NULL; + + _OrthancPluginAccessDicomInstance2 params; + params.targetStringToFree = ⌖ + params.instance = instance; + params.dicomWebCallback = callback; + params.dicomWebPayload = payload; + + if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebXml, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return target; + } + } + + + + /** + * @brief Signature of a callback function to transcode a DICOM instance. + * @param transcoded Target memory buffer. It must be allocated by the + * plugin using OrthancPluginCreateMemoryBuffer(). + * @param buffer Memory buffer containing the source DICOM instance. + * @param size Size of the source memory buffer. + * @param allowedSyntaxes A C array of possible transfer syntaxes UIDs for the + * result of the transcoding. The plugin must choose by itself the + * transfer syntax that will be used for the resulting DICOM image. + * @param countSyntaxes The number of transfer syntaxes that are contained + * in the "allowedSyntaxes" array. + * @param allowNewSopInstanceUid Whether the transcoding plugin can select + * a transfer syntax that will change the SOP instance UID (or, in other + * terms, whether the plugin can transcode using lossy compression). + * @return 0 if success (i.e. image successfully transcoded and stored into + * "transcoded"), or the error code if failure. + * @ingroup Callbacks + **/ + typedef OrthancPluginErrorCode (*OrthancPluginTranscoderCallback) ( + OrthancPluginMemoryBuffer* transcoded /* out */, + const void* buffer, + uint64_t size, + const char* const* allowedSyntaxes, + uint32_t countSyntaxes, + uint8_t allowNewSopInstanceUid); + + + typedef struct + { + OrthancPluginTranscoderCallback callback; + } _OrthancPluginTranscoderCallback; + + /** + * @brief Register a callback to handle the transcoding of DICOM images. + * + * This function registers a custom callback to transcode DICOM + * images, extending the built-in transcoder of Orthanc that uses + * DCMTK. The exact behavior is affected by the configuration option + * "BuiltinDecoderTranscoderOrder" of Orthanc. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param callback The callback. + * @return 0 if success, other value if error. + * @ingroup Callbacks + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRegisterTranscoderCallback( + OrthancPluginContext* context, + OrthancPluginTranscoderCallback callback) + { + _OrthancPluginTranscoderCallback params; + params.callback = callback; + + return context->InvokeService(context, _OrthancPluginService_RegisterTranscoderCallback, ¶ms); + } + + + + typedef struct + { + OrthancPluginMemoryBuffer* target; + uint32_t size; + } _OrthancPluginCreateMemoryBuffer; + + /** + * @brief Create a 32-bit memory buffer. + * + * This function creates a memory buffer that is managed by the + * Orthanc core. The main use case of this function is for plugins + * that act as DICOM transcoders. + * + * Your plugin should never call "free()" on the resulting memory + * buffer, as the C library that is used by the plugin is in general + * not the same as the one used by the Orthanc core. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer(). + * @param size Size of the memory buffer to be created. + * @return 0 if success, or the error code if failure. + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer( + OrthancPluginContext* context, + OrthancPluginMemoryBuffer* target, + uint32_t size) + { + _OrthancPluginCreateMemoryBuffer params; + params.target = target; + params.size = size; + + return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer, ¶ms); + } + + + /** + * @brief Generate a token to grant full access to the REST API of Orthanc. + * + * This function generates a token that can be set in the HTTP + * header "Authorization" so as to grant full access to the REST API + * of Orthanc using an external HTTP client. Using this function + * avoids the need of adding a separate user in the + * "RegisteredUsers" configuration of Orthanc, which eases + * deployments. + * + * This feature is notably useful in multiprocess scenarios, where a + * subprocess created by a plugin has no access to the + * "OrthancPluginContext", and thus cannot call + * "OrthancPluginRestApi[Get|Post|Put|Delete]()". + * + * This situation is frequently encountered in Python plugins, where + * the "multiprocessing" package can be used to bypass the Global + * Interpreter Lock (GIL) and thus to improve performance and + * concurrency. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @return The authorization token, or NULL value in the case of an error. + * This string must be freed by OrthancPluginFreeString(). + * @ingroup Orthanc + **/ + ORTHANC_PLUGIN_INLINE char* OrthancPluginGenerateRestApiAuthorizationToken( + OrthancPluginContext* context) + { + char* result; + + _OrthancPluginRetrieveDynamicString params; + params.result = &result; + params.argument = NULL; + + if (context->InvokeService(context, _OrthancPluginService_GenerateRestApiAuthorizationToken, + ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + + + typedef struct + { + OrthancPluginMemoryBuffer64* target; + uint64_t size; + } _OrthancPluginCreateMemoryBuffer64; + + /** + * @brief Create a 64-bit memory buffer. + * + * This function creates a 64-bit memory buffer that is managed by + * the Orthanc core. The main use case of this function is for + * plugins that read files from the storage area. + * + * Your plugin should never call "free()" on the resulting memory + * buffer, as the C library that is used by the plugin is in general + * not the same as the one used by the Orthanc core. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer(). + * @param size Size of the memory buffer to be created. + * @return 0 if success, or the error code if failure. + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer64( + OrthancPluginContext* context, + OrthancPluginMemoryBuffer64* target, + uint64_t size) + { + _OrthancPluginCreateMemoryBuffer64 params; + params.target = target; + params.size = size; + + return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer64, ¶ms); + } + + + typedef struct + { + OrthancPluginStorageCreate create; + OrthancPluginStorageReadWhole readWhole; + OrthancPluginStorageReadRange readRange; + OrthancPluginStorageRemove remove; + } _OrthancPluginRegisterStorageArea2; + + /** + * @brief Register a custom storage area, with support for range request. + * + * This function registers a custom storage area, to replace the + * built-in way Orthanc stores its files on the filesystem. This + * function must be called during the initialization of the plugin, + * i.e. inside the OrthancPluginInitialize() public function. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param create The callback function to store a file on the custom storage area. + * @param readWhole The callback function to read a whole file from the custom storage area. + * @param readRange The callback function to read some range of a file from the custom storage area. + * If this feature is not supported by the plugin, this value can be set to NULL. + * @param remove The callback function to remove a file from the custom storage area. + * @ingroup Callbacks + **/ + ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea2( + OrthancPluginContext* context, + OrthancPluginStorageCreate create, + OrthancPluginStorageReadWhole readWhole, + OrthancPluginStorageReadRange readRange, + OrthancPluginStorageRemove remove) + { + _OrthancPluginRegisterStorageArea2 params; + params.create = create; + params.readWhole = readWhole; + params.readRange = readRange; + params.remove = remove; + context->InvokeService(context, _OrthancPluginService_RegisterStorageArea2, ¶ms); + } + + + + typedef struct + { + _OrthancPluginCreateDicom createDicom; + const char* privateCreator; + } _OrthancPluginCreateDicom2; + + /** + * @brief Create a DICOM instance from a JSON string and an image, with a private creator. + * + * This function takes as input a string containing a JSON file + * describing the content of a DICOM instance. As an output, it + * writes the corresponding DICOM instance to a newly allocated + * memory buffer. Additionally, an image to be encoded within the + * DICOM instance can also be provided. + * + * Contrarily to the function OrthancPluginCreateDicom(), this + * function can be explicitly provided with a private creator. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param target The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer(). + * @param json The input JSON file. + * @param pixelData The image. Can be NULL, if the pixel data is encoded inside the JSON with the data URI scheme. + * @param flags Flags governing the output. + * @param privateCreator The private creator to be used for the private DICOM tags. + * Check out the global configuration option "Dictionary" of Orthanc. + * @return 0 if success, other value if error. + * @ingroup Toolbox + * @see OrthancPluginCreateDicom + * @see OrthancPluginDicomBufferToJson + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginCreateDicom2( + OrthancPluginContext* context, + OrthancPluginMemoryBuffer* target, + const char* json, + const OrthancPluginImage* pixelData, + OrthancPluginCreateDicomFlags flags, + const char* privateCreator) + { + _OrthancPluginCreateDicom2 params; + params.createDicom.target = target; + params.createDicom.json = json; + params.createDicom.pixelData = pixelData; + params.createDicom.flags = flags; + params.privateCreator = privateCreator; + + return context->InvokeService(context, _OrthancPluginService_CreateDicom2, ¶ms); + } + + + + + + + typedef struct + { + OrthancPluginMemoryBuffer* answerBody; + OrthancPluginMemoryBuffer* answerHeaders; + uint16_t* httpStatus; + OrthancPluginHttpMethod method; + const char* uri; + uint32_t headersCount; + const char* const* headersKeys; + const char* const* headersValues; + const void* body; + uint32_t bodySize; + uint8_t afterPlugins; + } _OrthancPluginCallRestApi; + + /** + * @brief Call the REST API of Orthanc with full flexibility. + * + * Make a call to the given URI in the REST API of Orthanc. The + * result to the query is stored into a newly allocated memory + * buffer. This function is always granted full access to the REST + * API (no credentials, nor security token is needed). + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param answerBody The target memory buffer (out argument). + * It must be freed with OrthancPluginFreeMemoryBuffer(). + * The value of this argument is ignored if the HTTP method is DELETE. + * @param answerHeaders The target memory buffer for the HTTP headers in the answer (out argument). + * The answer headers are formatted as a JSON object (associative array). + * The buffer must be freed with OrthancPluginFreeMemoryBuffer(). + * This argument can be set to NULL if the plugin has no interest in the answer HTTP headers. + * @param httpStatus The HTTP status after the execution of the request (out argument). + * @param method HTTP method to be used. + * @param uri The URI of interest. + * @param headersCount The number of HTTP headers. + * @param headersKeys Array containing the keys of the HTTP headers (can be NULL if no header). + * @param headersValues Array containing the values of the HTTP headers (can be NULL if no header). + * @param body The HTTP body for a POST or PUT request. + * @param bodySize The size of the body. + * @param afterPlugins If 0, the built-in API of Orthanc is used. + * If 1, the API is tainted by the plugins. + * @return 0 if success, or the error code if failure. + * @see OrthancPluginRestApiGet2, OrthancPluginRestApiPost, OrthancPluginRestApiPut, OrthancPluginRestApiDelete + * @ingroup Orthanc + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginCallRestApi( + OrthancPluginContext* context, + OrthancPluginMemoryBuffer* answerBody, + OrthancPluginMemoryBuffer* answerHeaders, + uint16_t* httpStatus, + OrthancPluginHttpMethod method, + const char* uri, + uint32_t headersCount, + const char* const* headersKeys, + const char* const* headersValues, + const void* body, + uint32_t bodySize, + uint8_t afterPlugins) + { + _OrthancPluginCallRestApi params; + memset(¶ms, 0, sizeof(params)); + + params.answerBody = answerBody; + params.answerHeaders = answerHeaders; + params.httpStatus = httpStatus; + params.method = method; + params.uri = uri; + params.headersCount = headersCount; + params.headersKeys = headersKeys; + params.headersValues = headersValues; + params.body = body; + params.bodySize = bodySize; + params.afterPlugins = afterPlugins; + + return context->InvokeService(context, _OrthancPluginService_CallRestApi, ¶ms); + } + + + + /** + * @brief Opaque structure that represents a WebDAV collection. + * @ingroup Callbacks + **/ + typedef struct _OrthancPluginWebDavCollection_t OrthancPluginWebDavCollection; + + + /** + * @brief Declare a file while returning the content of a folder. + * + * This function declares a file while returning the content of a + * WebDAV folder. + * + * @param collection Context of the collection. + * @param name Base name of the file. + * @param dateTime The date and time of creation of the file. + * Check out the documentation of OrthancPluginWebDavRetrieveFile() for more information. + * @param size Size of the file. + * @param mimeType The MIME type of the file. If empty or set to `NULL`, + * Orthanc will do a best guess depending on the file extension. + * @return 0 if success, other value if error. + * @ingroup Callbacks + **/ + typedef OrthancPluginErrorCode (*OrthancPluginWebDavAddFile) ( + OrthancPluginWebDavCollection* collection, + const char* name, + uint64_t size, + const char* mimeType, + const char* dateTime); + + + /** + * @brief Declare a subfolder while returning the content of a folder. + * + * This function declares a subfolder while returning the content of a + * WebDAV folder. + * + * @param collection Context of the collection. + * @param name Base name of the subfolder. + * @param dateTime The date and time of creation of the subfolder. + * Check out the documentation of OrthancPluginWebDavRetrieveFile() for more information. + * @return 0 if success, other value if error. + * @ingroup Callbacks + **/ + typedef OrthancPluginErrorCode (*OrthancPluginWebDavAddFolder) ( + OrthancPluginWebDavCollection* collection, + const char* name, + const char* dateTime); + + + /** + * @brief Retrieve the content of a file. + * + * This function is used to forward the content of a file from a + * WebDAV collection, to the core of Orthanc. + * + * @param collection Context of the collection. + * @param data Content of the file. + * @param size Size of the file. + * @param mimeType The MIME type of the file. If empty or set to `NULL`, + * Orthanc will do a best guess depending on the file extension. + * @param dateTime The date and time of creation of the file. + * It must be formatted as an ISO string of form + * `YYYYMMDDTHHMMSS,fffffffff` where T is the date-time + * separator. It must be expressed in UTC (it is the responsibility + * of the plugin to do the possible timezone + * conversions). Internally, this string will be parsed using + * `boost::posix_time::from_iso_string()`. + * @return 0 if success, other value if error. + * @ingroup Callbacks + **/ + typedef OrthancPluginErrorCode (*OrthancPluginWebDavRetrieveFile) ( + OrthancPluginWebDavCollection* collection, + const void* data, + uint64_t size, + const char* mimeType, + const char* dateTime); + + + /** + * @brief Callback for testing the existence of a folder. + * + * Signature of a callback function that tests whether the given + * path in the WebDAV collection exists and corresponds to a folder. + * + * @param isExisting Pointer to a Boolean that must be set to `1` if the folder exists, or `0` otherwise. + * @param pathSize Number of levels in the path. + * @param pathItems Items making the path. + * @param payload The user payload. + * @return 0 if success, other value if error. + * @ingroup Callbacks + **/ + typedef OrthancPluginErrorCode (*OrthancPluginWebDavIsExistingFolderCallback) ( + uint8_t* isExisting, /* out */ + uint32_t pathSize, + const char* const* pathItems, + void* payload); + + + /** + * @brief Callback for listing the content of a folder. + * + * Signature of a callback function that lists the content of a + * folder in the WebDAV collection. The callback must call the + * provided `addFile()` and `addFolder()` functions to emit the + * content of the folder. + * + * @param isExisting Pointer to a Boolean that must be set to `1` if the folder exists, or `0` otherwise. + * @param collection Context to be provided to `addFile()` and `addFolder()` functions. + * @param addFile Function to add a file to the list. + * @param addFolder Function to add a folder to the list. + * @param pathSize Number of levels in the path. + * @param pathItems Items making the path. + * @param payload The user payload. + * @return 0 if success, other value if error. + * @ingroup Callbacks + **/ + typedef OrthancPluginErrorCode (*OrthancPluginWebDavListFolderCallback) ( + uint8_t* isExisting, /* out */ + OrthancPluginWebDavCollection* collection, + OrthancPluginWebDavAddFile addFile, + OrthancPluginWebDavAddFolder addFolder, + uint32_t pathSize, + const char* const* pathItems, + void* payload); + + + /** + * @brief Callback for retrieving the content of a file. + * + * Signature of a callback function that retrieves the content of a + * file in the WebDAV collection. The callback must call the + * provided `retrieveFile()` function to emit the actual content of + * the file. + * + * @param collection Context to be provided to `retrieveFile()` function. + * @param retrieveFile Function to return the content of the file. + * @param pathSize Number of levels in the path. + * @param pathItems Items making the path. + * @param payload The user payload. + * @return 0 if success, other value if error. + * @ingroup Callbacks + **/ + typedef OrthancPluginErrorCode (*OrthancPluginWebDavRetrieveFileCallback) ( + OrthancPluginWebDavCollection* collection, + OrthancPluginWebDavRetrieveFile retrieveFile, + uint32_t pathSize, + const char* const* pathItems, + void* payload); + + + /** + * @brief Callback to store a file. + * + * Signature of a callback function that stores a file into the + * WebDAV collection. + * + * @param isReadOnly Pointer to a Boolean that must be set to `1` if the collection is read-only, or `0` otherwise. + * @param pathSize Number of levels in the path. + * @param pathItems Items making the path. + * @param data Content of the file to be stored. + * @param size Size of the file to be stored. + * @param payload The user payload. + * @return 0 if success, other value if error. + * @ingroup Callbacks + **/ + typedef OrthancPluginErrorCode (*OrthancPluginWebDavStoreFileCallback) ( + uint8_t* isReadOnly, /* out */ + uint32_t pathSize, + const char* const* pathItems, + const void* data, + uint64_t size, + void* payload); + + + /** + * @brief Callback to create a folder. + * + * Signature of a callback function that creates a folder in the + * WebDAV collection. + * + * @param isReadOnly Pointer to a Boolean that must be set to `1` if the collection is read-only, or `0` otherwise. + * @param pathSize Number of levels in the path. + * @param pathItems Items making the path. + * @param payload The user payload. + * @return 0 if success, other value if error. + * @ingroup Callbacks + **/ + typedef OrthancPluginErrorCode (*OrthancPluginWebDavCreateFolderCallback) ( + uint8_t* isReadOnly, /* out */ + uint32_t pathSize, + const char* const* pathItems, + void* payload); + + + /** + * @brief Callback to remove a file or a folder. + * + * Signature of a callback function that removes a file or a folder + * from the WebDAV collection. + * + * @param isReadOnly Pointer to a Boolean that must be set to `1` if the collection is read-only, or `0` otherwise. + * @param pathSize Number of levels in the path. + * @param pathItems Items making the path. + * @param payload The user payload. + * @return 0 if success, other value if error. + * @ingroup Callbacks + **/ + typedef OrthancPluginErrorCode (*OrthancPluginWebDavDeleteItemCallback) ( + uint8_t* isReadOnly, /* out */ + uint32_t pathSize, + const char* const* pathItems, + void* payload); + + + typedef struct + { + const char* uri; + OrthancPluginWebDavIsExistingFolderCallback isExistingFolder; + OrthancPluginWebDavListFolderCallback listFolder; + OrthancPluginWebDavRetrieveFileCallback retrieveFile; + OrthancPluginWebDavStoreFileCallback storeFile; + OrthancPluginWebDavCreateFolderCallback createFolder; + OrthancPluginWebDavDeleteItemCallback deleteItem; + void* payload; + } _OrthancPluginRegisterWebDavCollection; + + /** + * @brief Register a WebDAV virtual filesystem. + * + * This function maps a WebDAV collection onto the given URI in the + * REST API of Orthanc. This function must be called during the + * initialization of the plugin, i.e. inside the + * OrthancPluginInitialize() public function. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @param uri URI where to map the WebDAV collection (must start with a `/` character). + * @param isExistingFolder Callback method to test for the existence of a folder. + * @param listFolder Callback method to list the content of a folder. + * @param retrieveFile Callback method to retrieve the content of a file. + * @param storeFile Callback method to store a file into the WebDAV collection. + * @param createFolder Callback method to create a folder. + * @param deleteItem Callback method to delete a file or a folder. + * @param payload The user payload. + * @return 0 if success, other value if error. + * @ingroup Callbacks + **/ + ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRegisterWebDavCollection( + OrthancPluginContext* context, + const char* uri, + OrthancPluginWebDavIsExistingFolderCallback isExistingFolder, + OrthancPluginWebDavListFolderCallback listFolder, + OrthancPluginWebDavRetrieveFileCallback retrieveFile, + OrthancPluginWebDavStoreFileCallback storeFile, + OrthancPluginWebDavCreateFolderCallback createFolder, + OrthancPluginWebDavDeleteItemCallback deleteItem, + void* payload) + { + _OrthancPluginRegisterWebDavCollection params; + params.uri = uri; + params.isExistingFolder = isExistingFolder; + params.listFolder = listFolder; + params.retrieveFile = retrieveFile; + params.storeFile = storeFile; + params.createFolder = createFolder; + params.deleteItem = deleteItem; + params.payload = payload; + + return context->InvokeService(context, _OrthancPluginService_RegisterWebDavCollection, ¶ms); + } + + + /** + * @brief Gets the DatabaseServerIdentifier. + * + * @param context The Orthanc plugin context, as received by OrthancPluginInitialize(). + * @return the database server identifier. This is a statically-allocated + * string, do not free it. + * @ingroup Toolbox + **/ + ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetDatabaseServerIdentifier( + OrthancPluginContext* context) + { + const char* result; + + _OrthancPluginRetrieveStaticString params; + params.result = &result; + params.argument = NULL; + + if (context->InvokeService(context, _OrthancPluginService_GetDatabaseServerIdentifier, ¶ms) != OrthancPluginErrorCode_Success) + { + /* Error */ + return NULL; + } + else + { + return result; + } + } + + +#ifdef __cplusplus +} +#endif + + +/** @} */ + diff --git a/Resources/Orthanc/Toolchains/LinuxStandardBaseToolchain.cmake b/Resources/Orthanc/Toolchains/LinuxStandardBaseToolchain.cmake new file mode 100644 index 0000000..1a81990 --- /dev/null +++ b/Resources/Orthanc/Toolchains/LinuxStandardBaseToolchain.cmake @@ -0,0 +1,101 @@ +# Orthanc - A Lightweight, RESTful DICOM Store +# Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics +# Department, University Hospital of Liege, Belgium +# Copyright (C) 2017-2023 Osimis S.A., Belgium +# Copyright (C) 2024-2024 Orthanc Team SRL, Belgium +# Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium +# +# This program is free software: you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public License +# as published by the Free Software Foundation, either version 3 of +# the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this program. If not, see +# . + + +# +# Full build, as used on the BuildBot CIS: +# +# $ LSB_CC=gcc-4.8 LSB_CXX=g++-4.8 cmake ../OrthancServer/ -DCMAKE_BUILD_TYPE=Debug -DCMAKE_TOOLCHAIN_FILE=../OrthancFramework/Resources/Toolchains/LinuxStandardBaseToolchain.cmake -DUSE_LEGACY_JSONCPP=ON -DUSE_LEGACY_LIBICU=ON -DUSE_LEGACY_BOOST=ON -DBOOST_LOCALE_BACKEND=icu -DENABLE_PKCS11=ON -G Ninja +# +# Or, more lightweight version (without libp11 and ICU): +# +# $ LSB_CC=gcc-4.8 LSB_CXX=g++-4.8 cmake ../OrthancServer/ -DCMAKE_BUILD_TYPE=Debug -DCMAKE_TOOLCHAIN_FILE=../OrthancFramework/Resources/Toolchains/LinuxStandardBaseToolchain.cmake -DUSE_LEGACY_JSONCPP=ON -DUSE_LEGACY_BOOST=ON -G Ninja +# + +INCLUDE(CMakeForceCompiler) + +SET(LSB_PATH $ENV{LSB_PATH} CACHE STRING "") +SET(LSB_CC $ENV{LSB_CC} CACHE STRING "") +SET(LSB_CXX $ENV{LSB_CXX} CACHE STRING "") +SET(LSB_TARGET_VERSION "4.0" CACHE STRING "") + +IF ("${LSB_PATH}" STREQUAL "") + SET(LSB_PATH "/opt/lsb") +ENDIF() + +IF (EXISTS ${LSB_PATH}/lib64) + SET(LSB_TARGET_PROCESSOR "x86_64") + SET(LSB_LIBPATH ${LSB_PATH}/lib64-${LSB_TARGET_VERSION}) +ELSEIF (EXISTS ${LSB_PATH}/lib) + SET(LSB_TARGET_PROCESSOR "x86") + SET(LSB_LIBPATH ${LSB_PATH}/lib-${LSB_TARGET_VERSION}) +ELSE() + MESSAGE(FATAL_ERROR "Unable to detect the target processor architecture. Check the LSB_PATH environment variable.") +ENDIF() + +SET(LSB_CPPPATH ${LSB_PATH}/include) +SET(PKG_CONFIG_PATH ${LSB_LIBPATH}/pkgconfig/) + +# the name of the target operating system +SET(CMAKE_SYSTEM_NAME Linux) +SET(CMAKE_SYSTEM_VERSION LinuxStandardBase) +SET(CMAKE_SYSTEM_PROCESSOR ${LSB_TARGET_PROCESSOR}) + +# which compilers to use for C and C++ +SET(CMAKE_C_COMPILER ${LSB_PATH}/bin/lsbcc) + +if (${CMAKE_VERSION} VERSION_LESS "3.6.0") + CMAKE_FORCE_CXX_COMPILER(${LSB_PATH}/bin/lsbc++ GNU) +else() + SET(CMAKE_CXX_COMPILER ${LSB_PATH}/bin/lsbc++) +endif() + +# here is the target environment located +SET(CMAKE_FIND_ROOT_PATH ${LSB_PATH}) + +# adjust the default behaviour of the FIND_XXX() commands: +# search headers and libraries in the target environment, search +# programs in the host environment +SET(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) +SET(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY NEVER) +SET(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE NEVER) + +SET(CMAKE_CROSSCOMPILING OFF) + + +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} --lsb-target-version=${LSB_TARGET_VERSION} -I${LSB_PATH}/include" CACHE INTERNAL "" FORCE) +SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --lsb-target-version=${LSB_TARGET_VERSION} -nostdinc++ -I${LSB_PATH}/include -I${LSB_PATH}/include/c++ -I${LSB_PATH}/include/c++/backward" CACHE INTERNAL "" FORCE) +SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} --lsb-target-version=${LSB_TARGET_VERSION} -L${LSB_LIBPATH} --lsb-besteffort" CACHE INTERNAL "" FORCE) +SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --lsb-target-version=${LSB_TARGET_VERSION} -L${LSB_LIBPATH} --lsb-besteffort" CACHE INTERNAL "" FORCE) + +if (NOT "${LSB_CXX}" STREQUAL "") + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --lsb-cxx=${LSB_CXX}") + SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} --lsb-cxx=${LSB_CXX}") + SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --lsb-cxx=${LSB_CXX}") +endif() + +if (NOT "${LSB_CC}" STREQUAL "") + SET(CMAKE_C_FLAGS "${CMAKE_CC_FLAGS} --lsb-cc=${LSB_CC}") + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --lsb-cc=${LSB_CC}") + SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} --lsb-cc=${LSB_CC}") + SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --lsb-cc=${LSB_CC}") +endif() + diff --git a/Resources/Orthanc/Toolchains/MinGW-W64-Toolchain32.cmake b/Resources/Orthanc/Toolchains/MinGW-W64-Toolchain32.cmake new file mode 100644 index 0000000..61ae88f --- /dev/null +++ b/Resources/Orthanc/Toolchains/MinGW-W64-Toolchain32.cmake @@ -0,0 +1,39 @@ +# Orthanc - A Lightweight, RESTful DICOM Store +# Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics +# Department, University Hospital of Liege, Belgium +# Copyright (C) 2017-2023 Osimis S.A., Belgium +# Copyright (C) 2024-2024 Orthanc Team SRL, Belgium +# Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium +# +# This program is free software: you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public License +# as published by the Free Software Foundation, either version 3 of +# the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this program. If not, see +# . + + +# the name of the target operating system +set(CMAKE_SYSTEM_NAME Windows) + +# which compilers to use for C and C++ +set(CMAKE_C_COMPILER i686-w64-mingw32-gcc) +set(CMAKE_CXX_COMPILER i686-w64-mingw32-g++) +set(CMAKE_RC_COMPILER i686-w64-mingw32-windres) + +# here is the target environment located +set(CMAKE_FIND_ROOT_PATH /usr/i686-w64-mingw32) + +# adjust the default behaviour of the FIND_XXX() commands: +# search headers and libraries in the target environment, search +# programs in the host environment +set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) +set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) diff --git a/Resources/Orthanc/Toolchains/MinGW-W64-Toolchain64.cmake b/Resources/Orthanc/Toolchains/MinGW-W64-Toolchain64.cmake new file mode 100644 index 0000000..888ac6f --- /dev/null +++ b/Resources/Orthanc/Toolchains/MinGW-W64-Toolchain64.cmake @@ -0,0 +1,39 @@ +# Orthanc - A Lightweight, RESTful DICOM Store +# Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics +# Department, University Hospital of Liege, Belgium +# Copyright (C) 2017-2023 Osimis S.A., Belgium +# Copyright (C) 2024-2024 Orthanc Team SRL, Belgium +# Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium +# +# This program is free software: you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public License +# as published by the Free Software Foundation, either version 3 of +# the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this program. If not, see +# . + + +# the name of the target operating system +set(CMAKE_SYSTEM_NAME Windows) + +# which compilers to use for C and C++ +set(CMAKE_C_COMPILER x86_64-w64-mingw32-gcc) +set(CMAKE_CXX_COMPILER x86_64-w64-mingw32-g++) +set(CMAKE_RC_COMPILER x86_64-w64-mingw32-windres) + +# here is the target environment located +set(CMAKE_FIND_ROOT_PATH /usr/i686-w64-mingw32) + +# adjust the default behaviour of the FIND_XXX() commands: +# search headers and libraries in the target environment, search +# programs in the host environment +set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) +set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) diff --git a/Resources/Orthanc/Toolchains/MinGWToolchain.cmake b/Resources/Orthanc/Toolchains/MinGWToolchain.cmake new file mode 100644 index 0000000..b98ecdf --- /dev/null +++ b/Resources/Orthanc/Toolchains/MinGWToolchain.cmake @@ -0,0 +1,42 @@ +# Orthanc - A Lightweight, RESTful DICOM Store +# Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics +# Department, University Hospital of Liege, Belgium +# Copyright (C) 2017-2023 Osimis S.A., Belgium +# Copyright (C) 2024-2024 Orthanc Team SRL, Belgium +# Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium +# +# This program is free software: you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public License +# as published by the Free Software Foundation, either version 3 of +# the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this program. If not, see +# . + + +# the name of the target operating system +set(CMAKE_SYSTEM_NAME Windows) + +# which compilers to use for C and C++ +set(CMAKE_C_COMPILER i586-mingw32msvc-gcc) +set(CMAKE_CXX_COMPILER i586-mingw32msvc-g++) +set(CMAKE_RC_COMPILER i586-mingw32msvc-windres) + +# here is the target environment located +set(CMAKE_FIND_ROOT_PATH /usr/i586-mingw32msvc) + +# adjust the default behaviour of the FIND_XXX() commands: +# search headers and libraries in the target environment, search +# programs in the host environment +set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) +set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) + +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DSTACK_SIZE_PARAM_IS_A_RESERVATION=0x10000" CACHE INTERNAL "" FORCE) +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DSTACK_SIZE_PARAM_IS_A_RESERVATION=0x10000" CACHE INTERNAL "" FORCE) diff --git a/Resources/SyncOrthancFolder.py b/Resources/SyncOrthancFolder.py new file mode 100644 index 0000000..abf50dc --- /dev/null +++ b/Resources/SyncOrthancFolder.py @@ -0,0 +1,78 @@ +#!/usr/bin/python3 + +# +# This maintenance script updates the content of the "Orthanc" folder +# to match the latest version of the Orthanc source code. +# + +import multiprocessing +import os +import stat +import urllib.request + +TARGET = os.path.join(os.path.dirname(__file__), 'Orthanc') +PLUGIN_SDK_VERSION = '1.11.2' +REPOSITORY = 'https://orthanc.uclouvain.be/hg/orthanc/raw-file' + +FILES = [ + ('OrthancFramework/Resources/CMake/AutoGeneratedCode.cmake', 'CMake'), + ('OrthancFramework/Resources/CMake/Compiler.cmake', 'CMake'), + ('OrthancFramework/Resources/CMake/DownloadOrthancFramework.cmake', 'CMake'), + ('OrthancFramework/Resources/CMake/DownloadPackage.cmake', 'CMake'), + ('OrthancFramework/Resources/CMake/GoogleTestConfiguration.cmake', 'CMake'), + ('OrthancFramework/Resources/EmbedResources.py', 'CMake'), + ('OrthancFramework/Resources/Toolchains/LinuxStandardBaseToolchain.cmake', 'Toolchains'), + ('OrthancFramework/Resources/Toolchains/MinGW-W64-Toolchain32.cmake', 'Toolchains'), + ('OrthancFramework/Resources/Toolchains/MinGW-W64-Toolchain64.cmake', 'Toolchains'), + ('OrthancFramework/Resources/Toolchains/MinGWToolchain.cmake', 'Toolchains'), + ('OrthancServer/Plugins/Samples/Common/ExportedSymbolsPlugins.list', 'Plugins'), + ('OrthancServer/Plugins/Samples/Common/OrthancPluginCppWrapper.cpp', 'Plugins'), + ('OrthancServer/Plugins/Samples/Common/OrthancPluginCppWrapper.h', 'Plugins'), + ('OrthancServer/Plugins/Samples/Common/OrthancPluginException.h', 'Plugins'), + ('OrthancServer/Plugins/Samples/Common/OrthancPluginsExports.cmake', 'Plugins'), + ('OrthancServer/Plugins/Samples/Common/VersionScriptPlugins.map', 'Plugins'), +] + +SDK = [ + 'orthanc/OrthancCPlugin.h', +] + + +def Download(x): + branch = x[0] + source = x[1] + target = os.path.join(TARGET, x[2]) + print(target) + + try: + os.makedirs(os.path.dirname(target)) + except: + pass + + url = '%s/%s/%s' % (REPOSITORY, branch, source) + + with open(target, 'wb') as f: + try: + f.write(urllib.request.urlopen(url).read()) + except: + print('ERROR %s' % url) + raise + + +commands = [] + +for f in FILES: + commands.append([ 'default', + f[0], + os.path.join(f[1], os.path.basename(f[0])) ]) + +for f in SDK: + commands.append([ + 'Orthanc-%s' % PLUGIN_SDK_VERSION, + 'OrthancServer/Plugins/Include/%s' % f, + 'Sdk-%s/%s' % (PLUGIN_SDK_VERSION, f) + ]) + + +pool = multiprocessing.Pool(10) # simultaneous downloads +pool.map(Download, commands) diff --git a/TODO b/TODO new file mode 100644 index 0000000..19f7949 --- /dev/null +++ b/TODO @@ -0,0 +1,98 @@ +- implement pagination to fetch studies 100 -> 200 when we scroll to the end of the study-list +- implement pagination to fetch instances 100 -> 200 when we scroll to the end of the instance-list (displaying 2000 instances in one go sometimes takes 10 seconds !) + + +- add a "reset" button (on Windows, to reload the config after you have changed it without going to the Services -> Orthanc -> Restart) +- show ohif-vr and ohif-tmtv buttons only when relevant (analyse the content of the study) + +- predefined filters in config file to display below Studies: + - "Today": {"StudyDate": "$today"} + - "CT Last month": {"ModalitiesInStudy": "CT", "StudyDate": "$oneMonthAgo-"} + predefined keywords: $today, $yesterday, $oneWeekAgo, $oneMonthAgo, $oneYearAgo + +UI improvements: +- Admin theme including responsive tables (including multiline): https://github.com/lekoala/admini +- tags: https://github.com/lekoala/bootstrap5-tags +- when opening the series view I would prefer to see an image and it’s labels over a list of instance numbers and paired SOPInstanceUIDs: + https://discourse.orthanc-server.org/t/beginner-questions-from-horos-user/5322 + +- modification: + - configuration to hide DICOM UID options and select the right one directly for a given setup. + - add a Series Description renamer (one dialog to edit SeriesNumber + SeriesDescription of a study) + +- settings: + - show the list of /tools/accepted-transfer-syntaxes + - show the list of /tools/accepted-sop-classes (in 1.12.6) + +- show attachments + +- support neuro plugin (download nifti) + +- TagsTree: allow click on "null" tags to open /instances/../content/group,element in new window + +- show job details (need improvement in Orthanc API itself) +- include an "all jobs" panel and not only our jobs (https://discourse.orthanc-server.org/t/oe2-inclusion-of-jobs-panel-in-explorer-2/3708) + +- list last studies received (through DICOM or upload) + +- UI customization: + - add custom actions per study/series/instances: + - configuration suggestion: + { + "CustomButtons": [ + { + "Name": "Process study", // the text will appear in the button tooltip + "Icon": "bi bi-glass", + "Level": "Study", + "ActionUrl": "../../my-python-plugin/my-route", // this route can be templated with e.g: ../../my-python-plugin/my-route?StudyInstanceUID=$resource-dicom-id$&orthanc-id=$resource-orthanc-id$&level=$resource-level$" + "ActionMethod": "POST", + "ActionPostPayloadTemplate": { + "dicom-id": "$resource-dicom-id$", + "orthanc-id": "$resource-orthanc-id$" + } + "EnabledUrl": "../../my-python-plugin/my-route-enabled", // optional: a GET route that returns true/false if the custom button must be enabled/disabled for this resource. It shall be templated as well + + } + ] + } + - configure other viewers url (ex: radiant://?n=pstv&v=0020000D&v=%22StudyInstanceUID%22 or osirix or horos ...) + +- orthanc-share should generate QR code with publication links + +- Q&R on multiple modalities at a same time (select the modalities you want to Q&R and display the modality in the study list) + (same with Q&R for dicom-web and peers) + +- in local study list, display the number of studies that are present on a remote modality for this patient (e.g: a cold archive) + - Add a button to fetch all these data (todo: find a way to delete them after a while ?) + - same with dicom-web and peers ? + + +Configuration management (ideas + implementation notes): +------------------------------- + +- allow Orthanc to store anything in Global Properties. Maybe not through the API but only through the SDK. + Or, only for an "admin" user ? + +- Edit configuration through the oe2 UI: + - Some immutable configuration in a config file: + - DB + storage + - Admin user ! + - HttpPort + - Check if we could store a config in Global Properties (probably too early in the Orthanc init process). We would merge the file config with the config in DB + - Otherwise, store the config in a file and restart Orthanc + -> in Windows Service: how to tell Orthanc to use another config file ? + -> would be nice to have a SDK route to implement /tools/reboot with a given config file + - Could be a combination of 2: + - start Orthanc with config from file + - plugin reads the config in DB, generates a tmp config file -> /tools/reboot with this file + - that's a bit "shaky" since each cold start is made of 2 starts + +Ideas bag: +********* + +- allow users to choose the columns in the interface (store in browser LocalStorage ?) +- browse orthanc peer (probably need to extend the Orthanc API to avoid CORS issues) +- show statistics/event logs: e.g: would be nice to see how many instances + have been received recently (from where) +- add a button to export a whole series to jpeg (Chamrousse): we could reuse [this python code](https://orthanc.uclouvain.be/book/plugins/python.html#generating-a-mosaic-for-a-dicom-series) and trigger it from a [custom button](https://github.com/orthanc-server/orthanc-explorer-2/issues/18) (once we have implemented them !!!) +- add a text editor to associate a radiology report or note with a study, storing it as an attachment (cf. https://discourse.orthanc-server.org/t/oe2-inclusion-of-reporting-note/) diff --git a/WebApplication/index.html b/WebApplication/index.html new file mode 100644 index 0000000..624e575 --- /dev/null +++ b/WebApplication/index.html @@ -0,0 +1,24 @@ + + + + + + + ... + + + +
+ + + diff --git a/WebApplication/package-lock.json b/WebApplication/package-lock.json new file mode 100644 index 0000000..fcda460 --- /dev/null +++ b/WebApplication/package-lock.json @@ -0,0 +1,1341 @@ +{ + "name": "orthanc-explorer-2", + "version": "0.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "orthanc-explorer-2", + "version": "0.0.0", + "dependencies": { + "@fortawesome/fontawesome-free": "^6.5.1", + "@popperjs/core": "^2.11.8", + "@vuepic/vue-datepicker": "^8.3.1", + "axios": "^1.7.4", + "bootstrap": "5.3.3", + "bootstrap-icons": "^1.11.3", + "bootstrap5-tags": "^1.7.2", + "jquery": "^3.7.1", + "keycloak-js": "^24.0.5", + "mitt": "^3.0.1", + "uppie": "^4.0.0", + "uuid": "^9.0.1", + "vue": "^3.4.21", + "vue-i18n": "^9.10.2", + "vue-router": "^4.3.0", + "vue3-observe-visibility": "^1.0.2", + "vuex": "^4.1.0" + }, + "devDependencies": { + "@vitejs/plugin-vue": "^5.0.4", + "vite": "^5.4.8" + } + }, + "node_modules/@babel/helper-string-parser": { + "version": "7.24.8", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.24.8.tgz", + "integrity": "sha512-pO9KhhRcuUyGnJWwyEgnRJTSIZHiT+vMD0kPeD+so0l7mxkMT19g3pjY9GTnHySck/hDzq+dtW/4VgnMkippsQ==", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.24.7", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.24.7.tgz", + "integrity": "sha512-rR+PBcQ1SMQDDyF6X0wxtG8QyLCgUB0eRAGguqRLfkCA87l7yAP7ehq8SNj96OOGTO8OBV70KhuFYcIkHXOg0w==", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/parser": { + "version": "7.25.6", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.25.6.tgz", + "integrity": "sha512-trGdfBdbD0l1ZPmcJ83eNxB9rbEax4ALFTF7fN386TMYbeCQbyme5cOEXQhbGXKebwGaB/J52w1mrklMcbgy6Q==", + "dependencies": { + "@babel/types": "^7.25.6" + }, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/types": { + "version": "7.25.6", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.25.6.tgz", + "integrity": "sha512-/l42B1qxpG6RdfYf343Uw1vmDjeNhneUXtzhojE7pDgfpEypmRhI6j1kr17XCVv4Cgl9HdAiQY2x0GwKm7rWCw==", + "dependencies": { + "@babel/helper-string-parser": "^7.24.8", + "@babel/helper-validator-identifier": "^7.24.7", + "to-fast-properties": "^2.0.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz", + "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz", + "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz", + "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz", + "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz", + "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz", + "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz", + "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz", + "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz", + "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz", + "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz", + "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==", + "cpu": [ + "ia32" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz", + "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==", + "cpu": [ + "loong64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz", + "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==", + "cpu": [ + "mips64el" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz", + "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==", + "cpu": [ + "ppc64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz", + "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==", + "cpu": [ + "riscv64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz", + "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==", + "cpu": [ + "s390x" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz", + "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz", + "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz", + "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz", + "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz", + "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz", + "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==", + "cpu": [ + "ia32" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz", + "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@fortawesome/fontawesome-free": { + "version": "6.6.0", + "resolved": "https://registry.npmjs.org/@fortawesome/fontawesome-free/-/fontawesome-free-6.6.0.tgz", + "integrity": "sha512-60G28ke/sXdtS9KZCpZSHHkCbdsOGEhIUGlwq6yhY74UpTiToIh8np7A8yphhM4BWsvNFtIvLpi4co+h9Mr9Ow==", + "engines": { + "node": ">=6" + } + }, + "node_modules/@intlify/core-base": { + "version": "9.14.2", + "resolved": "https://registry.npmjs.org/@intlify/core-base/-/core-base-9.14.2.tgz", + "integrity": "sha512-DZyQ4Hk22sC81MP4qiCDuU+LdaYW91A6lCjq8AWPvY3+mGMzhGDfOCzvyR6YBQxtlPjFqMoFk9ylnNYRAQwXtQ==", + "dependencies": { + "@intlify/message-compiler": "9.14.2", + "@intlify/shared": "9.14.2" + }, + "engines": { + "node": ">= 16" + }, + "funding": { + "url": "https://github.com/sponsors/kazupon" + } + }, + "node_modules/@intlify/message-compiler": { + "version": "9.14.2", + "resolved": "https://registry.npmjs.org/@intlify/message-compiler/-/message-compiler-9.14.2.tgz", + "integrity": "sha512-YsKKuV4Qv4wrLNsvgWbTf0E40uRv+Qiw1BeLQ0LAxifQuhiMe+hfTIzOMdWj/ZpnTDj4RSZtkXjJM7JDiiB5LQ==", + "dependencies": { + "@intlify/shared": "9.14.2", + "source-map-js": "^1.0.2" + }, + "engines": { + "node": ">= 16" + }, + "funding": { + "url": "https://github.com/sponsors/kazupon" + } + }, + "node_modules/@intlify/shared": { + "version": "9.14.2", + "resolved": "https://registry.npmjs.org/@intlify/shared/-/shared-9.14.2.tgz", + "integrity": "sha512-uRAHAxYPeF+G5DBIboKpPgC/Waecd4Jz8ihtkpJQD5ycb5PwXp0k/+hBGl5dAjwF7w+l74kz/PKA8r8OK//RUw==", + "engines": { + "node": ">= 16" + }, + "funding": { + "url": "https://github.com/sponsors/kazupon" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz", + "integrity": "sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==" + }, + "node_modules/@popperjs/core": { + "version": "2.11.8", + "resolved": "https://registry.npmjs.org/@popperjs/core/-/core-2.11.8.tgz", + "integrity": "sha512-P1st0aksCrn9sGZhp8GMYwBnQsbvAWsZAX44oXNNvLHGqAOcoVxmjZiohstwQ7SqKnbR47akdNi+uleWD8+g6A==", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/popperjs" + } + }, + "node_modules/@rollup/rollup-android-arm-eabi": { + "version": "4.23.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.23.0.tgz", + "integrity": "sha512-8OR+Ok3SGEMsAZispLx8jruuXw0HVF16k+ub2eNXKHDmdxL4cf9NlNpAzhlOhNyXzKDEJuFeq0nZm+XlNb1IFw==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-android-arm64": { + "version": "4.23.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.23.0.tgz", + "integrity": "sha512-rEFtX1nP8gqmLmPZsXRMoLVNB5JBwOzIAk/XAcEPuKrPa2nPJ+DuGGpfQUR0XjRm8KjHfTZLpWbKXkA5BoFL3w==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-darwin-arm64": { + "version": "4.23.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.23.0.tgz", + "integrity": "sha512-ZbqlMkJRMMPeapfaU4drYHns7Q5MIxjM/QeOO62qQZGPh9XWziap+NF9fsqPHT0KzEL6HaPspC7sOwpgyA3J9g==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-darwin-x64": { + "version": "4.23.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.23.0.tgz", + "integrity": "sha512-PfmgQp78xx5rBCgn2oYPQ1rQTtOaQCna0kRaBlc5w7RlA3TDGGo7m3XaptgitUZ54US9915i7KeVPHoy3/W8tA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.23.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.23.0.tgz", + "integrity": "sha512-WAeZfAAPus56eQgBioezXRRzArAjWJGjNo/M+BHZygUcs9EePIuGI1Wfc6U/Ki+tMW17FFGvhCfYnfcKPh18SA==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm-musleabihf": { + "version": "4.23.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.23.0.tgz", + "integrity": "sha512-v7PGcp1O5XKZxKX8phTXtmJDVpE20Ub1eF6w9iMmI3qrrPak6yR9/5eeq7ziLMrMTjppkkskXyxnmm00HdtXjA==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-gnu": { + "version": "4.23.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.23.0.tgz", + "integrity": "sha512-nAbWsDZ9UkU6xQiXEyXBNHAKbzSAi95H3gTStJq9UGiS1v+YVXwRHcQOQEF/3CHuhX5BVhShKoeOf6Q/1M+Zhg==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-musl": { + "version": "4.23.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.23.0.tgz", + "integrity": "sha512-5QT/Di5FbGNPaVw8hHO1wETunwkPuZBIu6W+5GNArlKHD9fkMHy7vS8zGHJk38oObXfWdsuLMogD4sBySLJ54g==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-powerpc64le-gnu": { + "version": "4.23.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.23.0.tgz", + "integrity": "sha512-Sefl6vPyn5axzCsO13r1sHLcmPuiSOrKIImnq34CBurntcJ+lkQgAaTt/9JkgGmaZJ+OkaHmAJl4Bfd0DmdtOQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-gnu": { + "version": "4.23.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.23.0.tgz", + "integrity": "sha512-o4QI2KU/QbP7ZExMse6ULotdV3oJUYMrdx3rBZCgUF3ur3gJPfe8Fuasn6tia16c5kZBBw0aTmaUygad6VB/hQ==", + "cpu": [ + "riscv64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-s390x-gnu": { + "version": "4.23.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.23.0.tgz", + "integrity": "sha512-+bxqx+V/D4FGrpXzPGKp/SEZIZ8cIW3K7wOtcJAoCrmXvzRtmdUhYNbgd+RztLzfDEfA2WtKj5F4tcbNPuqgeg==", + "cpu": [ + "s390x" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.23.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.23.0.tgz", + "integrity": "sha512-I/eXsdVoCKtSgK9OwyQKPAfricWKUMNCwJKtatRYMmDo5N859tbO3UsBw5kT3dU1n6ZcM1JDzPRSGhAUkxfLxw==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.23.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.23.0.tgz", + "integrity": "sha512-4ZoDZy5ShLbbe1KPSafbFh1vbl0asTVfkABC7eWqIs01+66ncM82YJxV2VtV3YVJTqq2P8HMx3DCoRSWB/N3rw==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.23.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.23.0.tgz", + "integrity": "sha512-+5Ky8dhft4STaOEbZu3/NU4QIyYssKO+r1cD3FzuusA0vO5gso15on7qGzKdNXnc1gOrsgCqZjRw1w+zL4y4hQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.23.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.23.0.tgz", + "integrity": "sha512-0SPJk4cPZQhq9qA1UhIRumSE3+JJIBBjtlGl5PNC///BoaByckNZd53rOYD0glpTkYFBQSt7AkMeLVPfx65+BQ==", + "cpu": [ + "ia32" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.23.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.23.0.tgz", + "integrity": "sha512-lqCK5GQC8fNo0+JvTSxcG7YB1UKYp8yrNLhsArlvPWN+16ovSZgoehlVHg6X0sSWPUkpjRBR5TuR12ZugowZ4g==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@types/estree": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.6.tgz", + "integrity": "sha512-AYnb1nQyY49te+VRAVgmzfcgjYS91mY5P0TKUDCLEM+gNnA+3T6rWITXRLYCpahpqSQbN5cE+gHpnPyXjHWxcw==", + "dev": true + }, + "node_modules/@vitejs/plugin-vue": { + "version": "5.1.4", + "resolved": "https://registry.npmjs.org/@vitejs/plugin-vue/-/plugin-vue-5.1.4.tgz", + "integrity": "sha512-N2XSI2n3sQqp5w7Y/AN/L2XDjBIRGqXko+eDp42sydYSBeJuSm5a1sLf8zakmo8u7tA8NmBgoDLA1HeOESjp9A==", + "dev": true, + "engines": { + "node": "^18.0.0 || >=20.0.0" + }, + "peerDependencies": { + "vite": "^5.0.0", + "vue": "^3.2.25" + } + }, + "node_modules/@vue/compiler-core": { + "version": "3.5.10", + "resolved": "https://registry.npmjs.org/@vue/compiler-core/-/compiler-core-3.5.10.tgz", + "integrity": "sha512-iXWlk+Cg/ag7gLvY0SfVucU8Kh2CjysYZjhhP70w9qI4MvSox4frrP+vDGvtQuzIcgD8+sxM6lZvCtdxGunTAA==", + "dependencies": { + "@babel/parser": "^7.25.3", + "@vue/shared": "3.5.10", + "entities": "^4.5.0", + "estree-walker": "^2.0.2", + "source-map-js": "^1.2.0" + } + }, + "node_modules/@vue/compiler-dom": { + "version": "3.5.10", + "resolved": "https://registry.npmjs.org/@vue/compiler-dom/-/compiler-dom-3.5.10.tgz", + "integrity": "sha512-DyxHC6qPcktwYGKOIy3XqnHRrrXyWR2u91AjP+nLkADko380srsC2DC3s7Y1Rk6YfOlxOlvEQKa9XXmLI+W4ZA==", + "dependencies": { + "@vue/compiler-core": "3.5.10", + "@vue/shared": "3.5.10" + } + }, + "node_modules/@vue/compiler-sfc": { + "version": "3.5.10", + "resolved": "https://registry.npmjs.org/@vue/compiler-sfc/-/compiler-sfc-3.5.10.tgz", + "integrity": "sha512-to8E1BgpakV7224ZCm8gz1ZRSyjNCAWEplwFMWKlzCdP9DkMKhRRwt0WkCjY7jkzi/Vz3xgbpeig5Pnbly4Tow==", + "dependencies": { + "@babel/parser": "^7.25.3", + "@vue/compiler-core": "3.5.10", + "@vue/compiler-dom": "3.5.10", + "@vue/compiler-ssr": "3.5.10", + "@vue/shared": "3.5.10", + "estree-walker": "^2.0.2", + "magic-string": "^0.30.11", + "postcss": "^8.4.47", + "source-map-js": "^1.2.0" + } + }, + "node_modules/@vue/compiler-ssr": { + "version": "3.5.10", + "resolved": "https://registry.npmjs.org/@vue/compiler-ssr/-/compiler-ssr-3.5.10.tgz", + "integrity": "sha512-hxP4Y3KImqdtyUKXDRSxKSRkSm1H9fCvhojEYrnaoWhE4w/y8vwWhnosJoPPe2AXm5sU7CSbYYAgkt2ZPhDz+A==", + "dependencies": { + "@vue/compiler-dom": "3.5.10", + "@vue/shared": "3.5.10" + } + }, + "node_modules/@vue/devtools-api": { + "version": "6.6.4", + "resolved": "https://registry.npmjs.org/@vue/devtools-api/-/devtools-api-6.6.4.tgz", + "integrity": "sha512-sGhTPMuXqZ1rVOk32RylztWkfXTRhuS7vgAKv0zjqk8gbsHkJ7xfFf+jbySxt7tWObEJwyKaHMikV/WGDiQm8g==" + }, + "node_modules/@vue/reactivity": { + "version": "3.5.10", + "resolved": "https://registry.npmjs.org/@vue/reactivity/-/reactivity-3.5.10.tgz", + "integrity": "sha512-kW08v06F6xPSHhid9DJ9YjOGmwNDOsJJQk0ax21wKaUYzzuJGEuoKNU2Ujux8FLMrP7CFJJKsHhXN9l2WOVi2g==", + "dependencies": { + "@vue/shared": "3.5.10" + } + }, + "node_modules/@vue/runtime-core": { + "version": "3.5.10", + "resolved": "https://registry.npmjs.org/@vue/runtime-core/-/runtime-core-3.5.10.tgz", + "integrity": "sha512-9Q86I5Qq3swSkFfzrZ+iqEy7Vla325M7S7xc1NwKnRm/qoi1Dauz0rT6mTMmscqx4qz0EDJ1wjB+A36k7rl8mA==", + "dependencies": { + "@vue/reactivity": "3.5.10", + "@vue/shared": "3.5.10" + } + }, + "node_modules/@vue/runtime-dom": { + "version": "3.5.10", + "resolved": "https://registry.npmjs.org/@vue/runtime-dom/-/runtime-dom-3.5.10.tgz", + "integrity": "sha512-t3x7ht5qF8ZRi1H4fZqFzyY2j+GTMTDxRheT+i8M9Ph0oepUxoadmbwlFwMoW7RYCpNQLpP2Yx3feKs+fyBdpA==", + "dependencies": { + "@vue/reactivity": "3.5.10", + "@vue/runtime-core": "3.5.10", + "@vue/shared": "3.5.10", + "csstype": "^3.1.3" + } + }, + "node_modules/@vue/server-renderer": { + "version": "3.5.10", + "resolved": "https://registry.npmjs.org/@vue/server-renderer/-/server-renderer-3.5.10.tgz", + "integrity": "sha512-IVE97tt2kGKwHNq9yVO0xdh1IvYfZCShvDSy46JIh5OQxP1/EXSpoDqetVmyIzL7CYOWnnmMkVqd7YK2QSWkdw==", + "dependencies": { + "@vue/compiler-ssr": "3.5.10", + "@vue/shared": "3.5.10" + }, + "peerDependencies": { + "vue": "3.5.10" + } + }, + "node_modules/@vue/shared": { + "version": "3.5.10", + "resolved": "https://registry.npmjs.org/@vue/shared/-/shared-3.5.10.tgz", + "integrity": "sha512-VkkBhU97Ki+XJ0xvl4C9YJsIZ2uIlQ7HqPpZOS3m9VCvmROPaChZU6DexdMJqvz9tbgG+4EtFVrSuailUq5KGQ==" + }, + "node_modules/@vuepic/vue-datepicker": { + "version": "8.8.1", + "resolved": "https://registry.npmjs.org/@vuepic/vue-datepicker/-/vue-datepicker-8.8.1.tgz", + "integrity": "sha512-8ehfUz1m69Vuc16Pm4ukgb3Mg1VT14x4EsG1ag4O/qbSNRWztTo+pUV4JnFt0FGLl5gGb6NXlxIvR7EjLgD7Gg==", + "dependencies": { + "date-fns": "^3.6.0" + }, + "peerDependencies": { + "vue": ">=3.2.0" + } + }, + "node_modules/asynckit": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", + "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==" + }, + "node_modules/axios": { + "version": "1.7.7", + "resolved": "https://registry.npmjs.org/axios/-/axios-1.7.7.tgz", + "integrity": "sha512-S4kL7XrjgBmvdGut0sN3yJxqYzrDOnivkBiN0OFs6hLiUam3UPvswUo0kqGyhqUZGEOytHyumEdXsAkgCOUf3Q==", + "dependencies": { + "follow-redirects": "^1.15.6", + "form-data": "^4.0.0", + "proxy-from-env": "^1.1.0" + } + }, + "node_modules/bootstrap": { + "version": "5.3.3", + "resolved": "https://registry.npmjs.org/bootstrap/-/bootstrap-5.3.3.tgz", + "integrity": "sha512-8HLCdWgyoMguSO9o+aH+iuZ+aht+mzW0u3HIMzVu7Srrpv7EBBxTnrFlSCskwdY1+EOFQSm7uMJhNQHkdPcmjg==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/twbs" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/bootstrap" + } + ], + "peerDependencies": { + "@popperjs/core": "^2.11.8" + } + }, + "node_modules/bootstrap-icons": { + "version": "1.11.3", + "resolved": "https://registry.npmjs.org/bootstrap-icons/-/bootstrap-icons-1.11.3.tgz", + "integrity": "sha512-+3lpHrCw/it2/7lBL15VR0HEumaBss0+f/Lb6ZvHISn1mlK83jjFpooTLsMWbIjJMDjDjOExMsTxnXSIT4k4ww==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/twbs" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/bootstrap" + } + ] + }, + "node_modules/bootstrap5-tags": { + "version": "1.7.5", + "resolved": "https://registry.npmjs.org/bootstrap5-tags/-/bootstrap5-tags-1.7.5.tgz", + "integrity": "sha512-EqCpdjD/UdZVYdlgcWfQKU68x7AtUs3lSnl9/u1xW2kVc193nqE4QOyJ5fAvc4i4t365LerRG87kptMpsD1PlQ==" + }, + "node_modules/combined-stream": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz", + "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==", + "dependencies": { + "delayed-stream": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/csstype": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz", + "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==" + }, + "node_modules/date-fns": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/date-fns/-/date-fns-3.6.0.tgz", + "integrity": "sha512-fRHTG8g/Gif+kSh50gaGEdToemgfj74aRX3swtiouboip5JDLAyDE9F11nHMIcvOaXeOC6D7SpNhi7uFyB7Uww==", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/kossnocorp" + } + }, + "node_modules/delayed-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", + "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==", + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/entities": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz", + "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==", + "engines": { + "node": ">=0.12" + }, + "funding": { + "url": "https://github.com/fb55/entities?sponsor=1" + } + }, + "node_modules/esbuild": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz", + "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==", + "dev": true, + "hasInstallScript": true, + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=12" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.21.5", + "@esbuild/android-arm": "0.21.5", + "@esbuild/android-arm64": "0.21.5", + "@esbuild/android-x64": "0.21.5", + "@esbuild/darwin-arm64": "0.21.5", + "@esbuild/darwin-x64": "0.21.5", + "@esbuild/freebsd-arm64": "0.21.5", + "@esbuild/freebsd-x64": "0.21.5", + "@esbuild/linux-arm": "0.21.5", + "@esbuild/linux-arm64": "0.21.5", + "@esbuild/linux-ia32": "0.21.5", + "@esbuild/linux-loong64": "0.21.5", + "@esbuild/linux-mips64el": "0.21.5", + "@esbuild/linux-ppc64": "0.21.5", + "@esbuild/linux-riscv64": "0.21.5", + "@esbuild/linux-s390x": "0.21.5", + "@esbuild/linux-x64": "0.21.5", + "@esbuild/netbsd-x64": "0.21.5", + "@esbuild/openbsd-x64": "0.21.5", + "@esbuild/sunos-x64": "0.21.5", + "@esbuild/win32-arm64": "0.21.5", + "@esbuild/win32-ia32": "0.21.5", + "@esbuild/win32-x64": "0.21.5" + } + }, + "node_modules/estree-walker": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz", + "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==" + }, + "node_modules/follow-redirects": { + "version": "1.15.9", + "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.9.tgz", + "integrity": "sha512-gew4GsXizNgdoRyqmyfMHyAmXsZDk6mHkSxZFCzW9gwlbtOW44CDtYavM+y+72qD/Vq2l550kMF52DT8fOLJqQ==", + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/RubenVerborgh" + } + ], + "engines": { + "node": ">=4.0" + }, + "peerDependenciesMeta": { + "debug": { + "optional": true + } + } + }, + "node_modules/form-data": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.0.tgz", + "integrity": "sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==", + "dependencies": { + "asynckit": "^0.4.0", + "combined-stream": "^1.0.8", + "mime-types": "^2.1.12" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/jquery": { + "version": "3.7.1", + "resolved": "https://registry.npmjs.org/jquery/-/jquery-3.7.1.tgz", + "integrity": "sha512-m4avr8yL8kmFN8psrbFFFmB/If14iN5o9nw/NgnnM+kybDJpRsAynV2BsfpTYrTRysYUdADVD7CkUUizgkpLfg==" + }, + "node_modules/js-sha256": { + "version": "0.11.0", + "resolved": "https://registry.npmjs.org/js-sha256/-/js-sha256-0.11.0.tgz", + "integrity": "sha512-6xNlKayMZvds9h1Y1VWc0fQHQ82BxTXizWPEtEeGvmOUYpBRy4gbWroHLpzowe6xiQhHpelCQiE7HEdznyBL9Q==" + }, + "node_modules/jwt-decode": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/jwt-decode/-/jwt-decode-4.0.0.tgz", + "integrity": "sha512-+KJGIyHgkGuIq3IEBNftfhW/LfWhXUIY6OmyVWjliu5KH1y0fw7VQ8YndE2O4qZdMSd9SqbnC8GOcZEy0Om7sA==", + "engines": { + "node": ">=18" + } + }, + "node_modules/keycloak-js": { + "version": "24.0.5", + "resolved": "https://registry.npmjs.org/keycloak-js/-/keycloak-js-24.0.5.tgz", + "integrity": "sha512-VQOSn3j13DPB6OuavKAq+sRjDERhIKrXgBzekoHRstifPuyULILguugX6yxRUYFSpn3OMYUXmSX++tkdCupOjA==", + "dependencies": { + "js-sha256": "^0.11.0", + "jwt-decode": "^4.0.0" + } + }, + "node_modules/magic-string": { + "version": "0.30.11", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.11.tgz", + "integrity": "sha512-+Wri9p0QHMy+545hKww7YAu5NyzF8iomPL/RQazugQ9+Ez4Ic3mERMd8ZTX5rfK944j+560ZJi8iAwgak1Ac7A==", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.0" + } + }, + "node_modules/mime-db": { + "version": "1.52.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", + "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime-types": { + "version": "2.1.35", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz", + "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==", + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mitt": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/mitt/-/mitt-3.0.1.tgz", + "integrity": "sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==" + }, + "node_modules/nanoid": { + "version": "3.3.8", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.8.tgz", + "integrity": "sha512-WNLf5Sd8oZxOm+TzppcYk8gVOgP+l58xNy58D0nbUnOxOWRWvlcCV4kUF7ltmI6PsrLl/BgKEyS4mqsGChFN0w==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/picocolors": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.0.tgz", + "integrity": "sha512-TQ92mBOW0l3LeMeyLV6mzy/kWr8lkd/hp3mTg7wYK7zJhuBStmGMBG0BdeDZS/dZx1IukaX6Bk11zcln25o1Aw==" + }, + "node_modules/postcss": { + "version": "8.4.47", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.47.tgz", + "integrity": "sha512-56rxCq7G/XfB4EkXq9Egn5GCqugWvDFjafDOThIdMBsI15iqPqR5r15TfSr1YPYeEI19YeaXMCbY6u88Y76GLQ==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "dependencies": { + "nanoid": "^3.3.7", + "picocolors": "^1.1.0", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/proxy-from-env": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz", + "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==" + }, + "node_modules/rollup": { + "version": "4.23.0", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.23.0.tgz", + "integrity": "sha512-vXB4IT9/KLDrS2WRXmY22sVB2wTsTwkpxjB8Q3mnakTENcYw3FRmfdYDy/acNmls+lHmDazgrRjK/yQ6hQAtwA==", + "dev": true, + "dependencies": { + "@types/estree": "1.0.6" + }, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "@rollup/rollup-android-arm-eabi": "4.23.0", + "@rollup/rollup-android-arm64": "4.23.0", + "@rollup/rollup-darwin-arm64": "4.23.0", + "@rollup/rollup-darwin-x64": "4.23.0", + "@rollup/rollup-linux-arm-gnueabihf": "4.23.0", + "@rollup/rollup-linux-arm-musleabihf": "4.23.0", + "@rollup/rollup-linux-arm64-gnu": "4.23.0", + "@rollup/rollup-linux-arm64-musl": "4.23.0", + "@rollup/rollup-linux-powerpc64le-gnu": "4.23.0", + "@rollup/rollup-linux-riscv64-gnu": "4.23.0", + "@rollup/rollup-linux-s390x-gnu": "4.23.0", + "@rollup/rollup-linux-x64-gnu": "4.23.0", + "@rollup/rollup-linux-x64-musl": "4.23.0", + "@rollup/rollup-win32-arm64-msvc": "4.23.0", + "@rollup/rollup-win32-ia32-msvc": "4.23.0", + "@rollup/rollup-win32-x64-msvc": "4.23.0", + "fsevents": "~2.3.2" + } + }, + "node_modules/source-map-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/to-fast-properties": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz", + "integrity": "sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==", + "engines": { + "node": ">=4" + } + }, + "node_modules/uppie": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/uppie/-/uppie-4.0.0.tgz", + "integrity": "sha512-AiV1n8tFfsNOmLDB547P1os56p6NMDsgtMBJ73BIGBlzVgvNZuqbZGMsU7OLZCeMNiSAEdBbeu9KR4TK0TpMMw==" + }, + "node_modules/uuid": { + "version": "9.0.1", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-9.0.1.tgz", + "integrity": "sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA==", + "funding": [ + "https://github.com/sponsors/broofa", + "https://github.com/sponsors/ctavan" + ], + "bin": { + "uuid": "dist/bin/uuid" + } + }, + "node_modules/vite": { + "version": "5.4.8", + "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.8.tgz", + "integrity": "sha512-FqrItQ4DT1NC4zCUqMB4c4AZORMKIa0m8/URVCZ77OZ/QSNeJ54bU1vrFADbDsuwfIPcgknRkmqakQcgnL4GiQ==", + "dev": true, + "dependencies": { + "esbuild": "^0.21.3", + "postcss": "^8.4.43", + "rollup": "^4.20.0" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^18.0.0 || >=20.0.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^18.0.0 || >=20.0.0", + "less": "*", + "lightningcss": "^1.21.0", + "sass": "*", + "sass-embedded": "*", + "stylus": "*", + "sugarss": "*", + "terser": "^5.4.0" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + } + } + }, + "node_modules/vue": { + "version": "3.5.10", + "resolved": "https://registry.npmjs.org/vue/-/vue-3.5.10.tgz", + "integrity": "sha512-Vy2kmJwHPlouC/tSnIgXVg03SG+9wSqT1xu1Vehc+ChsXsRd7jLkKgMltVEFOzUdBr3uFwBCG+41LJtfAcBRng==", + "dependencies": { + "@vue/compiler-dom": "3.5.10", + "@vue/compiler-sfc": "3.5.10", + "@vue/runtime-dom": "3.5.10", + "@vue/server-renderer": "3.5.10", + "@vue/shared": "3.5.10" + }, + "peerDependencies": { + "typescript": "*" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/vue-i18n": { + "version": "9.14.2", + "resolved": "https://registry.npmjs.org/vue-i18n/-/vue-i18n-9.14.2.tgz", + "integrity": "sha512-JK9Pm80OqssGJU2Y6F7DcM8RFHqVG4WkuCqOZTVsXkEzZME7ABejAUqUdA931zEBedc4thBgSUWxeQh4uocJAQ==", + "dependencies": { + "@intlify/core-base": "9.14.2", + "@intlify/shared": "9.14.2", + "@vue/devtools-api": "^6.5.0" + }, + "engines": { + "node": ">= 16" + }, + "funding": { + "url": "https://github.com/sponsors/kazupon" + }, + "peerDependencies": { + "vue": "^3.0.0" + } + }, + "node_modules/vue-router": { + "version": "4.4.5", + "resolved": "https://registry.npmjs.org/vue-router/-/vue-router-4.4.5.tgz", + "integrity": "sha512-4fKZygS8cH1yCyuabAXGUAsyi1b2/o/OKgu/RUb+znIYOxPRxdkytJEx+0wGcpBE1pX6vUgh5jwWOKRGvuA/7Q==", + "dependencies": { + "@vue/devtools-api": "^6.6.4" + }, + "funding": { + "url": "https://github.com/sponsors/posva" + }, + "peerDependencies": { + "vue": "^3.2.0" + } + }, + "node_modules/vue3-observe-visibility": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/vue3-observe-visibility/-/vue3-observe-visibility-1.0.2.tgz", + "integrity": "sha512-PmNmvLezogMAgwix6VPnkkrx7sj834GblvqCCDI2iySpohTQvCm1j2q89aTmyS0XzG4sWBK2Izypejf4IpNFig==", + "peerDependencies": { + "vue": "^3.x.x" + } + }, + "node_modules/vuex": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/vuex/-/vuex-4.1.0.tgz", + "integrity": "sha512-hmV6UerDrPcgbSy9ORAtNXDr9M4wlNP4pEFKye4ujJF8oqgFFuxDCdOLS3eNoRTtq5O3hoBDh9Doj1bQMYHRbQ==", + "dependencies": { + "@vue/devtools-api": "^6.0.0-beta.11" + }, + "peerDependencies": { + "vue": "^3.2.0" + } + } + } +} diff --git a/WebApplication/package.json b/WebApplication/package.json new file mode 100644 index 0000000..f1516d0 --- /dev/null +++ b/WebApplication/package.json @@ -0,0 +1,33 @@ +{ + "name": "orthanc-explorer-2", + "version": "0.0.0", + "type": "module", + "scripts": { + "dev": "vite", + "build": "vite build", + "preview": "vite preview" + }, + "dependencies": { + "@fortawesome/fontawesome-free": "^6.5.1", + "@popperjs/core": "^2.11.8", + "@vuepic/vue-datepicker": "^8.3.1", + "axios": "^1.7.4", + "bootstrap": "5.3.3", + "bootstrap-icons": "^1.11.3", + "bootstrap5-tags": "^1.7.2", + "jquery": "^3.7.1", + "keycloak-js": "^24.0.5", + "mitt": "^3.0.1", + "uppie": "^4.0.0", + "uuid": "^9.0.1", + "vue": "^3.4.21", + "vue-i18n": "^9.10.2", + "vue-router": "^4.3.0", + "vuex": "^4.1.0", + "vue3-observe-visibility": "^1.0.2" + }, + "devDependencies": { + "@vitejs/plugin-vue": "^5.0.4", + "vite": "^5.4.8" + } +} diff --git a/WebApplication/public/favicon.ico b/WebApplication/public/favicon.ico new file mode 100644 index 0000000..529c09d Binary files /dev/null and b/WebApplication/public/favicon.ico differ diff --git a/WebApplication/retrieve-and-view.html b/WebApplication/retrieve-and-view.html new file mode 100644 index 0000000..a31cc00 --- /dev/null +++ b/WebApplication/retrieve-and-view.html @@ -0,0 +1,13 @@ + + + + + + + OE2 Retrieve and view + + +
+ + + diff --git a/WebApplication/src/App.vue b/WebApplication/src/App.vue new file mode 100644 index 0000000..083b80d --- /dev/null +++ b/WebApplication/src/App.vue @@ -0,0 +1,84 @@ + + + + + \ No newline at end of file diff --git a/WebApplication/src/AppLanding.vue b/WebApplication/src/AppLanding.vue new file mode 100644 index 0000000..8fd59b0 --- /dev/null +++ b/WebApplication/src/AppLanding.vue @@ -0,0 +1,47 @@ + + + + + \ No newline at end of file diff --git a/WebApplication/src/AppRetrieveAndView.vue b/WebApplication/src/AppRetrieveAndView.vue new file mode 100644 index 0000000..699151a --- /dev/null +++ b/WebApplication/src/AppRetrieveAndView.vue @@ -0,0 +1,33 @@ + + + + + \ No newline at end of file diff --git a/WebApplication/src/assets/css/common.css b/WebApplication/src/assets/css/common.css new file mode 100644 index 0000000..b3ede3c --- /dev/null +++ b/WebApplication/src/assets/css/common.css @@ -0,0 +1,75 @@ +.cut-text { + text-overflow: ellipsis; + overflow: hidden; + white-space: pre; /* preserve double white spaces (https://github.com/orthanc-server/orthanc-explorer-2/issues/30) */ + max-width: 0; +} + + /* override CSS from datepicker to avoid the close button to overflow over the text */ +.dp__input_icon_pad { + padding-right: 30px !important; +} + +.dp__preset_ranges { + width: 300px !important; +} + +.dp__range_end, .dp__range_start, .dp__active_date { + background: var(--dp-primary-color) !important; +} + + + +/* for the StudyItem */ +.label { + margin-left: 2px; + margin-left: 2px; + background-color: var(--label-bg-color); +} + +/* for the tag editor */ +.tags-badge.bg-info { + background-color: var(--label-bg-color) !important; +} + +.form-control::placeholder { /* Chrome, Firefox, Opera, Safari 10.1+ */ + color: var(--form-placeholder-color); + opacity: 1; /* Firefox */ +} + +.job-card { + margin-bottom: 2px; +} + +.job-card a { + /* color: black; */ +} + +.job-card-close { + position: absolute; + top: 5px; + right: 5px; +} + +.job-pct-pill { + width: 50px; + margin-right: 5px; +} + +.jobs-header { + text-align: left; + padding-top: 2px; + padding-bottom: 2px; + line-height: 1.2rem; +} + +.jobs-body { + padding-top: 2px; + padding-bottom: 2px; + line-height: 1.6; + text-align: left; +} + +.jobs-body a { + text-decoration: underline; +} diff --git a/WebApplication/src/assets/css/defaults-dark.css b/WebApplication/src/assets/css/defaults-dark.css new file mode 100644 index 0000000..bbbe492 --- /dev/null +++ b/WebApplication/src/assets/css/defaults-dark.css @@ -0,0 +1,67 @@ +/* Customized CSS. +This CSS is loaded after all other CSS files have been loaded +therefore, it overrides all other definitions */ +:root { + --bootstrap-theme: dark; + + --study-even-bg-color: rgb(55, 55, 60); + --study-odd-bg-color: rgb(45, 45, 50); + --study-hover-color: rgb(100, 98, 95); + --study-selected-color: rgb(40, 40, 45); + --study-details-bg-color: var(--study-selected-color); + --study-list-remote-bg-color: var(--study-hover-color); + + --series-even-bg-color: rgb(45, 45, 50); + --series-odd-bg-color: rgb(35, 35, 40); + --series-hover-color: var(--study-hover-color); + --series-selected-color: rgb(30, 30, 35); + --series-details-bg-color: var(--series-selected-color); + + --instance-odd-bg-color: rgb(35, 35, 40); + --instance-even-bg-color: rgb(30, 30, 35); + --instance-hover-color: var(--study-hover-color); + --instance-selected-color: rgb(20, 20, 25); + --instance-details-bg-color: var(--instance-selected-color); + + --study-table-header-bg-color: var(--study-even-bg-color); + --study-table-filter-bg-color: rgb(60, 60, 59); + --study-table-actions-bg-color: var(--study-table-filter-bg-color); + + --table-filters-is-searching-color: #fda90d86; + --table-filters-is-not-searching-color: rgb(30, 150, 255); + + --details-top-margin: 25px; + + --nav-bar-width: 260px; + + --nav-side-color: rgb(255, 255, 255); + --nav-side-bg-color: rgb(30, 36, 42); + --nav-side-sub-bg-color: #181c20; + --nav-side-selected-bg-color: #4f5b69; + --nav-side-hover-bg-color: #3e454d; + --nav-side-submenu-color: rgb(255, 255, 255); + --nav-side-active-border-color: #d19b3d; + + --label-bg-color: rgb(61, 116, 141); + + --form-placeholder-color: #888; + + /* you may also customize global bootstrap variables */ + --bs-border-color: rgb(110, 160, 200); + /* --bs-info-rgb: 255, 26, 35; */ + +} + +/* datepicker variables */ +.dp__theme_dark { + --dp-border-color: var(--bs-border-color); +} + +/* optional, you may e.g. customize bootstrap buttons or any other class that is declared globally */ + +/* +.btn-primary { + --bs-btn-color: white; + --bs-btn-bg: red; +} */ + diff --git a/WebApplication/src/assets/css/defaults-light.css b/WebApplication/src/assets/css/defaults-light.css new file mode 100644 index 0000000..ec1e13a --- /dev/null +++ b/WebApplication/src/assets/css/defaults-light.css @@ -0,0 +1,72 @@ +/* Default CSS. +This CSS is loaded after all other CSS files have been loaded +therefore, it overrides all other definitions. However, if you provide +a CustomCssPath, the custom file will be loaded after this one*/ +:root { + --bootstrap-theme: light; + + --study-even-bg-color: rgb(250, 250, 250); + --study-odd-bg-color: rgb(240, 240, 240); + --study-hover-color: rgb(60, 180, 255); + --study-selected-color: rgb(235, 235, 235); + --study-details-bg-color: var(--study-selected-color); + --study-list-remote-bg-color: var(--study-hover-color); + + --series-even-bg-color: rgb(240, 240, 240); + --series-odd-bg-color: rgb(235, 235, 235); + --series-hover-color: var(--study-hover-color); + --series-selected-color: rgb(225, 225, 225); + --series-details-bg-color: var(--series-selected-color); + + --instance-odd-bg-color: rgb(230, 230, 230); + --instance-even-bg-color: rgb(225, 225, 225); + --instance-hover-color: var(--study-hover-color); + --instance-selected-color: rgb(215, 215, 215); + --instance-details-bg-color: var(--instance-selected-color); + + --study-table-header-bg-color: var(--study-even-bg-color); + --study-table-filter-bg-color: rgb(220, 220, 220); + --study-table-actions-bg-color: var(--study-table-filter-bg-color); + + --table-filters-is-searching-color: #fda90d86; + --table-filters-is-not-searching-color: rgb(30, 150, 255); + + --details-top-margin: 25px; + + --nav-bar-width: 260px; + + --nav-side-color: rgb(255, 255, 255); + --nav-side-bg-color: #2e353d; + --nav-side-sub-bg-color: #181c20; + --nav-side-selected-bg-color: #4f5b69; + --nav-side-hover-bg-color: #3e454d; + --nav-side-submenu-color: rgb(255, 255, 255); + --nav-side-active-border-color: #d19b3d; + + --label-bg-color: rgb(10, 200, 240); + + --form-placeholder-color: #CCC; + + /* you may also customize global bootstrap variables */ + /* --bs-border-color: rgb(110, 160, 200); */ + /* --bs-info-rgb: 255, 26, 35; */ +} + +/* override the custom logo class */ +/* .custom-logo { + height: 150px; +} */ + + +/* datepicker variables */ +/* .dp__theme_dark { + --dp-border-color: var(--bs-border-color); +} */ + +/* optional, you may e.g. customize bootstrap buttons or any other class that is declared globally */ + +/* +.btn-primary { + --bs-btn-color: white; + --bs-btn-bg: red; +} */ diff --git a/WebApplication/src/assets/css/layout.css b/WebApplication/src/assets/css/layout.css new file mode 100644 index 0000000..e6c10ae --- /dev/null +++ b/WebApplication/src/assets/css/layout.css @@ -0,0 +1,3 @@ +.content { + margin-left: var(--nav-bar-width); +} \ No newline at end of file diff --git a/WebApplication/src/assets/images/orthanc.png b/WebApplication/src/assets/images/orthanc.png new file mode 100644 index 0000000..816a429 Binary files /dev/null and b/WebApplication/src/assets/images/orthanc.png differ diff --git a/WebApplication/src/assets/logo.png b/WebApplication/src/assets/logo.png new file mode 100644 index 0000000..f3d2503 Binary files /dev/null and b/WebApplication/src/assets/logo.png differ diff --git a/WebApplication/src/components/AddSeriesModal.vue b/WebApplication/src/components/AddSeriesModal.vue new file mode 100644 index 0000000..0f93705 --- /dev/null +++ b/WebApplication/src/components/AddSeriesModal.vue @@ -0,0 +1,335 @@ + + + + + \ No newline at end of file diff --git a/WebApplication/src/components/BulkLabelsModal.vue b/WebApplication/src/components/BulkLabelsModal.vue new file mode 100644 index 0000000..3be10e6 --- /dev/null +++ b/WebApplication/src/components/BulkLabelsModal.vue @@ -0,0 +1,225 @@ + + + + + \ No newline at end of file diff --git a/WebApplication/src/components/CopyToClipboardButton.vue b/WebApplication/src/components/CopyToClipboardButton.vue new file mode 100644 index 0000000..1e67a31 --- /dev/null +++ b/WebApplication/src/components/CopyToClipboardButton.vue @@ -0,0 +1,75 @@ + + + + + diff --git a/WebApplication/src/components/InstanceDetails.vue b/WebApplication/src/components/InstanceDetails.vue new file mode 100644 index 0000000..2f2a6ad --- /dev/null +++ b/WebApplication/src/components/InstanceDetails.vue @@ -0,0 +1,127 @@ + + + + + + + + diff --git a/WebApplication/src/components/InstanceItem.vue b/WebApplication/src/components/InstanceItem.vue new file mode 100644 index 0000000..bfae735 --- /dev/null +++ b/WebApplication/src/components/InstanceItem.vue @@ -0,0 +1,117 @@ + + + + + + \ No newline at end of file diff --git a/WebApplication/src/components/InstanceList.vue b/WebApplication/src/components/InstanceList.vue new file mode 100644 index 0000000..b0ced62 --- /dev/null +++ b/WebApplication/src/components/InstanceList.vue @@ -0,0 +1,109 @@ + + + + + \ No newline at end of file diff --git a/WebApplication/src/components/InstanceListExtended.vue b/WebApplication/src/components/InstanceListExtended.vue new file mode 100644 index 0000000..473928b --- /dev/null +++ b/WebApplication/src/components/InstanceListExtended.vue @@ -0,0 +1,128 @@ + + + + + diff --git a/WebApplication/src/components/JobItem.vue b/WebApplication/src/components/JobItem.vue new file mode 100644 index 0000000..dcbbf64 --- /dev/null +++ b/WebApplication/src/components/JobItem.vue @@ -0,0 +1,99 @@ + + + + \ No newline at end of file diff --git a/WebApplication/src/components/JobsList.vue b/WebApplication/src/components/JobsList.vue new file mode 100644 index 0000000..1e0512c --- /dev/null +++ b/WebApplication/src/components/JobsList.vue @@ -0,0 +1,46 @@ + + + + \ No newline at end of file diff --git a/WebApplication/src/components/LabelsEditor.vue b/WebApplication/src/components/LabelsEditor.vue new file mode 100644 index 0000000..cf7741e --- /dev/null +++ b/WebApplication/src/components/LabelsEditor.vue @@ -0,0 +1,116 @@ + + + + + + \ No newline at end of file diff --git a/WebApplication/src/components/LanguagePicker.vue b/WebApplication/src/components/LanguagePicker.vue new file mode 100644 index 0000000..5814487 --- /dev/null +++ b/WebApplication/src/components/LanguagePicker.vue @@ -0,0 +1,125 @@ + + + + + diff --git a/WebApplication/src/components/Modal.vue b/WebApplication/src/components/Modal.vue new file mode 100644 index 0000000..f565c2d --- /dev/null +++ b/WebApplication/src/components/Modal.vue @@ -0,0 +1,45 @@ + + + + + \ No newline at end of file diff --git a/WebApplication/src/components/ModifyModal.vue b/WebApplication/src/components/ModifyModal.vue new file mode 100644 index 0000000..187a8d0 --- /dev/null +++ b/WebApplication/src/components/ModifyModal.vue @@ -0,0 +1,998 @@ + + + + + \ No newline at end of file diff --git a/WebApplication/src/components/NotFound.vue b/WebApplication/src/components/NotFound.vue new file mode 100644 index 0000000..1c7188d --- /dev/null +++ b/WebApplication/src/components/NotFound.vue @@ -0,0 +1,22 @@ + + + \ No newline at end of file diff --git a/WebApplication/src/components/ResourceButtonGroup.vue b/WebApplication/src/components/ResourceButtonGroup.vue new file mode 100644 index 0000000..988e69a --- /dev/null +++ b/WebApplication/src/components/ResourceButtonGroup.vue @@ -0,0 +1,1006 @@ + + + + + \ No newline at end of file diff --git a/WebApplication/src/components/ResourceDetailText.vue b/WebApplication/src/components/ResourceDetailText.vue new file mode 100644 index 0000000..5e986a1 --- /dev/null +++ b/WebApplication/src/components/ResourceDetailText.vue @@ -0,0 +1,78 @@ + + + + + diff --git a/WebApplication/src/components/RetrieveAndView.vue b/WebApplication/src/components/RetrieveAndView.vue new file mode 100644 index 0000000..0c40faf --- /dev/null +++ b/WebApplication/src/components/RetrieveAndView.vue @@ -0,0 +1,151 @@ + + + + + \ No newline at end of file diff --git a/WebApplication/src/components/SeriesDetails.vue b/WebApplication/src/components/SeriesDetails.vue new file mode 100644 index 0000000..63e2126 --- /dev/null +++ b/WebApplication/src/components/SeriesDetails.vue @@ -0,0 +1,165 @@ + + + + + + + \ No newline at end of file diff --git a/WebApplication/src/components/SeriesItem.vue b/WebApplication/src/components/SeriesItem.vue new file mode 100644 index 0000000..7ecd655 --- /dev/null +++ b/WebApplication/src/components/SeriesItem.vue @@ -0,0 +1,140 @@ + + + + + + \ No newline at end of file diff --git a/WebApplication/src/components/SeriesList.vue b/WebApplication/src/components/SeriesList.vue new file mode 100644 index 0000000..8da43f7 --- /dev/null +++ b/WebApplication/src/components/SeriesList.vue @@ -0,0 +1,149 @@ + + + + + \ No newline at end of file diff --git a/WebApplication/src/components/Settings.vue b/WebApplication/src/components/Settings.vue new file mode 100644 index 0000000..e886ec2 --- /dev/null +++ b/WebApplication/src/components/Settings.vue @@ -0,0 +1,221 @@ + + + \ No newline at end of file diff --git a/WebApplication/src/components/SettingsLabels.vue b/WebApplication/src/components/SettingsLabels.vue new file mode 100644 index 0000000..c2d0b8e --- /dev/null +++ b/WebApplication/src/components/SettingsLabels.vue @@ -0,0 +1,222 @@ + + + \ No newline at end of file diff --git a/WebApplication/src/components/SettingsPermissions.vue b/WebApplication/src/components/SettingsPermissions.vue new file mode 100644 index 0000000..7c8db11 --- /dev/null +++ b/WebApplication/src/components/SettingsPermissions.vue @@ -0,0 +1,427 @@ + + + \ No newline at end of file diff --git a/WebApplication/src/components/ShareModal.vue b/WebApplication/src/components/ShareModal.vue new file mode 100644 index 0000000..c93d1c1 --- /dev/null +++ b/WebApplication/src/components/ShareModal.vue @@ -0,0 +1,200 @@ + + + + + \ No newline at end of file diff --git a/WebApplication/src/components/SideBar.vue b/WebApplication/src/components/SideBar.vue new file mode 100644 index 0000000..ad7a02c --- /dev/null +++ b/WebApplication/src/components/SideBar.vue @@ -0,0 +1,488 @@ + + + \ No newline at end of file diff --git a/WebApplication/src/components/StudyDetails.vue b/WebApplication/src/components/StudyDetails.vue new file mode 100644 index 0000000..99b0a69 --- /dev/null +++ b/WebApplication/src/components/StudyDetails.vue @@ -0,0 +1,194 @@ + + + + + + \ No newline at end of file diff --git a/WebApplication/src/components/StudyItem.vue b/WebApplication/src/components/StudyItem.vue new file mode 100644 index 0000000..0cb0949 --- /dev/null +++ b/WebApplication/src/components/StudyItem.vue @@ -0,0 +1,328 @@ + + + + + + \ No newline at end of file diff --git a/WebApplication/src/components/StudyList.vue b/WebApplication/src/components/StudyList.vue new file mode 100644 index 0000000..4b8c244 --- /dev/null +++ b/WebApplication/src/components/StudyList.vue @@ -0,0 +1,1232 @@ + + + + + + \ No newline at end of file diff --git a/WebApplication/src/components/TagsTree.vue b/WebApplication/src/components/TagsTree.vue new file mode 100644 index 0000000..2cf557a --- /dev/null +++ b/WebApplication/src/components/TagsTree.vue @@ -0,0 +1,84 @@ + + + + + + diff --git a/WebApplication/src/components/TokenLanding.vue b/WebApplication/src/components/TokenLanding.vue new file mode 100644 index 0000000..ace1dcc --- /dev/null +++ b/WebApplication/src/components/TokenLanding.vue @@ -0,0 +1,57 @@ + + + + + \ No newline at end of file diff --git a/WebApplication/src/components/TokenLinkButton.vue b/WebApplication/src/components/TokenLinkButton.vue new file mode 100644 index 0000000..c2ce3ac --- /dev/null +++ b/WebApplication/src/components/TokenLinkButton.vue @@ -0,0 +1,142 @@ + + + + + \ No newline at end of file diff --git a/WebApplication/src/components/UploadHandler.vue b/WebApplication/src/components/UploadHandler.vue new file mode 100644 index 0000000..e32abeb --- /dev/null +++ b/WebApplication/src/components/UploadHandler.vue @@ -0,0 +1,216 @@ + + + + \ No newline at end of file diff --git a/WebApplication/src/components/UploadReport.vue b/WebApplication/src/components/UploadReport.vue new file mode 100644 index 0000000..e7b3ac0 --- /dev/null +++ b/WebApplication/src/components/UploadReport.vue @@ -0,0 +1,109 @@ + + + + \ No newline at end of file diff --git a/WebApplication/src/globalConfigurations.js b/WebApplication/src/globalConfigurations.js new file mode 100644 index 0000000..1d9e55c --- /dev/null +++ b/WebApplication/src/globalConfigurations.js @@ -0,0 +1,3 @@ +export var baseOe2Url = window.location.pathname.slice(0, -1); +export var orthancApiUrl = '../../' +export var oe2ApiUrl = '../api/'; \ No newline at end of file diff --git a/WebApplication/src/helpers/clipboard-helpers.js b/WebApplication/src/helpers/clipboard-helpers.js new file mode 100644 index 0000000..62a0f48 --- /dev/null +++ b/WebApplication/src/helpers/clipboard-helpers.js @@ -0,0 +1,39 @@ +export default { + copyToClipboard(text, onSuccess, onFailure) { + if (navigator.clipboard) { + navigator.clipboard.writeText(text).then( + () => { + if (onSuccess !== undefined) { + onSuccess(); + } else { + console.log("copied to clipboard: ", text) + } + }, + () => { + if (onFailure !== undefined) { + onFailure(); + } else { + console.log("failed to copy to clipboard") + } + } + ) + } else { // this happens, e.g in unsecure contexts (https://discourse.orthanc-server.org/t/copy-icon-oe2-problem/3958/4) + const tmp = document.createElement('TEXTAREA'); + const focus = document.activeElement; + + tmp.value = text; + + document.body.appendChild(tmp); + tmp.select(); + document.execCommand('copy'); // note: this is deprecated but we use this code only as a fallback + document.body.removeChild(tmp); + focus.focus(); + + if (onSuccess !== undefined) { + onSuccess(); + } else { + console.log("hopefully copied to clipboard: ", text) + } + } + }, +} diff --git a/WebApplication/src/helpers/date-helpers.js b/WebApplication/src/helpers/date-helpers.js new file mode 100644 index 0000000..5399d33 --- /dev/null +++ b/WebApplication/src/helpers/date-helpers.js @@ -0,0 +1,91 @@ +import { parse, format, endOfMonth, endOfYear, startOfMonth, startOfYear, subMonths, subDays, startOfWeek, endOfWeek, subYears } from 'date-fns'; + +document._datePickerPresetRanges = [ + { tLabel: 'date_picker.today', value: [new Date(), new Date()] }, + { tLabel: 'date_picker.yesterday', value: [subDays(new Date(), 1), subDays(new Date(), 1)] }, + { tLabel: 'date_picker.this_week', value: [startOfWeek(new Date(), { weekStartsOn: 1 }), new Date()] }, + { tLabel: 'date_picker.last_week', value: [startOfWeek(subDays(new Date(), 7), { weekStartsOn: 1 }), endOfWeek(subDays(new Date(), 7), { weekStartsOn: 1 })] }, + { tLabel: 'date_picker.this_month', value: [startOfMonth(new Date()), endOfMonth(new Date())] }, + { tLabel: 'date_picker.last_month', value: [startOfMonth(subMonths(new Date(), 1)), endOfMonth(subMonths(new Date(), 1))] }, + { tLabel: 'date_picker.last_12_months', value: [subYears(new Date(), 1), new Date()] }, +]; + +export default { + parse(dateStr, format) { + return parse(dateStr, format, 0); + }, + toDicomDate(date) { + return (date.getFullYear() * 10000 + (date.getMonth()+1) * 100 + date.getDate()).toString(); + }, + fromDicomDate(dateStr) { + let match = null; + match = dateStr.match(/^(\d{4})(\d{1,2})(\d{1,2})$/); // yyyymmdd (DICOM) + if (match) { + return new Date(match[1], match[2]-1, match[3]); + } + return null; + }, + parseDateForDatePicker(str) { + let match = null; + match = str.match(/^(\d{4})(\d{1,2})(\d{1,2})$/); // yyyymmdd (DICOM) + if (match) { + return [new Date(match[1], match[2]-1, match[3]), null]; + } + match = str.match(/^(\d{4})(\d{1,2})(\d{1,2})\-(\d{4})(\d{1,2})(\d{1,2})$/); // yyyymmdd-yyyymmdd (DICOM range) + if (match) { + return [new Date(match[1], match[2]-1, match[3]), new Date(match[4], match[5]-1, match[6])]; + } + // match = str.match(/^(\d{1,2})[\/\-](\d{1,2})[\/\-](\d{4})$/); // dd/mm/yyyy or dd-mm-yyyy + // if (match) { + // return [new Date(match[3], match[2]-1, match[1]), null]; + // } + // match = str.match(/^(\d{4})[\/\-](\d{1,2})[\/\-](\d{1,2})$/); // yyyy/mm/dd or yyyy-mm-dd + // if (match) { + // return [new Date(match[1], match[2]-1, match[3]), null]; + // } + return null; + }, + dicomDateFromDatePicker(dates) { + let output = ""; + if (dates == null) { + output = null; + } + else if (dates instanceof Date) { + output = this.toDicomDate(dates); + } + else if (dates instanceof Array) { + if (dates.length == 2 && (dates[0] != null && dates[0].getFullYear != undefined) && (dates[1] != null && dates[1].getFullYear != undefined)) { + if (this.toDicomDate(dates[0]) == this.toDicomDate(dates[1])) { + output = this.toDicomDate(dates[0]); + } else { + output = this.toDicomDate(dates[0]) + "-" + this.toDicomDate(dates[1]); + } + } else if (dates.length >= 1 && dates[0].getFullYear != undefined) { + output = this.toDicomDate(dates[0]); + } else if (dates.length == 2 && typeof dates[0] == 'string' && typeof dates[1] == 'string') { + output = dates[0] + "-" + dates[1]; + } else if (dates.length == 1 && typeof dates[0] == 'string') { + output = dates[0]; + } + } + return output; + }, + formatDateForDisplay(dicomDate, dateFormat) { + if (!dicomDate) { + return ""; + } + if (dicomDate && dicomDate.length == 8) { + let d = parse(dicomDate, "yyyyMMdd", new Date()); + if (!isNaN(d.getDate())) { + return format(d, dateFormat); + } + } + if (dicomDate.length > 0) { + return dicomDate; + } + return ""; + }, + isDateTag(tagName) { + return ["StudyDate", "PatientBirthDate", "SeriesDate", "AcquisitionDate", "ContentDate"].indexOf(tagName) != -1; + } +} diff --git a/WebApplication/src/helpers/label-helpers.js b/WebApplication/src/helpers/label-helpers.js new file mode 100644 index 0000000..7ac2356 --- /dev/null +++ b/WebApplication/src/helpers/label-helpers.js @@ -0,0 +1,22 @@ +export default { + filterLabel(str) { + const regexLabel = new RegExp("^[0-9\-\_a-zA-Z]+$"); + if (str && str.length > 0 && !regexLabel.test(str)) { + console.log("invalid label: ", str); + const invalidLabelTips = document.querySelectorAll('.invalid-label-tips'); + invalidLabelTips.forEach(element => { + element.classList.remove('invalid-label-tips-hidden'); + }) + setTimeout(() => { + const invalidLabelTips = document.querySelectorAll('.invalid-label-tips'); + invalidLabelTips.forEach(element => { + element.classList.add('invalid-label-tips-hidden'); + }) + }, 8000); + } else { + // console.log("valid '" + str + "'"); + } + + return str.replace(/[^0-9\-\_a-zA-Z]/gi, ''); + } +} \ No newline at end of file diff --git a/WebApplication/src/helpers/resource-helpers.js b/WebApplication/src/helpers/resource-helpers.js new file mode 100644 index 0000000..e226960 --- /dev/null +++ b/WebApplication/src/helpers/resource-helpers.js @@ -0,0 +1,89 @@ +import store from "../store" +import api from "../orthancApi" + +export default { + getResourceTitle(resourceType, patientMainDicomTags, studyMainDicomTags, seriesMainDicomTags, instanceTags) { + let title = []; + + function addIfExists(title, key, dico) { + if (key in dico) { + title.push(dico[key]); + return true; + } + return false; + }; + + if (resourceType == "study" || resourceType == "series") { + addIfExists(title, "PatientID", patientMainDicomTags) + addIfExists(title, "StudyID", studyMainDicomTags) + addIfExists(title, "StudyDate", studyMainDicomTags) + addIfExists(title, "StudyDescription", studyMainDicomTags) + } + if (resourceType == "series" || resourceType == "instance") { + addIfExists(title, "SeriesNumber", seriesMainDicomTags); + addIfExists(title, "SeriesDescription", seriesMainDicomTags); + } + if (resourceType == "instance") { + if ("0020,0013" in instanceTags) { + title.push("instance # " + instanceTags["0020,0013"]["Value"]); + } else { + title.push("instance"); + } + } + + return title.join(" | "); + }, + + patientNameCapture : "([^\\^]+)\\^?([^\\^]+)?\\^?([^\\^]+)?\\^?([^\\^]+)?\\^?([^\\^]+)?", + patientNameFormatting : null, + formatPatientName(originalPatientName) { + if (originalPatientName && this.patientNameFormatting && this.patientNameCapture) { + return originalPatientName.replace(new RegExp(this.patientNameCapture), this.patientNameFormatting); + } else { + return originalPatientName; + } + }, + + getPrimaryViewerUrl(level, orthancId, dicomId) { + if (store.state.configuration.uiOptions.ViewersOrdering.length > 0) { + for (let viewer of store.state.configuration.uiOptions.ViewersOrdering) { + if ((["osimis-web-viewer", "stone-webviewer", "volview", "wsi"].indexOf(viewer) != -1 && viewer in store.state.configuration.installedPlugins) || + (viewer.startsWith("ohif") && viewer in store.state.configuration.installedPlugins) || + (viewer.startsWith("ohif") && store.state.configuration.uiOptions.EnableOpenInOhifViewer3) || + (viewer == "meddream" && store.state.configuration.uiOptions.EnableOpenInMedDreamViewer)) + { + return this.getViewerUrl(level, orthancId, dicomId, viewer); + } + } + } + return null; + }, + + getViewerUrl(level, orthancId, dicomId, viewer) { + if (viewer == 'osimis-web-viewer') { + return api.getOsimisViewerUrl(level, orthancId); + } else if (viewer == 'stone-webviewer') { + return api.getStoneViewerUrl(level, dicomId) + } else if (viewer == 'volview') { + return api.getVolViewUrl(level, orthancId); + } else if (viewer == 'ohif') { + if (store.state.configuration.ohifDataSource == 'dicom-web') { + return api.getOhifViewerUrlForDicomWeb('basic', dicomId); + } else { + return api.getOhifViewerUrlForDicomJson('basic', dicomId); + } + } else if (viewer == 'ohif-vr') { + return api.getOhifViewerUrl('vr'); + } else if (viewer == 'ohif-tmtv') { + return api.getOhifViewerUrl('tmtv'); + } else if (viewer == 'ohif-seg') { + return api.getOhifViewerUrl('seg'); + } else if (viewer == 'ohif-micro') { + return api.getOhifViewerUrl('microscopy'); + } else if (viewer == 'wsi') { + return api.getWsiViewerUrl(orthancId); // note: this must be a series ID ! + } else if (viewer == 'meddream') { + return store.state.configuration.uiOptions.MedDreamViewerPublicRoot + "?study=" + dicomId; + } + } +} diff --git a/WebApplication/src/helpers/source-type.js b/WebApplication/src/helpers/source-type.js new file mode 100644 index 0000000..6e18788 --- /dev/null +++ b/WebApplication/src/helpers/source-type.js @@ -0,0 +1,7 @@ +const SourceType = Object.freeze({ + LOCAL_ORTHANC: 0, + REMOTE_DICOM: 1, + REMOTE_DICOM_WEB: 2 +}); + +export default SourceType; \ No newline at end of file diff --git a/WebApplication/src/locales/de.json b/WebApplication/src/locales/de.json new file mode 100644 index 0000000..381a362 --- /dev/null +++ b/WebApplication/src/locales/de.json @@ -0,0 +1,213 @@ +{ + "all_modalities": "Alle", + "anonymize": "Anonymisieren", + "cancel": "Abbrechen", + "change_password": "Passwort ändern", + "close": "Schließen", + "copy_orthanc_id": "Orthanc-ID kopieren", + "date_picker": { + "last_12_months": "Letzten 12 Monate", + "last_month": "Letzten Monat", + "last_week": "Letzte Woche", + "this_month": "Diesen Monat", + "this_week": "Diese Woche", + "today": "Heute", + "yesterday": "Gestern" + }, + "default": "Standard", + "delete": "Löschen", + "delete_instance_body": "Sind Sie sicher, dass Sie diese Instanz löschen möchten?
Diese Aktion kann nicht rückgängig gemacht werden!", + "delete_instance_title": "Instanz löschen?", + "delete_series_body": "Sind Sie sicher, dass Sie diese Serie löschen möchten?
Diese Aktion kann nicht rückgängig gemacht werden!", + "delete_series_title": "Serien löschen?", + "delete_studies_body": "Sind Sie sicher, dass Sie diese Studien löschen möchten?
Diese Aktion kann nicht rückgängig gemacht werden!", + "delete_studies_title": "Studien löschen?", + "delete_study_body": "Sind Sie sicher, dass Sie diese Studie löschen möchten?
Diese Aktion kann nicht rückgängig gemacht werden!", + "delete_study_title": "Studie löschen?", + "description": "Beschreibung", + "dicom_modalities": "DICOM Modalitäten", + "dicom_tags": { + "AccessionNumber": "Zugangsnummer", + "BodyPartExamined": "Untersuchungsregion", + "InstanceNumber": "Instanznummer", + "InstitutionName": "Institutionsname", + "ModalitiesInStudy": "Modalitäten in der Studie", + "Modality": "Modalität", + "NumberOfFrames": "Anzahl der Frames", + "NumberOfStudyRelatedSeries": "Anzahl der studienbezogenen Serien", + "PatientBirthDate": "Geburtsdatum des Patienten", + "PatientID": "Patienten-ID", + "PatientName": "Patientenname", + "PatientSex": "Geschlecht des Patienten", + "ProtocolName": "Protokollname", + "ReferringPhysicianName": "Überweisender Arzt", + "RequestingPhysician": "Anfordernder Arzt", + "SOPInstanceUID": "SOP-Instanz-UID", + "SeriesDate": "Serien-Datum", + "SeriesDescription": "Serienbeschreibung", + "SeriesInstanceUID": "Serieninstanz-UID", + "SeriesNumber": "Seriennummer", + "SeriesTime": "Serienzeit", + "StudyDate": "Studiendatum", + "StudyDescription": "Studienbeschreibung", + "StudyID": "Studien-ID", + "StudyInstanceUID": "Studieninstanz-UID", + "StudyTime": "Studienzeit", + "seriesCount": "Anzahl der Serien" + }, + "dicom_web_servers": "DICOM-Webserver", + "displaying_latest_studies": "Anzeige der neuesten Studien", + "download_dicom_file": "DICOM-Datei herunterladen", + "download_dicomdir": "DICOMDIR herunterladen", + "download_zip": "ZIP herunterladen", + "drop_files": "Dateien hier ablegen", + "enter_search": "Geben Sie Suchkriterien ein, um Ergebnisse anzuzeigen!", + "error": "Fehler", + "file": "Datei", + "files": "Dateien", + "frames": "Frames", + "instance": "Instanz", + "instances": "Instanzen", + "instances_number": "Anzahl der Instanzen", + "labels": { + "add_button": "Hinzufügen", + "add_labels_message_html": "Hinzufügen dieser Labels zu allen ausgewählten Ressourcen", + "add_labels_placeholder": "Labels hinzufügen, drücken Sie Enter, um ein neues Label zu erstellen", + "added_labels_message_part_1_html": "Hinzugefügte Labels ", + "added_labels_message_part_2_html": " zu {count} Studien", + "clear_all_button": "Alle entfernen", + "clear_all_labels_message_html": "Entferne alle Labels in allen ausgewählten Ressourcen", + "cleared_labels_message_part_1_html": "Entfernte Labels ", + "cleared_labels_message_part_2_html": " von {count} Studien", + "edit_labels_button": "Labels bearbeiten", + "modal_title": "Labels in ausgewählten Ressourcen bearbeiten", + "remove_button": "Entfernen", + "remove_labels_message_html": "Entfernen dieser Labels aus allen ausgewählten Ressourcen", + "remove_labels_placeholder": "Labels entfernen", + "removed_labels_message_part_1_html": "Entfernte Labels ", + "removed_labels_message_part_2_html": " von {count} Studien", + "study_details_title": "Labels" + }, + "legacy_ui": "Alte Benutzeroberfläche", + "loading_latest_studies": "Laden der neuesten Studien", + "local_studies": "Alle lokalen Studien", + "logout": "Abmelden", + "mammography_plugin": "Start mammogram AI", + "modalities_in_study": "Modalitäten in der Studie", + "modify": { + "anonymize_button_title": "Anonymisieren", + "anonymize_modal_title": "Anonymisieren", + "autogenerated_dicom_uid": "Automatisch generiert", + "back_button_title": "Zurück", + "error_attach_series_to_existing_study_target_does_not_exist_html": "Fehler beim Ändern der Serie, keine Studie mit dieser Studieninstanz-UID gefunden.", + "error_attach_series_to_existing_study_target_unchanged_html": "Fehler beim Ändern der Serie, die Zielstudie ist dieselbe wie die aktuelle Serienstudie.", + "error_attach_study_to_existing_patient_target_does_not_exist_html": "Fehler beim Ändern des Patienten, kein Patient mit dieser Patienten-ID gefunden. Bitte verwenden Sie die Ändern von Studien-Tags Funktion.", + "error_modify_any_study_tags_can_not_modify_patient_tags_because_of_other_studies_html": "Fehler beim Ändern von Studien-Tags: Dieser Patient hat bereits andere Studien. Bitte verwenden Sie die Patient-Tags ändern Funktion.", + "error_modify_any_study_tags_patient_exists_html": "Fehler beim Ändern von Studien-Tags: Ein anderer Patient mit derselben Patienten-ID existiert bereits. Bitte verwenden Sie die Patient ändern Funktion.", + "error_modify_patient_tags_another_patient_exists_with_same_patient_id_html": "Fehler beim Ändern von Patienten-Tags: Ein anderer Patient mit derselben Patienten-ID existiert bereits. Bitte verwenden Sie die Patient-Tags ändern Funktion.", + "error_modify_unexpected_error_html": "Unerwarteter Fehler während der Änderung, überprüfen Sie die Orthanc-Protokolle", + "insert_tag": "DICOM-Tag einfügen", + "job_in_progress": "Änderung wird verarbeitet", + "modify_button_title": "Ändern", + "modify_modal_title": "Ändern", + "modify_study_mode_duplicate_html": "Erstellen Sie eine Kopie der Originalstudie mit Ihren Änderungen. (generiert neue DICOM-UIDs und behält die Originalstudie)", + "modify_study_mode_keep_uids_html": "Originalstudie verändern. (behalten die originalen DICOM-UIDs)", + "modify_study_mode_new_uids_html": "Originalstudie verändern. (generiert neue DICOM-UIDs)", + "remove_tag_tooltip": "Tag entfernen", + "remove_tag_undo_tooltip": "Tag entfernen rückgängig machen", + "series_step_0_attach_series_to_existing_study_button_title_html": "Studie ändern", + "series_step_0_attach_series_to_existing_study_html": "Diese Serie zu einer vorhandenen Studie verschieben.", + "series_step_0_create_new_study_button_title_html": "Neue Studie erstellen", + "series_step_0_create_new_study_html": "Diese Serie in eine neue Studie verschieben.", + "series_step_0_modify_series_button_title_html": "Seriendaten ändern", + "series_step_0_modify_series_html": "Seriendaten in dieser Serie ändern?", + "show_modified_resources": "Modifizierte Ressourcen anzeigen", + "study_step_0_attach_study_to_existing_patient_button_title_html": "Patient ändern", + "study_step_0_attach_study_to_existing_patient_html": "Diese Studie an einen anderen vorhandenen Patienten anhängen.", + "study_step_0_modify_study_button_title_html": "Studien-Tags ändern", + "study_step_0_modify_study_html": "Patienten-/Studien-Tags in dieser Studie ändern?", + "study_step_0_patient_has_other_studies_button_title_html": "Patienten-Tags ändern", + "study_step_0_patient_has_other_studies_html": "Dieser Patient hat insgesamt {count} Studien.
Möchten Sie den Patienten in all diesen Studien ändern?", + "warning_create_new_study_from_series_html": "Ein Patient mit derselben Patienten-ID existiert bereits mit unterschiedlichen Tags. Möchten Sie den vorhandenen Patientennamen, das Geschlecht und das Geburtsdatum verwenden?" + }, + "my_jobs": "Meine Aufträge", + "no_modalities": "Keine", + "no_result_found": "Kein Ergebnis gefunden!", + "not_showing_all_results": "Es können nicht alle Ergebnisse angezeigt werden. Sie sollten Ihre Suchkriterien verfeinern", + "open": "Öffnen", + "page_not_found": "Seite nicht gefunden!", + "plugin": "Plugin", + "preview": "Vorschau", + "profile": "Profil", + "retrieve_and_view": { + "finding_locally": "Überprüfen, ob die Studie bereits lokal verfügbar ist.", + "finding_remotely": "Suchen der Studie in Remote-DICOM-Knoten.", + "not_found": "Die Studie wurde weder lokal noch in Remote-DICOM-Knoten gefunden.", + "retrieved_html": "Abgerufene {count} Instanzen.", + "retrieving": "Studie abrufen." + }, + "searching": "Suchen...", + "select_files": "Dateien auswählen", + "select_folder": "Ordner auswählen", + "send_to": { + "button_title": "Senden", + "dicom": "An DICOM-Knoten senden", + "dicom_web": "An DICOMWeb-Server senden", + "orthanc_peer": "An Orthanc Peer senden", + "transfers": "An Orthanc Peer senden (erweiterte Übertragungen)" + }, + "series": "Serie", + "series_count_header": "# Serien", + "series_plural": "Serien", + "settings": { + "dicom_AET": "DICOM AET", + "dicom_port": "DICOM-Port", + "ingest_transcoding": "Transcoding übernehmen", + "installed_plugins": "Installierte Plugins", + "orthanc_name": "Orthanc-Name", + "orthanc_system_info": "Orthanc-Systeminformationen", + "orthanc_version": "Orthanc-Version", + "overwrite_instances": "Instanzen überschreiben", + "plugins_not_enabled": "Geladene, aber nicht aktivierte oder nicht korrekt konfigurierte Plugins sind ", + "statistics": "Statistiken", + "storage_compression": "Speicherkompression", + "storage_size": "Speichergröße", + "striked_through": "durchgestrichen", + "title": "Einstellungen", + "verbosity_level": "Ausführlichkeitsstufe" + }, + "share": { + "anonymize": "Anonymisieren?", + "button_title": "Teilen", + "copy_and_close": "Kopieren und Schließen", + "days": "Tage", + "expires_in": "Läuft ab in", + "link": "Link", + "modal_title": "Studie teilen", + "never": "niemals" + }, + "show_errors": "Fehler anzeigen", + "studies": "Studien", + "study": "Studie", + "this_patient_has_no_other_studies": "Dieser Patient hat keine anderen Studien.", + "this_patient_has_other_studies": "Dieser Patient hat insgesamt {count} Studien.", + "this_patient_has_other_studies_show": "Andere Studien anzeigen!", + "token": { + "error_token_expired_html": "Ihr Token ist abgelaufen.", + "error_token_invalid_html": "Ihr Token ist ungültig.
Überprüfen Sie, ob Sie es vollständig eingefügt haben, oder kontaktieren Sie die Person, die es Ihnen zur Verfügung gestellt hat.", + "error_token_unknown_html": "Ihr Token ist ungültig.
Überprüfen Sie, ob Sie es vollständig eingefügt haben, oder kontaktieren Sie die Person, die es Ihnen zur Verfügung gestellt hat.", + "token_being_checked_html": "Ihr Token wird überprüft." + }, + "trace": "Trace", + "upload": "Hochladen", + "uploaded_studies": "Hochgeladene Studien", + "verbose": "Ausführlich", + "view_in_meddream": "In MedDream anzeigen", + "view_in_ohif": "In OHIF anzeigen", + "view_in_ohif_tmtv": "In OHIF Total Metabolic Tumor Volume-Modus anzeigen", + "view_in_ohif_vr": "In OHIF Volumenrendering-Modus anzeigen", + "view_in_osimis": "In OsimisViewer anzeigen", + "view_in_stone": "In StoneViewer anzeigen", + "view_in_volview": "In VolView anzeigen", + "view_in_wsi_viewer": "In Whole Slide Imaging Viewer anzeigen" +} \ No newline at end of file diff --git a/WebApplication/src/locales/en.json b/WebApplication/src/locales/en.json new file mode 100644 index 0000000..2f5fa25 --- /dev/null +++ b/WebApplication/src/locales/en.json @@ -0,0 +1,270 @@ +{ + "add_series": { + "button_title": "Add a series", + "drop_file": "Drop a single PDF, image or STL file here or", + "error_add_series_unexpected_error_html": "Unexpected error while adding a series, check Orthanc logs", + "modal_title": "Add a new series to study", + "select_file": "Select a file", + "unrecognized_file_format": "Unrecognized file format. Only PDF, image files and STL files are supported", + "uploaded_file": "The file {name} ({size}) is of {type} type." + }, + "all_modalities": "All", + "anonymize": "Anonymize", + "cancel": "Cancel", + "change_password": "Change password", + "close": "Close", + "copy_orthanc_id": "Copy Orthanc ID", + "date_picker": { + "last_12_months": "Last 12 months", + "last_month": "Last month", + "last_week": "Last week", + "this_month": "This month", + "this_week": "This week", + "today": "Today", + "yesterday": "Yesterday" + }, + "default": "Default", + "delete": "Delete", + "delete_instance_body": "Are you sure you want to delete this instance?
This action can not be undone!", + "delete_instance_title": "Delete instance?", + "delete_series_body": "Are you sure you want to delete this series?
This action can not be undone!", + "delete_series_title": "Delete series?", + "delete_studies_body": "Are you sure you want to delete these studies?
This action can not be undone!", + "delete_studies_title": "Delete studies?", + "delete_study_body": "Are you sure you want to delete this study?
This action can not be undone!", + "delete_study_title": "Delete study?", + "description": "Description", + "dicom_modalities": "DICOM Modalities", + "dicom_tags": { + "AccessionNumber": "Accession number", + "BodyPartExamined": "Body part examined", + "InstanceNumber": "Instance number", + "InstitutionName": "Institution Name", + "ModalitiesInStudy": "Modalities in Study", + "Modality": "Modality", + "NumberOfFrames": "Number of frames", + "NumberOfStudyRelatedSeries": "Number of series", + "OtherPatientIDs": "Patient Other IDs", + "PatientBirthDate": "Patient Birth Date", + "PatientID": "Patient ID", + "PatientName": "Patient Name", + "PatientSex": "Patient sex", + "ProtocolName": "Protocol Name", + "ReferringPhysicianName": "Referring Physician Name", + "RequestingPhysician": "Requesting Physician", + "SOPInstanceUID": "SOP Instance UID", + "SeriesDate": "Series Date", + "SeriesDescription": "Series Description", + "SeriesInstanceUID": "Series Instance UID", + "SeriesNumber": "Series number", + "SeriesTime": "Series Time", + "StudyDate": "Study Date", + "StudyDescription": "Study Description", + "StudyID": "Study ID", + "StudyInstanceUID": "Study Instance UID", + "StudyTime": "Study Time", + "seriesCount": "Number of series" + }, + "dicom_web_servers": "DICOM-Web Servers", + "displaying_latest_studies": "Displaying most recent studies", + "download_dicom_file": "Download DICOM file", + "download_dicomdir": "Download DICOMDIR", + "download_zip": "Download ZIP", + "drop_files": "Drop files here or", + "enter_search": "Enter a search criteria to show results!", + "error": "Error", + "file": "File", + "files": "files", + "frames": "frames", + "instance": "Instance", + "instances": "Instances", + "instances_count_header": "# instances", + "instances_number": "Number of instances", + "job_success": "Success", + "job_failure": "Failure", + "labels": { + "add_button": "Add", + "add_labels_message_html": "Add these labels to all selected resources", + "add_labels_placeholder": "Labels to add, press Enter to create or add a new one", + "add_labels_placeholder_no_create": "Labels to add", + "added_labels_message_part_1_html": "Added labels ", + "added_labels_message_part_2_html": " to {count} studies", + "clear_all_button": "Remove all", + "clear_all_labels_message_html": "Remove all labels in all selected resources", + "cleared_labels_message_part_1_html": "Removed labels ", + "cleared_labels_message_part_2_html": " from {count} studies", + "edit_labels_button": "Edit labels", + "modal_title": "Modify labels in selected resources", + "remove_button": "Remove", + "remove_labels_message_html": "Remove these labels from all selected resources", + "remove_labels_placeholder": "Labels to remove", + "removed_labels_message_part_1_html": "Removed labels ", + "removed_labels_message_part_2_html": " from {count} studies", + "study_details_title": "Labels", + "valid_alphabet_warning": "Only allowed characters in labels are: latin letters, numbers, - and _" + }, + "legacy_ui": "Legacy UI", + "loading_latest_studies": "Loading most recent studies", + "local_studies": "All local Studies", + "logout": "Logout", + "mammography_plugin": "Start mammography AI", + "modalities_in_study": "Modalities in Study", + "modify": { + "anonymize_button_title": "Anonymize", + "anonymize_modal_title": "Anonymize", + "autogenerated_dicom_uid": "Auto-generated", + "back_button_title": "Back", + "error_attach_series_to_existing_study_target_does_not_exist_html": "Error while changing series, no study found with this StudyInstanceUID.", + "error_attach_series_to_existing_study_target_unchanged_html": "Error while changing series, the target study is the same as the current series study.", + "error_attach_study_to_existing_patient_target_does_not_exist_html": "Error while changing patient, no patient found with this PatientID. You should probably use the Modify Study tags function instead.", + "error_modify_any_study_tags_can_not_modify_patient_tags_because_of_other_studies_html": "Error while modifyting study tags: this patient has other studies. You should use the Modify Patient tags function instead.", + "error_modify_any_study_tags_patient_exists_html": "Error while modifying study tags: another patient with the same PatientID already exists. You should use the Change patient function instead.", + "error_modify_patient_tags_another_patient_exists_with_same_patient_id_html": "Error while modifying a patient tags: another patient with the same PatientID already exists. You should use the Modify Patient tags function instead.", + "error_modify_unexpected_error_html": "Unexpected error during modification, check Orthanc logs", + "insert_tag": "Insert a DICOM Tag", + "job_in_progress": "Modification is being processed", + "modify_button_title": "Modify", + "modify_modal_title": "Modify", + "modify_series_mode_duplicate_html": "Create a modified copy of the original series. (generating new DICOM UIDs and keeping the original series)", + "modify_series_mode_keep_uids_html": "Modify the original series. (keeping the original DICOM UIDs)", + "modify_series_mode_new_uids_html": "Modify the original series. (generating new DICOM UIDs)", + "modify_study_mode_duplicate_html": "Create a modified copy of the original study. (generating new DICOM UIDs and keeping the original study)", + "modify_study_mode_keep_uids_html": "Modify the original study. (keeping the original DICOM UIDs)", + "modify_study_mode_new_uids_html": "Modify the original study. (generating new DICOM UIDs)", + "remove_tag_tooltip": "Remove tag", + "remove_tag_undo_tooltip": "Undo remove tag", + "series_step_0_attach_series_to_existing_study_button_title_html": "Change study", + "series_step_0_attach_series_to_existing_study_html": "Move this series to an existing Study.", + "series_step_0_create_new_study_button_title_html": "Create new study", + "series_step_0_create_new_study_html": "Move this series to a new study.", + "series_step_0_modify_series_button_title_html": "Modify series tags", + "series_step_0_modify_series_html": "Modify Series tags in this series only?", + "show_modified_resources": "Show modified resources", + "study_step_0_attach_study_to_existing_patient_button_title_html": "Change patient", + "study_step_0_attach_study_to_existing_patient_html": "Attach this study to another existing Patient.", + "study_step_0_modify_study_button_title_html": "Modify Study tags", + "study_step_0_modify_study_html": "Modify Patient/Study tags in this study only?", + "study_step_0_patient_has_other_studies_button_title_html": "Modify Patient tags", + "study_step_0_patient_has_other_studies_html": "This patient has {count} studies in total.
Do you want to modify the patient in all these studies?", + "warning_create_new_study_from_series_html": "A patient with the same PatientID already exists with differing tags. Do you want to use the existing PatientName, PatientSex and PatientBirthDate?" + }, + "my_jobs": "My jobs", + "no_modalities": "None", + "no_result_found": "No result found!", + "not_showing_all_results": "Not showing all results. You should refine your search criteria", + "open": "Open", + "page_not_found": "Page not found!", + "patients": "Patients", + "plugin": "plugin", + "plugins": { + "delayed_deletion": { + "pending_files_count": "Delayed Deletion plugin: Files to delete" + } + }, + "preview": "Preview", + "profile": "Profile", + "retrieve": "Retrieve", + "retrieve_and_view": { + "finding_locally": "Checking if the study is already available locally.", + "finding_remotely": "Searching for the study in remote DICOM nodes.", + "not_found": "The study was not found neither locally nor in remote DICOM nodes.", + "retrieved_html": "Retrieved {count} instances.", + "retrieving": "Retrieving study." + }, + "remote_dicom_browsing": "You are currently browsing the {source} remote DICOM node", + "remote_dicom_web_browsing": "You are currently browsing the {source} remote DICOMWeb server", + "save": "Save", + "searching": "Searching...", + "select_files": "Select Files", + "select_folder": "Select Folder", + "send_to": { + "button_title": "Send", + "dicom": "Send to DICOM node", + "dicom_web": "Send to DICOMWeb server", + "orthanc_peer": "Send to Orthanc Peer", + "transfers": "Send to Orthanc Peer (advanced-transfers)" + }, + "series": "Series", + "series_count_header": "# series", + "series_and_instances_count_header": "# Ser/Inst", + "series_plural": "Series", + "settings": { + "allow_all_currents_and_futures_labels": "All current and future labels", + "available_labels_global_instructions_html": "Since you have enabled permissions and you are an administrator, this page enables you to create/delete the available labels. Users won't be able to create other labels.
Once you have updated this list, don't forget to click Save to apply your changes.", + "available_labels_title": "Available labels", + "create_new_label": "Create new label", + "dicom_AET": "DICOM AET", + "dicom_port": "DICOM Port", + "ingest_transcoding": "Ingest transcoding", + "installed_plugins": "Installed Plugins", + "labels_clear_selection": "Clear selection", + "labels_description_html": "Labels are created/deleted in the settings/Labels page.", + "labels_select_all_currents": "Select all currently defined labels", + "labels_limit_available_labels": "Limit available labels to a list", + "labels_list_empty": "The labels list is currently empty", + "labels_based_permissions_title": "Labels based permissions", + "labels_title": "Labels", + "global_permissions_title": "Global permissions", + "orthanc_name": "Orthanc Name", + "orthanc_system_info": "Orthanc System Info", + "orthanc_version": "Orthanc Version", + "overwrite_instances": "Overwrite instances", + "permissions": "Permissions", + "permissions_clear_selection": "Clear selection", + "permissions_global_instructions_html": "Edit the permissions below and click Save to apply your modifications.
For each role, select the labels whose access is allowed and the allowed permissions.", + "permissions_instructions": "The permissions are statically defined in the authorization-plugin configuration.", + "read_only": "Read only system", + "select_all_label_permissions": "Select all label permissions", + "select_all_global_permissions": "Select all global permissions", + "plugins_not_enabled": "Plugins that are loaded but not enabled or not configured correctly are ", + "roles_title": "Roles", + "roles_description_html": "The roles are created/deleted in Keycloak", + "statistics": "Statistics", + "storage_compression": "Storage Compression", + "storage_size": "Storage Size", + "striked_through": "striked-through", + "system_info": "System info", + "title": "Settings", + "verbosity_level": "Verbosity Level" + }, + "share": { + "anonymize": "Anonymize?", + "button_title": "Share", + "copy_and_close": "Copy and close", + "days": "days", + "expires_in": "Expires in", + "link": "Link", + "modal_title": "Share study", + "modal_title_multiple_studies": "Share {count} studies", + "never": "never" + }, + "show_errors": "Show errors", + "studies": "Studies", + "study": "Study", + "this_patient_has_no_other_studies": "This patient has no other studies.", + "this_patient_has_other_studies": "This patient has {count} studies in total.", + "this_patient_has_other_studies_show": "Show them!", + "this_remote_patient_has_local_studies": "This patient has {count} studies already stored locally.", + "this_study_is_already_stored_locally": "This study is already stored locally.", + "this_study_is_already_stored_locally_show": "Show it!", + "token": { + "error_token_expired_html": "Your token has expired.", + "error_token_invalid_html": "Your token is invalid.
Check if you have pasted it completely, or contact the person who has provided it to you.", + "error_token_unknown_html": "Your token is invalid.
Check if you have pasted it completely, or contact the person who has provided it to you.", + "token_being_checked_html": "Your token is being checked." + }, + "trace": "Trace", + "upload": "Upload", + "uploaded_studies": "Uploaded studies", + "verbose": "Verbose", + "view_in_meddream": "View in MedDream", + "view_in_ohif": "View in OHIF", + "view_in_ohif_microscopy": "View in OHIF Microscopy mode", + "view_in_ohif_seg": "View in OHIF Segmentation mode", + "view_in_ohif_tmtv": "View in OHIF Total Metabolic Tumor Volume mode", + "view_in_ohif_vr": "View in OHIF Volume Rendering mode", + "view_in_osimis": "View in OsimisViewer", + "view_in_stone": "View in StoneViewer", + "view_in_volview": "View in VolView", + "view_in_wsi_viewer": "View in Whole Slide Imaging Viewer" +} \ No newline at end of file diff --git a/WebApplication/src/locales/es.json b/WebApplication/src/locales/es.json new file mode 100644 index 0000000..abd4dce --- /dev/null +++ b/WebApplication/src/locales/es.json @@ -0,0 +1,190 @@ +{ + "all_modalities": "Todos", + "anonymize": "Anonimizar", + "cancel": "Cancelar", + "change_password": "Cambiar la contraseña", + "close": "Cerrar", + "copy_orthanc_id": "Copiar Orthanc ID", + "date_picker": { + "last_12_months": "Últimos 12 meses", + "last_month": "El mes pasado", + "last_week": "La semana pasada", + "this_month": "Este mes", + "this_week": "Este semana", + "today": "Hoy", + "yesterday": "Ayer" + }, + "default": "Predeterminado", + "delete": "Eliminar", + "delete_instance_body": "¿Estás seguro de que quieres eliminar este elemento?
Esta acción no se puede deshacer!", + "delete_instance_title": "¿Eliminar elemento?", + "delete_series_body": "¿Estás seguro de que quieres eliminar esta serie?
Esta acción no se puede deshacer!", + "delete_series_title": "¿Eliminar serie?", + "delete_studies_body": "¿Estás seguro de que quieres eliminar estos estudios?
Esta acción no se puede deshacer!", + "delete_studies_title": "¿Eliminar estudios?", + "delete_study_body": "¿Estás seguro de que quieres eliminar este estudio?
Esta acción no se puede deshacer!", + "delete_study_title": "¿Eliminar estudio?", + "description": "Descripción", + "dicom_modalities": "Modalidades DICOM", + "dicom_tags": { + "AccessionNumber": "Número de acceso", + "BodyPartExamined": "Parte del cuerpo examinada", + "InstanceNumber": "Número de elemento", + "InstitutionName": "Nombre de la institucion", + "ModalitiesInStudy": "Modalidades en Estudio", + "Modality": "Modalidad", + "NumberOfFrames": "Número de cuadros", + "NumberOfStudyRelatedSeries": "Recuento de serie", + "PatientBirthDate": "Fecha de nacimiento del paciente", + "PatientID": "ID del paciente", + "PatientName": "Nombre del paciente", + "PatientSex": "Sexo del paciente", + "ProtocolName": "Nombre del protocolo", + "ReferringPhysicianName": "Nombre del médico de referencia", + "RequestingPhysician": "Médico solicitante", + "SeriesDate": "Fecha de la serie", + "SeriesDescription": "Descripción de la serie", + "SeriesInstanceUID": "Series Instance UID", + "SeriesNumber": "Número de serie", + "SeriesTime": "Hora de la serie", + "StudyDate": "Fecha del estudio", + "StudyDescription": "Descripción del estudio", + "StudyID": "Identificación del estudio", + "StudyInstanceUID": "Study Instance UID", + "StudyTime": "Hora de estudio", + "seriesCount": "Recuento de serie" + }, + "dicom_web_servers": "Servidores DICOM-Web", + "displaying_latest_studies": "Se muestran los estudios más recientes", + "download_dicom_file": "Descargar archivo DICOM", + "download_dicomdir": "Descargar DICOMDIR", + "download_zip": "Descargar ZIP", + "drop_files": "Soltar archivos aquí o", + "enter_search": "¡Ingrese un criterio de búsqueda para mostrar resultados!", + "error": "Error", + "file": "Archivo", + "files": "archivos", + "frames": "cuadros", + "instance": "Elemento", + "instances": "Elementos", + "instances_number": "Número de elementos", + "legacy_ui": "IU heredada", + "loading_latest_studies": "Cargando estudios más recientes", + "local_studies": "Estudios locales", + "logout": "Cerrar sesión", + "mammography_plugin": "Start mammogram AI", + "modalities_in_study": "Modalidades en Estudio", + "modify": { + "anonymize_button_title": "Anonimizar", + "anonymize_modal_title": "Anonimizar", + "autogenerated_dicom_uid": "Auto generado", + "back_button_title": "Atrás", + "error_attach_series_to_existing_study_target_does_not_exist_html": "Error al cambiar de serie, no se encontró ningún estudio con este StudyInstanceUID.", + "error_attach_series_to_existing_study_target_unchanged_html": "Error al cambiar de serie, el estudio de destino es el mismo que el estudio de la serie actual.", + "error_attach_study_to_existing_patient_target_does_not_exist_html": "Error al cambiar de paciente, no se encontró ningún paciente con este ID de paciente. Modificar etiquetas de estudio función en su lugar.", + "error_modify_any_study_tags_can_not_modify_patient_tags_because_of_other_studies_html": "Error al modificar etiquetas de estudio: este paciente tiene otros estudios. Modificar etiquetas de pacientes función en su lugar.", + "error_modify_any_study_tags_patient_exists_html": "Error al modificar las etiquetas del estudio: ya existe otro paciente con el mismo ID de paciente. Cambiar de paciente función en su lugar.", + "error_modify_patient_tags_another_patient_exists_with_same_patient_id_html": "Error al modificar las etiquetas de un paciente: ya existe otro paciente con el mismo ID de paciente. Modificar etiquetas de pacientes función en su lugar.", + "error_modify_unexpected_error_html": "Error inesperado durante la modificación, verifique los registros de Orthanc", + "insert_tag": "Insertar una etiqueta DICOM", + "job_in_progress": "Se está procesando la modificación", + "modify_button_title": "Modificar", + "modify_modal_title": "Modificar", + "modify_study_mode_duplicate_html": "Crear una copia modificada del estudio original. (generando nuevos DICOM UIDs y manteniendo el estudio original)", + "modify_study_mode_keep_uids_html": "Modificar el estudio original. (manteniendo los DICOM UIDs originales)", + "modify_study_mode_new_uids_html": "Modificar el estudio original. (generando nuevos DICOM UIDs)", + "remove_tag_tooltip": "Eliminar etiqueta", + "remove_tag_undo_tooltip": "Deshacer eliminar etiqueta", + "series_step_0_attach_series_to_existing_study_button_title_html": "Cambiar de estudio", + "series_step_0_attach_series_to_existing_study_html": "Mover esta serie a un estudio existente.", + "series_step_0_create_new_study_button_title_html": "Crear nuevo estudio", + "series_step_0_create_new_study_html": "Mover esta serie a un nuevo estudio.", + "series_step_0_modify_series_button_title_html": "Modificar etiquetas de serie", + "series_step_0_modify_series_html": "¿Modificar etiquetas de serie solo en esta serie?", + "show_modified_resources": "Mostrar recursos modificados", + "study_step_0_attach_study_to_existing_patient_button_title_html": "Cambiar de paciente", + "study_step_0_attach_study_to_existing_patient_html": "Adjuntar este estudio a otro paciente existente.", + "study_step_0_modify_study_button_title_html": "Modificar etiquetas de estudio", + "study_step_0_modify_study_html": "¿Modificar etiquetas de paciente/estudio solo en este estudio?", + "study_step_0_patient_has_other_studies_button_title_html": "Modificar etiquetas de pacientes", + "study_step_0_patient_has_other_studies_html": "Este paciente tiene {count} estudios en total.
¿Quieres modificar al paciente en todos estos estudios?", + "warning_create_new_study_from_series_html": "Ya existe un paciente con el mismo ID de paciente con etiquetas diferentes. ¿Desea utilizar las etiquetas PatientName, PatientSex and PatientBirthDate existentes?" + }, + "my_jobs": "Mis trabajos", + "no_modalities": "Ninguno", + "no_result_found": "¡No se encontraron resultados!", + "not_showing_all_results": "No se muestran todos los resultados. Debes afinar tus criterios de búsqueda. ", + "open": "Abrir", + "page_not_found": "¡Página no encontrada!", + "plugin": "Complemento", + "preview": "Vista previa", + "profile": "Perfil", + "retrieve_and_view": { + "finding_locally": "Verificando si el estudio está disponible localmente.", + "finding_remotely": "Buscando el estudio en nodos DICOM remotos.", + "not_found": "El estudio no se encontró ni localmente ni en nodos DICOM remotos.", + "retrieved_html": "Se recuperaron {count} elementos.", + "retrieving": "Recuperando estudio." + }, + "searching": "Buscando...", + "select_files": "Seleccionar Archivos", + "select_folder": "Seleccionar Carpeta", + "send_to": { + "button_title": "Enviar", + "dicom": "Enviar a nodo DICOM", + "dicom_web": "Enviar a DICOM-Web", + "orthanc_peer": "Enviar a un par", + "transfers": "Enviar a un par (Transferencias avanzadas)" + }, + "series": "Serie", + "series_count_header": "# serie", + "series_plural": "Series", + "settings": { + "dicom_AET": "DICOM AET", + "dicom_port": "Puerto DICOM", + "ingest_transcoding": "Transcodificación adaptable", + "installed_plugins": "Complementos instalados", + "orthanc_name": "Nombre original", + "orthanc_system_info": "Información del sistema Orthanc", + "orthanc_version": "Versión original", + "overwrite_instances": "Sobrescribir elementos", + "plugins_not_enabled": "Los complementos que están cargados pero no habilitados o configurados correctamente están ", + "statistics": "Estadísticas", + "storage_compression": "Compresión de almacenamiento", + "storage_size": "Tamaño de almacenamiento", + "striked_through": "tachado", + "title": "Configuraciones", + "verbosity_level": "Nivel de Verbosidad" + }, + "share": { + "anonymize": "¿Anonimizar?", + "button_title": "Compartir", + "copy_and_close": "Copiar y cerrar", + "days": "días", + "expires_in": "Expira en", + "link": "Enlace", + "modal_title": "Compartir estudio", + "never": "nunca" + }, + "show_errors": "Mostrar errores", + "studies": "Estudios", + "study": "Estudio", + "this_patient_has_no_other_studies": "Este paciente no tiene otros estudios.", + "this_patient_has_other_studies": "Este paciente tiene {count} estudios en total.", + "this_patient_has_other_studies_show": "Mostrarlos!", + "token": { + "error_token_expired_html": "Tu token ha caducado.", + "error_token_invalid_html": "Tu token es inválido.
Comprueba que lo has pegado por completo o contacta a la persona que te lo ha facilitado.", + "error_token_unknown_html": "Tu token es inválido.
Comprueba que lo has pegado por completo o contacta a la persona que te lo ha facilitado.", + "token_being_checked_html": "Tu token está siendo verificado." + }, + "trace": "Rastreo", + "upload": "Cargar", + "uploaded_studies": "Estudios cargados", + "verbose": "Detallado", + "view_in_meddream": "Ver en MedDream", + "view_in_ohif": "Ver en OHIF", + "view_in_osimis": "Ver en OsimisViewer", + "view_in_stone": "Ver en StoneViewer", + "view_in_volview": "Ver en VolView" +} \ No newline at end of file diff --git a/WebApplication/src/locales/fr.json b/WebApplication/src/locales/fr.json new file mode 100644 index 0000000..26d3b02 --- /dev/null +++ b/WebApplication/src/locales/fr.json @@ -0,0 +1,270 @@ +{ + "add_series": { + "button_title": "Ajouter une série", + "drop_file": "Déposez ici un fichier PDF, image ou STL", + "error_add_series_unexpected_error_html": "Erreur inattendue lors de l'ajout de la sérier', vérifiez les logs d'Orthanc", + "modal_title": "Ajouter une nouvelle série à l'examen", + "select_file": "Choisir un fichier", + "unrecognized_file_format": "Format de fichier non reconnu. Seuls les format PDF, images (JPG et PNG) et STL sont supportés.", + "uploaded_file": "Le fichier {name} ({size}) est de type {type}." + }, + "all_modalities": "Toutes", + "anonymize": "Anonymiser", + "cancel": "Annuler", + "change_password": "Changer le MDP", + "close": "Fermer", + "copy_orthanc_id": "Copier l'identifiant Orthanc", + "date_picker": { + "last_12_months": "Les 12 derniers mois", + "last_month": "Le mois dernier", + "last_week": "La semaine dernière", + "this_month": "Ce mois-ci", + "this_week": "Cette semaine", + "today": "Aujourd'hui", + "yesterday": "Hier" + }, + "default": "Par défaut", + "delete": "Supprimer", + "delete_instance_body": "Êtes vous sûr de vouloir supprimer cette instance ?
Cette opération est définitive.", + "delete_instance_title": "Supprimer l'instance ?", + "delete_series_body": "Êtes vous sûr de vouloir supprimer cette série ?
Cette opération est définitive.", + "delete_series_title": "Supprimer la série ?", + "delete_studies_body": "Êtes vous sûr de vouloir supprimer ces examens ?
Cette opération est définitive.", + "delete_studies_title": "Supprimer les examens ?", + "delete_study_body": "Êtes vous sûr de vouloir supprimer cet examen ?
Cette opération est définitive.", + "delete_study_title": "Supprimer l'examen ?", + "description": "Description", + "dicom_modalities": "Modalités DICOM", + "dicom_tags": { + "AccessionNumber": "Numéro d'accès", + "BodyPartExamined": "Partie du corps examinée", + "InstanceNumber": "Numéro d'instance", + "InstitutionName": "Nom de l'établissement", + "ModalitiesInStudy": "Modalités", + "Modality": "Modalité", + "NumberOfFrames": "Nombre d'images", + "NumberOfStudyRelatedSeries": "Nombre de séries", + "OtherPatientIDs": "Autres ID Patient", + "PatientBirthDate": "Date de naissance", + "PatientID": "ID Patient", + "PatientName": "Nom", + "PatientSex": "Sexe", + "ProtocolName": "Nom du protocole", + "ReferringPhysicianName": "Nom du médecin référent", + "RequestingPhysician": "Médecin demandeur", + "SOPInstanceUID": "SOP Instance UID", + "SeriesDate": "Date de la série", + "SeriesDescription": "Description", + "SeriesInstanceUID": "Series Instance UID", + "SeriesNumber": "Numéro de série", + "SeriesTime": "Heure de la série", + "StudyDate": "Date de l'examen", + "StudyDescription": "Description", + "StudyID": "ID de l'examen", + "StudyInstanceUID": "Study Instance UID", + "StudyTime": "Heure de l'examen", + "seriesCount": "Nombre de séries" + }, + "dicom_web_servers": "Serveurs Web DICOM", + "displaying_latest_studies": "Liste des examens les plus récents", + "download_dicom_file": "Télécharger le fichier DICOM", + "download_dicomdir": "Télécharger DICOMDIR", + "download_zip": "Télécharger ZIP", + "drop_files": "Déposez les fichiers ici ou", + "enter_search": "Entrez un critère de recherche pour afficher les résultats !", + "error": "Erreur", + "file": "Fichier", + "files": "fichiers", + "frames": "Frames", + "instance": "Élément", + "instances": "Instances", + "instances_count_header": "# instances", + "instances_number": "Nombre d'instances", + "job_success": "Succès", + "job_failure": "Échec", + "labels": { + "add_button": "Ajouter", + "add_labels_message_html": "Ajouter ces étiquettes aux examens sélectionnés", + "add_labels_placeholder": "Ajouter des étiquettes, appuyer sur Enter pour en créer de nouvelles", + "add_labels_placeholder_no_create": "Ajouter des étiquettes", + "added_labels_message_part_1_html": "Les étiquettes ", + "added_labels_message_part_2_html": " ont été ajoutées aux {count} examens", + "clear_all_button": "Tout effacer", + "clear_all_labels_message_html": "Effacer toutes les étiquettes des examens sélectionnés", + "cleared_labels_message_part_1_html": "Les étiquettes ", + "cleared_labels_message_part_2_html": " ont été supprimées de {count} examens", + "edit_labels_button": "Modifier les étiquettes", + "modal_title": "Modifier les étiquettes dans les examens sélectionnés", + "remove_button": "Supprimer", + "remove_labels_message_html": "Supprimer ces étiquettes des examens sélectionnés", + "remove_labels_placeholder": "Étiquettes à supprimer", + "removed_labels_message_part_1_html": "Les étiquettes ", + "removed_labels_message_part_2_html": " ont été supprimées de {count} examens", + "study_details_title": "Étiquettes", + "valid_alphabet_warning": "Seuls les caractères suivant sont autorisé : lettres sans accents, chiffres, - et _" + }, + "legacy_ui": "Ancienne interface", + "loading_latest_studies": "Chargement des examens les plus récents", + "local_studies": "Tous les examens", + "logout": "Se déconnecter", + "mammography_plugin": "Start mammogram AI", + "modalities_in_study": "Modalités dans l'examen", + "modify": { + "anonymize_button_title": "Anonymiser", + "anonymize_modal_title": "Anonymiser", + "autogenerated_dicom_uid": "DICOM UID autogénéré", + "back_button_title": "Précédent", + "error_attach_series_to_existing_study_target_does_not_exist_html": "Impossible de modifier la série, aucun examen trouvé avec ce StudyInstanceUID.", + "error_attach_series_to_existing_study_target_unchanged_html": "Impossible de modifier la série, l'examen de destination est le même que l'examen de la série actuelle.", + "error_attach_study_to_existing_patient_target_does_not_exist_html": "Erreur lors de la modification du patient, aucun patient trouvé avec cet identifiant. Utilisez plutôt la fonction Modifier les tags de l'examen.", + "error_modify_any_study_tags_can_not_modify_patient_tags_because_of_other_studies_html": "Erreur lors de la modification des tags de l'examen : ce patient possède d'autres examens. Utilisez plutôt la fonction Modifier les tags du Patient.", + "error_modify_any_study_tags_patient_exists_html": "Erreur lors de la modification des tags de l'examen : un autre patient existe déjà avec le même identifiant. Utilisez plutôt la fonction Changer de patient.", + "error_modify_patient_tags_another_patient_exists_with_same_patient_id_html": "Erreur lors de la modification des tags du patient : un autre patient existe déjà avec le même identifiant. Utilisez plutôt la fonction Modifier les tags du Patient.", + "error_modify_unexpected_error_html": "Erreur inattendue lors de la modification, vérifiez les logs d'Orthanc", + "insert_tag": "Insérer un tag DICOM", + "job_in_progress": "La modification est en cours de traitement", + "modify_button_title": "Modifier", + "modify_modal_title": "Modifier", + "modify_series_mode_duplicate_html": "Créer une copie modifiée de la série originale. (en générant de nouveaux UID DICOM et en conservant la série originale)", + "modify_series_mode_keep_uids_html": "Modifier la série originale. (en conservant les UID DICOM d'origine)", + "modify_series_mode_new_uids_html": "Modifier la série originale. (en générant de nouveaux UID DICOM)", + "modify_study_mode_duplicate_html": "Créer une copie modifiée de l'examen original. (en générant de nouveaux UID DICOM et en conservant l'examen original)", + "modify_study_mode_keep_uids_html": "Modifier l'examen original. (en conservant les UID DICOM d'origine)", + "modify_study_mode_new_uids_html": "Modifier l'examen original. (en générant de nouveaux UID DICOM)", + "remove_tag_tooltip": "Supprimer le tag", + "remove_tag_undo_tooltip": "Annuler la suppression du tag", + "series_step_0_attach_series_to_existing_study_button_title_html": "Déplacez dans un examen existant", + "series_step_0_attach_series_to_existing_study_html": "Déplacez cette série vers un examen existant.", + "series_step_0_create_new_study_button_title_html": "Créer un nouvel examen", + "series_step_0_create_new_study_html": "Déplacez cette série dans un nouvel examen.", + "series_step_0_modify_series_button_title_html": "Modifier les tags de la série", + "series_step_0_modify_series_html": "Modifier les tags relatifs à la série uniquement dans cette série ?", + "show_modified_resources": "Afficher les ressources modifiées", + "study_step_0_attach_study_to_existing_patient_button_title_html": "Changer de patient", + "study_step_0_attach_study_to_existing_patient_html": "Attachez cet examen à un autre patient existant.", + "study_step_0_modify_study_button_title_html": "Modifier les tags de l'examen", + "study_step_0_modify_study_html": "Modifier les tags relatif au patient et à l'examen uniquement dans cet examen ?", + "study_step_0_patient_has_other_studies_button_title_html": "Modifier les tags du Patient", + "study_step_0_patient_has_other_studies_html": "Ce patient a {count} examen au total.
Voulez-vous modifier le patient dans tous ces examens ?", + "warning_create_new_study_from_series_html": "Un patient avec le même identifiant existe déjà avec des tags différents. Voulez-vous utiliser les nom, sexe et date de naissance du patient existant ?" + }, + "my_jobs": "Mes jobs", + "no_modalities": "Aucune", + "no_result_found": "Aucun résultat trouvé !", + "not_showing_all_results": "Tous les résultats ne sont pas affichés. Veuillez affiner vos critères de recherche", + "open": "Ouvrir", + "page_not_found": "Page introuvable !", + "patients": "Patients", + "plugin": "Plugin", + "plugins": { + "delayed_deletion": { + "pending_files_count": "Delayed Deletion plugin: Fichiers à effacer" + } + }, + "preview": "Aperçu", + "profile": "Profil", + "retrieve": "Rapatrier", + "retrieve_and_view": { + "finding_locally": "Recherche de l'examen en local.", + "finding_remotely": "Recherche de l'examen dans les modalités DICOM.", + "not_found": "Cet examen n'a pu être trouvé ni en local ni dans les modalités DICOM.", + "retrieved_html": "{count} instances récupérées.", + "retrieving": "L'examen est en cours de récupération." + }, + "remote_dicom_browsing": "Vous explorez actuellement le contenu du noeud DICOM {source}", + "remote_dicom_web_browsing": "Vous explorez actuellement le contenu du serveur DICOMWeb {source}", + "save": "Enregistrer", + "searching": "Recherche...", + "select_files": "Choisir des fichiers", + "select_folder": "Choisir un dossier", + "send_to": { + "button_title": "Envoyer", + "dicom": "Envoyer vers un noeud DICOM", + "dicom_web": "Envoyer vers un serveur DICOMWeb", + "orthanc_peer": "Envoyer à un peer Orthanc", + "transfers": "Envoyer à un peer Orthanc (advanced-transfers)" + }, + "series": "Série", + "series_count_header": "# séries", + "series_and_instances_count_header": "# Ser/Inst", + "series_plural": "Séries", + "settings": { + "allow_all_currents_and_futures_labels": "Toutes les étiquettes actuelles et futures", + "available_labels_global_instructions_html": "Les permissions étant activées, cette page vous permet de modifier la liste des étiquettes disponibles. Les autres utilisateurs ne pourront pas créer de nouvelles étiquettes.
N'oubliez pas d'enregistrer vos modifications.", + "available_labels_title": "Étiquettes disponibles", + "create_new_label": "Créer une étiquette", + "dicom_AET": "DICOM AET", + "dicom_port": "Port DICOM", + "ingest_transcoding": "Transcodage à la réception", + "installed_plugins": "Plugins installés", + "labels_clear_selection": "Vider la sélection", + "labels_description_html": "Les étiquettes sont créées dans la pages Paramètres/Étiquettes.", + "labels_select_all_currents": "Sélectionner toutes les étiquettes actuellement disponibles.", + "labels_limit_available_labels": "Restreindre les étiquettes à une liste", + "labels_list_empty": "La liste des étiquettes est actuellement vide", + "labels_based_permissions_title": "Permissions basées sur les étiquettes", + "labels_title": "Étiquettes", + "global_permissions_title": "Permissions globales", + "orthanc_name": "Nom de l'Orthanc", + "orthanc_system_info": "Informations système Orthanc", + "orthanc_version": "Version d'Orthanc", + "overwrite_instances": "Écraser les instances", + "permissions": "Permissions", + "permissions_clear_selection": "Vider la sélection", + "permissions_global_instructions_html": "Éditer les permissions ci-dessous et cliquez sur Enregistrer pour appliquer les modifications.
Pour chaque rôle, sélectionnez les étiquettes qui seront accessibles et les actions autorisées sur ces examens.", + "permissions_instructions": "La liste de permission ne peut être modifiée; elle est définie dans le plugin authorization.", + "plugins_not_enabled": "Les plugins qui sont chargés mais non-activés ou configurés correctement sont ", + "read_only": "Système en lecture seule", + "roles_title": "Rôles", + "roles_description_html": "Les rôles sont créés et modifiés dans Keycloak", + "select_all_label_permissions": "Sélectionner toutes les permissions basées sur les étiquettes", + "select_all_global_permissions": "Sélectionner toutes les permissions globales", + "system_info": "Système", + "statistics": "Statistiques", + "storage_compression": "Compression du stockage", + "storage_size": "Espace utilisé", + "striked_through": "barrés", + "title": "Paramètres", + "verbosity_level": "Niveau de verbosité des logs" + }, + "share": { + "anonymize": "Anonymiser ?", + "button_title": "Partager", + "copy_and_close": "Copier et fermer", + "days": "jours", + "expires_in": "Expire dans", + "link": "Lien", + "modal_title": "Partager l'examen", + "modal_title_multiple_studies": "Partager {count} examens", + "never": "jamais" + }, + "show_errors": "Afficher les erreurs", + "studies": "Examens", + "study": "Examen", + "this_patient_has_no_other_studies": "Ce patient n'a pas d'autres examens.", + "this_patient_has_other_studies": "Ce patient a {count} examens au total.", + "this_patient_has_other_studies_show": "Les afficher !", + "this_remote_patient_has_local_studies": "Ce patient a déjà {count} examens stockés en local.", + "this_study_is_already_stored_locally": "Cet examen est déjà stocké en local.", + "this_study_is_already_stored_locally_show": "L'afficher !", + "token": { + "error_token_expired_html": "Votre lien a expiré.", + "error_token_invalid_html": "Votre lien n'est pas valide.
Vérifiez que vous l'avez collé complètement ou contactez la personne qui vous l'a fourni.", + "error_token_unknown_html": "Votre lien n'est pas valide.
Vérifiez que vous l'avez collé complètement ou contactez la personne qui vous l'a fourni.", + "token_being_checked_html": "Votre lien est en cours de vérification." + }, + "trace": "Trace", + "upload": "Importer", + "uploaded_studies": "Examens importés", + "verbose": "Verbose", + "view_in_meddream": "Visualiser avec MedDream", + "view_in_ohif": "Visualiser avec OHIF", + "view_in_ohif_microscopy": "Visualiser avec OHIF en mode Microscopie", + "view_in_ohif_seg": "Visualiser avec OHIF en mode Segmentation", + "view_in_ohif_tmtv": "Visualiser avec OHIF en mode Total Metabolic Tumor Volume", + "view_in_ohif_vr": "Visualiser avec OHIF en mode Volume Rendering", + "view_in_osimis": "Visualiser avec le OsimisViewer", + "view_in_stone": "Visualiser avec le StoneViewer", + "view_in_volview": "Visualiser avec VolView", + "view_in_wsi_viewer": "Visualiser avec le Whole Slide Imaging Viewer" +} \ No newline at end of file diff --git a/WebApplication/src/locales/i18n.js b/WebApplication/src/locales/i18n.js new file mode 100644 index 0000000..3f5ecd5 --- /dev/null +++ b/WebApplication/src/locales/i18n.js @@ -0,0 +1,48 @@ +import { createI18n } from "vue-i18n"; +import en from "./en.json"; +import de from "./de.json"; +import es from "./es.json"; +import fr from "./fr.json"; +import it from "./it.json"; +import ka from "./ka.json"; +import ru from "./ru.json"; +import si from "./si.json"; +import uk from "./uk.json"; +import zh from "./zh.json"; + +const i18n = createI18n({ + warnHtmlInMessage: 'off', + locale: 'en', // when the list of availableLanguages is loaded, this value is updated in LanguagePicker.isConfigurationLoaded + fallbackLocale: 'en', + messages: { + en, + de, + es, + fr, + it, + ka, + ru, + si, + uk, + zh + }, +}); + +document._mustTranslateDicomTags = false; + +function translateDicomTag($t, $te, tagName) { + if (document._mustTranslateDicomTags) { + if ($te('dicom_tags.' + tagName)) { + return $t('dicom_tags.' + tagName) + } else { + return tagName; + } + } else { + return tagName; + } +} + +export { + i18n as default, + translateDicomTag +}; diff --git a/WebApplication/src/locales/it.json b/WebApplication/src/locales/it.json new file mode 100644 index 0000000..3781487 --- /dev/null +++ b/WebApplication/src/locales/it.json @@ -0,0 +1,190 @@ +{ + "all_modalities": "Tutte le modalità", + "anonymize": "Anonimizzare", + "cancel": "Annulla", + "change_password": "Cambia password", + "close": "Chiudi", + "copy_orthanc_id": "Copia Orthanc ID", + "date_picker": { + "last_12_months": "12 Mesi precedenti ", + "last_month": "Mese Precedente", + "last_week": "Scorsa settimana", + "this_month": "Questo mese", + "this_week": "Questa settimana", + "today": "Oggi", + "yesterday": "Ieri" + }, + "default": "Predefinito", + "delete": "Cancella", + "delete_instance_body": "Sei sicuro di voler cancellare questa istanza?
Questa azione non potrà essere annullata!", + "delete_instance_title": "Cancellare istanza?", + "delete_series_body": "Sei sicuro di voler cancellare la serie?
Questa azione non potrà essere annullata!", + "delete_series_title": "Cancellare la serie?", + "delete_studies_body": "Sei sicuro di voler cancellare questi studi?
Questa azione non potrà essere annullata!", + "delete_studies_title": "Cancellare gli studi?", + "delete_study_body": "Sei sicuro di voler cancellare lo studio?
Questa azione non potrà essere annullata!", + "delete_study_title": "Cancellare lo Studio?", + "description": "Descrizione", + "dicom_modalities": "DICOM Modalità", + "dicom_tags": { + "AccessionNumber": "Numero Accesso", + "BodyPartExamined": "Parte del corpo esaminata", + "InstanceNumber": "Numero Istanza", + "InstitutionName": "Nome Istituto", + "ModalitiesInStudy": "Modalità nello Studio", + "Modality": "Modalità", + "NumberOfFrames": "Numero immagini", + "NumberOfStudyRelatedSeries": "Numero serie", + "PatientBirthDate": "Data di Nascita Paziente", + "PatientID": "ID Paziente", + "PatientName": "Nome Paziente", + "PatientSex": "Sesso Paziente", + "ProtocolName": "Nome Protocollo", + "ReferringPhysicianName": "Nome Medico Referimento", + "RequestingPhysician": "Medico Richiedente", + "SeriesDate": "Data Serie", + "SeriesDescription": "Descrizione Serie", + "SeriesInstanceUID": "Instanza UID Serie", + "SeriesNumber": "Numero Serie", + "SeriesTime": "Ora Serie", + "StudyDate": "Data Studio", + "StudyDescription": "Descrizione Studio", + "StudyID": "ID Studio", + "StudyInstanceUID": "Instanza UID Studio", + "StudyTime": "Ora Studio", + "seriesCount": "Numero di serie" + }, + "dicom_web_servers": "DICOM-Web Servers", + "displaying_latest_studies": "Visualizza studio più recente", + "download_dicom_file": "Scarica DICOM file", + "download_dicomdir": "Scarica DICOMDIR", + "download_zip": "Scarica ZIP", + "drop_files": "Trascina files qui oppure", + "enter_search": "Inserisci un criterio di ricerca per mostrare i risultati!", + "error": "Errore", + "file": "File", + "files": "files", + "frames": "immagini", + "instance": "Istanza", + "instances": "Istanze", + "instances_number": "Numero di istanze", + "legacy_ui": "Storica UI", + "loading_latest_studies": "Caricamento studio più recente", + "local_studies": "Studi Locali", + "logout": "Disconnettersi", + "mammography_plugin": "Start mammogram AI", + "modalities_in_study": "Modalità nello Studio", + "modify": { + "anonymize_button_title": "Anonimizzare", + "anonymize_modal_title": "Anonimizzare", + "autogenerated_dicom_uid": "Generato automaticamente", + "back_button_title": "Indietro", + "error_attach_series_to_existing_study_target_does_not_exist_html": "Errore nel cambiare la serie, nessun studio trovato con questa Instanza UID Studio.", + "error_attach_series_to_existing_study_target_unchanged_html": "Errore nel cambiare la serie, lo studio in oggetto è identico alla serie studio corrente.", + "error_attach_study_to_existing_patient_target_does_not_exist_html": "Errore nel cambiare il paziente, nessun paziente trovato con questo ID Paziente. Pobabilmente dovresti usare la funzione Modifica per le Etichette dello Studio.", + "error_modify_any_study_tags_can_not_modify_patient_tags_because_of_other_studies_html": "Errore nella modifica delle etichette Studio: ci sono altri studi per questo paziente. Dovresti usare la funzione Modifica etichette Paziente.", + "error_modify_any_study_tags_patient_exists_html": "Errore nella modifica delle etichette studio: esiste già un altro paziente con lo stesso ID Paziente. Dovresti usare la funzione Cambia paziente.", + "error_modify_patient_tags_another_patient_exists_with_same_patient_id_html": "Errore nella modifica delle etichette Paziente: esiste un altro paziente con lo stesso ID Paziente. Dovresti usare la funzione Modifica etichette Paziente.", + "error_modify_unexpected_error_html": "Errore inaspettato durante la modifica, verifica i log di Orthanc", + "insert_tag": "Inserisci un'etichetta DICOM", + "job_in_progress": "La modifica è in fase di elaborazione", + "modify_button_title": "Modifica", + "modify_modal_title": "Modifica", + "modify_study_mode_duplicate_html": "Creare una copia modificata dello studio originale. (generazione di un nuovo DICOM UIDs e mantenendo lo studio originale)", + "modify_study_mode_keep_uids_html": "Modifica lo studio originale. (mantenendo l'originale DICOM UIDs)", + "modify_study_mode_new_uids_html": "Modifica lo studio originale. (generazione di un nuovo DICOM UIDs)", + "remove_tag_tooltip": "Rimuovi etichetta", + "remove_tag_undo_tooltip": "Annulla rimuovi etichetta", + "series_step_0_attach_series_to_existing_study_button_title_html": "Cambia studio", + "series_step_0_attach_series_to_existing_study_html": "Sposta questa serie in uno studio esistente.", + "series_step_0_create_new_study_button_title_html": "Crea nuovo studio", + "series_step_0_create_new_study_html": "Sposta questa serie in un nuovo studio.", + "series_step_0_modify_series_button_title_html": "Modifica le etichette di serie", + "series_step_0_modify_series_html": "Modifica le etichette di serie solo in questa serie?", + "show_modified_resources": "Mostra risorse modificate", + "study_step_0_attach_study_to_existing_patient_button_title_html": "Cambia paziente", + "study_step_0_attach_study_to_existing_patient_html": "Allegare questo studio a un altro paziente esistente.", + "study_step_0_modify_study_button_title_html": "Modifica etichette Studio", + "study_step_0_modify_study_html": "Modifica etichette Paziente/Studio solo in questo studio?", + "study_step_0_patient_has_other_studies_button_title_html": "Modifica etichette Paziente", + "study_step_0_patient_has_other_studies_html": "Questo paziente ha {count} studi in totale.
vuoi moficare il paziente in tutti questi studi?", + "warning_create_new_study_from_series_html": "Un paziente con lo stesso ID Paziente esiste già con delle etichette differenti. Vuoi usare Nome Paziente, Sesso Paziente e Data di Nascita Paziente esistente?" + }, + "my_jobs": "I miei Lavori", + "no_modalities": "Nessuna", + "no_result_found": "Nessun risultato trovato!", + "not_showing_all_results": "Non vengono visualizzati tutti i risultati. Dovresti affinare i tuoi criteri di ricerca", + "open": "Apri", + "page_not_found": "Pagina non trovata!", + "plugin": "plugin", + "preview": "Anteprima", + "profile": "Profilo", + "retrieve_and_view": { + "finding_locally": "Verificare se lo studio è già disponibile localmente.", + "finding_remotely": "Ricerca dello studio nei nodi DICOM remoti.", + "not_found": "Lo studio non è stato trovato né localmente né in nodi DICOM remoti.", + "retrieved_html": "Recuperate {count} istanze.", + "retrieving": "Recupero dello studio." + }, + "searching": "Cercando...", + "select_files": "Seleziona Files", + "select_folder": "Seleziona Cartella", + "send_to": { + "button_title": "Invia", + "dicom": "Invia ad un nodo DICOM", + "dicom_web": "Invia ad un server DICOMWeb", + "orthanc_peer": "Invia ad un Peer Orthanc", + "transfers": "Invia ad un Peer Orthanc (trasferimento-avanzato)" + }, + "series": "Serie", + "series_count_header": "# serie", + "series_plural": "Serie", + "settings": { + "dicom_AET": "DICOM AET", + "dicom_port": "DICOM Porta", + "ingest_transcoding": "Transcodifica Ingest", + "installed_plugins": "Plugins Installato", + "orthanc_name": "Nome Orthanc", + "orthanc_system_info": "Informazioni di sistema Orthanc", + "orthanc_version": "Versione Orthanc", + "overwrite_instances": "Sovrascrivi istanze", + "plugins_not_enabled": "Plugins caricato non è abilitato oppure non è configurato correttamente", + "statistics": "Statistiche", + "storage_compression": "Compressione di archiviazione", + "storage_size": "Dimensioni di archiviazione", + "striked_through": "Colpito", + "title": "Impostazioni", + "verbosity_level": "Livello Prolisso" + }, + "share": { + "anonymize": "Anonimizzare?", + "button_title": "Condividi", + "copy_and_close": "Copia e Chiudi", + "days": "giorni", + "expires_in": "Scade tra", + "link": "Collegamento", + "modal_title": "Condividi studio", + "never": "mai" + }, + "show_errors": "mostra errori", + "studies": "Studi", + "study": "Studio", + "this_patient_has_no_other_studies": "Questo paziente non ha altri studi.", + "this_patient_has_other_studies": "Questo paziente ha {count} studi in totale.", + "this_patient_has_other_studies_show": "Mostra altri!", + "token": { + "error_token_expired_html": "Il tuo token è scaduto.", + "error_token_invalid_html": "Il tuo token non è valido.
Controlla di averlo incollato completamente o contatta la persona che te lo ha fornito.", + "error_token_unknown_html": "Il tuo token è sconosciuto.
Controlla di averlo incollato completamente o contatta la persona che te lo ha fornito.", + "token_being_checked_html": "Il tuo token è in fase di verifica." + }, + "trace": "Traccia", + "upload": "caricare", + "uploaded_studies": "Studi caricati", + "verbose": "Prolisso", + "view_in_meddream": "Visualizza con MedDream", + "view_in_ohif": "Visualizza con OHIF", + "view_in_osimis": "Visualizza con OsimisViewer", + "view_in_stone": "Visualizza con StoneViewer", + "view_in_volview": "Visualizza con VolView" +} \ No newline at end of file diff --git a/WebApplication/src/locales/ka.json b/WebApplication/src/locales/ka.json new file mode 100644 index 0000000..08dc1b4 --- /dev/null +++ b/WebApplication/src/locales/ka.json @@ -0,0 +1,190 @@ +{ + "all_modalities": "ყველა", + "anonymize": "ანონიმიზაცია", + "cancel": "გაუქმება", + "change_password": "პაროლის შეცვლა", + "close": "დახურვა", + "copy_orthanc_id": "Orthanc ID-ს კოპირება", + "date_picker": { + "last_12_months": "ბოლო 12 თვე", + "last_month": "წინა თვე", + "last_week": "წინა კვირა", + "this_month": "ეს თვე", + "this_week": "ეს კვირა", + "today": "დღეს", + "yesterday": "გუშინ" + }, + "default": "სტანდარტული", + "delete": "წაშლა", + "delete_instance_body": "ნამდვილად გსურთ ობიექტის წაშლა?
სურათის დაბრუნება შეუძლებელი იქნება", + "delete_instance_title": "ობიექტის წაშლა", + "delete_series_body": "ნამდვილად გსურთ სერიის წაშლა?
სერიის დაბრუნება შეუძლებელი იქნება", + "delete_series_title": "სერიის წაშლა", + "delete_studies_body": "ნამდვილად გსურთ კვლევების წაშლა?
კვლევის დაბრუნება შეუძლებელი იქნება", + "delete_studies_title": "კვლევების წაშლა", + "delete_study_body": "ნამდვილად გსურთ კვლევის წაშლა?
კვლევის დაბრუნება შეუძლებელი იქნება", + "delete_study_title": "კვლევის წაშლა", + "description": "აღწერა", + "dicom_modalities": "DICOM აპარატები", + "dicom_tags": { + "AccessionNumber": "რიგითობის ID", + "BodyPartExamined": "გამოკვლეული სხეულის ნაწილი", + "InstanceNumber": "ობიექტების #", + "InstitutionName": "დაწესებულება", + "ModalitiesInStudy": "აპარატები", + "Modality": "აპარატი", + "NumberOfFrames": "კადრები", + "NumberOfStudyRelatedSeries": "სერიების რაოდენობა", + "PatientBirthDate": "პაციენტის დ.თ.", + "PatientID": "პაციენტის ID", + "PatientName": "სახელი", + "PatientSex": "სქესი", + "ProtocolName": "პროტოკოლი", + "ReferringPhysicianName": "გამომგზავნი", + "RequestingPhysician": "დამკვეთი", + "SeriesDate": "სერიის თარიღი", + "SeriesDescription": "სერიის აღწერა", + "SeriesInstanceUID": "სერიის ობიექტის UID", + "SeriesNumber": "სერიის #", + "SeriesTime": "სერიის დრო", + "StudyDate": "თარიღი", + "StudyDescription": "კვლევის აღწერა", + "StudyID": "კვლევის ID", + "StudyInstanceUID": "კვლევის ობიექტის UID", + "StudyTime": "დრო", + "seriesCount": "სერიები" + }, + "dicom_web_servers": "DICOM-Web სერვერები", + "displaying_latest_studies": "ნაჩვენებია უახლესი კვლევები", + "download_dicom_file": "DICOM ფაილის გადმოწერა", + "download_dicomdir": "DICOMDIR გადმოწერა", + "download_zip": "ZIP გადმოწერა", + "drop_files": "დაყარეთ ფაილები აქ ან", + "enter_search": "რეზულტატის სანახავად შეიყვანეთ ძიების კრიტერიუმები", + "error": "შეცდომა", + "file": "ფაილი", + "files": "ფაილები", + "frames": "კადრები", + "instance": "სურათი", + "instances": "სურათები", + "instances_number": "სურათების რაოდენობა", + "legacy_ui": "ძველი ინტერფეისი", + "loading_latest_studies": "იტვირთება უახლესი კვლევები", + "local_studies": "ადგილობრივი კვლევები", + "logout": "გამოსვლა", + "mammography_plugin": "Start mammogram AI", + "modalities_in_study": "კვლევაში გამოყენებული აპარატები", + "modify": { + "anonymize_button_title": "ანონიმიზაცია", + "anonymize_modal_title": "ანონიმიზაცია", + "autogenerated_dicom_uid": "ავტომატურად გენერირებული", + "back_button_title": "უკან", + "error_attach_series_to_existing_study_target_does_not_exist_html": "დაფიქსირდა შეცდომა სერიის ცვლილების დროს, ამ კვლევის UID-თ კვლევა არ იძებნება.", + "error_attach_series_to_existing_study_target_unchanged_html": "დაფიქსირდა შეცდომა სერიის ცვლილებისას, სამიზნე კვლევა იგივეა რაც არსებული სერიის კვლევა.", + "error_attach_study_to_existing_patient_target_does_not_exist_html": "დაფიქსირდა შეცდომა პაციენტის ცვლილების დროს, პაციენტი ამ ID-თ არ იძებნება. სავარაუდოდ უნდა გამოიყენოთ კვლევის თეგების შეცვლის ფუნქცია.", + "error_modify_any_study_tags_can_not_modify_patient_tags_because_of_other_studies_html": "დაფიქსირდა შეცდომა კვლევის თეგების მოდიფიკაციის დროს: ამ პაციენტს უკვე აქვს სხვა კვლევები. უნდა გამოიყენოთ პაციენტის თეგების ცვლილების ფუნქცია.", + "error_modify_any_study_tags_patient_exists_html": "დაფიქსირდა შეცდომა კვლევის თეგების ცვლილების დროს. არსებობს სხვა პაციენტი იგივე პაციენტის ID-თ. სავარაუდოდ უნდა გამოიყენოთ პაციენტის ცვლილების ფუნქცია.", + "error_modify_patient_tags_another_patient_exists_with_same_patient_id_html": "დაფიქსირდა შეცდომა პაციენტის თეგების მოდიფიკაციის დროს: არსებობს სხვა პაციენტი იგივე პაციენტის ID-თ. უნდა გამოიყენოთ პაციენტის თეგების ცვლილების ფუნქცია.", + "error_modify_unexpected_error_html": "შეცდომა მოდიფიკაციის დროს, შეამოწმეთ Orthanc ლოგები", + "insert_tag": "DICOM თეგის დამატება", + "job_in_progress": "მოდიფიკაცია მუშავდება", + "modify_button_title": "ცვლილება", + "modify_modal_title": "ცვლილება", + "modify_study_mode_duplicate_html": "შეიქმნას საწყისი კვლევის მოდიფიცირებული ასლი. ( დაგენერირდეს ახალი DICOM UID-ები და შეინახოს საწყისი კვლევა)", + "modify_study_mode_keep_uids_html": "შეიცვალოს საწყისი კვლევა (დარჩეს საწყისი DICOM UID-ები)", + "modify_study_mode_new_uids_html": "შეიცვალოს საწყისი კვლევა (დაგენერირდეს ახალი DICOM UID-ებს)", + "remove_tag_tooltip": "თეგის წაშლა", + "remove_tag_undo_tooltip": "წაშლილი თეგის დაბრუნება", + "series_step_0_attach_series_to_existing_study_button_title_html": "კვლევის ცვლილება", + "series_step_0_attach_series_to_existing_study_html": "ამ სერიის არსებულ კვლევაში გადატანა.", + "series_step_0_create_new_study_button_title_html": "ახალი კვლევის შექმნა", + "series_step_0_create_new_study_html": "ამ სერიის ახალ კვლევაში გადატანა.", + "series_step_0_modify_series_button_title_html": "სერიის თეგების ცვლილება", + "series_step_0_modify_series_html": "შეიცვალოს სერიის თეგები მხოლოდ ამ სერიისთვის?", + "show_modified_resources": "მოდიფიცირებული რესურსების ნახვა", + "study_step_0_attach_study_to_existing_patient_button_title_html": "პაციენტის ცვლილება", + "study_step_0_attach_study_to_existing_patient_html": "ამ კვლევის სხვა, არსებულ პაციენტზე მიბმა.", + "study_step_0_modify_study_button_title_html": "კვლევის თეგების ცვლილება", + "study_step_0_modify_study_html": "შეიცვალოს პაციენტის/კვლევის თეგები მხოლოდ ამ კვლევისთვის?", + "study_step_0_patient_has_other_studies_button_title_html": "პაციენტის თეგების ცვლილება", + "study_step_0_patient_has_other_studies_html": "ამ პაციენტს ჯამში აქვს{count} კვლევა.
გსურთ პაციენტის ცვლილება ყველა კვლევაში?", + "warning_create_new_study_from_series_html": "უკვე არსებობს პაციენტი იგივე ID-თ და განსხვავებული თეგებით. გსურთ გამოიყენოთ არსებული სახელი, სქესი და დაბადების თარიღი?" + }, + "my_jobs": "ჩემი დავალებები", + "no_modalities": "არცერთი", + "no_result_found": "რეზულტატები ვერ მოიძებნა", + "not_showing_all_results": "ყველა კვლევა არ არის ნაჩვენები. დააზუსტეთ ძიების კრიტერიუმები.", + "open": "გახსნა", + "page_not_found": "გვერდი ვერ მოიძებნა", + "plugin": "ფლაგინი", + "preview": "ნახვა", + "profile": "პროფილი", + "retrieve_and_view": { + "finding_locally": "მოწმდება თუ კვლევა უკვე ლოკალურად არის ხელმისაწვდომი.", + "finding_remotely": "იძებნება კვლევა დისტანციურ DICOM აპარატებში.", + "not_found": "კვლევა არ იძებნება არც ლოკალურად და არც დისტანციურ DICOM აპარატებში.", + "retrieved_html": "გამოთხოვილია {count} ობიექტი.", + "retrieving": "კვლეევის გამოთხოვა." + }, + "searching": "ძიება...", + "select_files": "აირჩიეთ ფაილები", + "select_folder": "აირჩიეთ ფოლდერი", + "send_to": { + "button_title": "გაგზავნა", + "dicom": "DICOM აპარატში გაგზავნა", + "dicom_web": "DICOMWeb სერვერზე გაგზავნა", + "orthanc_peer": "გაგზავნა სხვა Orthanc სისტემაში", + "transfers": "სხვა Orthanc სისტემაში გაგზავნა (ოპტიმიზირებული)" + }, + "series": "სერია", + "series_count_header": "სერიები", + "series_plural": "სერიები", + "settings": { + "dicom_AET": "DICOM AET", + "dicom_port": "DICOM პორტი", + "ingest_transcoding": "შემოსული სურათების ტრანსკოდირება", + "installed_plugins": "დაინსტალირებული ფლაგინები", + "orthanc_name": "Orthanc სახელი", + "orthanc_system_info": "Orthanc სისტემის ინფორმაცია", + "orthanc_version": "Orthanc ვერსია", + "overwrite_instances": "სურათების გადაწერა", + "plugins_not_enabled": "ფლაგინები რომლებიც ჩაიტვირთა, მაგრამ არ არის ჩართული ან სწორად კონფიგურირებული: ", + "statistics": "სტატისტიკა", + "storage_compression": "ფაილების საცავის კომპრესია", + "storage_size": "ფაილების საცავის ზომა", + "striked_through": "გახაზულია", + "title": "პარამეტრები", + "verbosity_level": "ლოგირების დონე" + }, + "share": { + "anonymize": "მოხდეს ანონიმიზირება?", + "button_title": "გაზიარება", + "copy_and_close": "დაკოპირება და დახურვა", + "days": "დღეში", + "expires_in": "ვადა გასდის", + "link": "ბმული", + "modal_title": "კვლევის გაზიარება", + "never": "არასდროს" + }, + "show_errors": "აჩვენე შეცდომები", + "studies": "კვლევები", + "study": "კვლევა", + "this_patient_has_no_other_studies": "ამ პაციენტს სხვა კვლევები არ აქვს.", + "this_patient_has_other_studies": "ამ პაციენტს ჯამში აქვს {count} კვლევა.", + "this_patient_has_other_studies_show": "ჩვენება", + "token": { + "error_token_expired_html": "თქვენი დაშვების კოდის ვადა ამოწურულია.", + "error_token_invalid_html": "თქვენი დაშვების კოდი არ არის ძალაში.
გადაამოწმეთ რომ სწორად გაქვთ დაკოპირებული, ან დაეკონტაქტეთ ადამიანს ვინც გამოგიგზავნათ.", + "error_token_unknown_html": "თქვენი დაშვების კოდი არ არის ძალაში.
გადაამოწმეთ რომ სწორად გაქვთ დაკოპირებული, ან დაეკონტაქტეთ ადამიანს ვინც გამოგიგზავნათ.", + "token_being_checked_html": "თქვენი დაშვების კოდი მოწმდება." + }, + "trace": "ყველაზე დეტალური", + "upload": "ატვირთვა", + "uploaded_studies": "ატვირთული კვლევები", + "verbose": "ვრცელი", + "view_in_meddream": "MedDream Viewer-ში ნახვა", + "view_in_ohif": "OHIF Viewer-ში ნახვა", + "view_in_osimis": "OsimisViewer-ში ნახვა", + "view_in_stone": "StoneViewer-ში ნახვა", + "view_in_volview": "VolView-ში ნახვა" +} \ No newline at end of file diff --git a/WebApplication/src/locales/ru.json b/WebApplication/src/locales/ru.json new file mode 100644 index 0000000..71384de --- /dev/null +++ b/WebApplication/src/locales/ru.json @@ -0,0 +1,213 @@ +{ + "all_modalities": "Все", + "anonymize": "Анонимизировать", + "cancel": "Отменить", + "change_password": "Изменить пароль", + "close": "Закрыть", + "copy_orthanc_id": "Копировать Orthanc ID ", + "date_picker": { + "last_12_months": "За последние 12 месяцев", + "last_month": "В прошлом месяце", + "last_week": "На прошлой неделе", + "this_month": "В этом месяце", + "this_week": "На этой неделе", + "today": "Сегодня", + "yesterday": "Вчера" + }, + "default": "По умолчанию", + "delete": "Удалить", + "delete_instance_body": "Вы уверены, что хотите удалить этот экземпляр?
Это действие нельзя отменить!", + "delete_instance_title": "Удалить экземпляр?", + "delete_series_body": "Вы уверены, что хотите удалить эту серию?
Это действие нельзя отменить!", + "delete_series_title": "Удалить серию?", + "delete_studies_body": "Вы уверены, что хотите удалить эти исследования?
Это действие нельзя отменить!", + "delete_studies_title": "Удалить исследования?", + "delete_study_body": "Вы уверены, что хотите удалить это исследование?
Это действие нельзя отменить!", + "delete_study_title": "Удалить исследование?", + "description": "Описание", + "dicom_modalities": "Модальности DICOM", + "dicom_tags": { + "AccessionNumber": "Регистрационный номер", + "BodyPartExamined": "Обследованная часть тела", + "InstanceNumber": "Номер экземпляра", + "InstitutionName": "Название учреждения", + "ModalitiesInStudy": "Модальности в исследовании", + "Modality": "Модальность", + "NumberOfFrames": "Количество кадров", + "NumberOfStudyRelatedSeries": "Количество серий, связанных с исследованием", + "PatientBirthDate": "Дата рождения", + "PatientID": "ID пациента", + "PatientName": "Имя пациента", + "PatientSex": "Пол пациента", + "ProtocolName": "Название протокола", + "ReferringPhysicianName": "Направляющий врач", + "RequestingPhysician": "Запрашивающий врач", + "SOPInstanceUID": "UID экземпляра SOP", + "SeriesDate": "Дата серии", + "SeriesDescription": "Описание серии", + "SeriesInstanceUID": "UID экземпляра серии", + "SeriesNumber": "Номер серии", + "SeriesTime": "Время серии", + "StudyDate": "Дата исследования", + "StudyDescription": "Описание исследования", + "StudyID": "ID исследования", + "StudyInstanceUID": "UID экземпляра исследования", + "StudyTime": "Время исследования", + "seriesCount": "Количество серий" + }, + "dicom_web_servers": "Серверы DICOM-Web", + "displaying_latest_studies": "Отображение последних исследований", + "download_dicom_file": "Загрузить файл DICOM", + "download_dicomdir": "Загрузить DICOMDIR", + "download_zip": "Загрузить ZIP-архив", + "drop_files": "Перетащите файлы сюда или", + "enter_search": "Введите критерии поиска для отображения результатов!", + "error": "Ошибка", + "file": "Файл", + "files": "файлы", + "frames": "кадры", + "instance": "Экземпляр", + "instances": "Экземпляры", + "instances_number": "Количество экземпляров", + "labels": { + "add_button": "Добавить", + "add_labels_message_html": "Добавить эти метки всем выбранным ресурсам", + "add_labels_placeholder": "Метки, которые нужно добавить. Нажмите Enter, чтобы создать новый", + "added_labels_message_part_1_html": "Добавленные метки ", + "added_labels_message_part_2_html": " до {count} исследований", + "clear_all_button": "Удалить все", + "clear_all_labels_message_html": "Удалить все метки во всех выделенных ресурсах", + "cleared_labels_message_part_1_html": "Удаленные метки ", + "cleared_labels_message_part_2_html": " из {count} исследований", + "edit_labels_button": "Редактировать метки", + "modal_title": "Редактирование меток в выделенных ресурсах", + "remove_button": "Удалить", + "remove_labels_message_html": "Удалить эти метки из всех выбранных ресурсов", + "remove_labels_placeholder": "Метки, которые будут удалены", + "removed_labels_message_part_1_html": "Удаленные метки ", + "removed_labels_message_part_2_html": " из {count} исследований", + "study_details_title": "Метки" + }, + "legacy_ui": "Старый интерфейс", + "loading_latest_studies": "Загрузка последних исследований", + "local_studies": "Все локальные исследования", + "logout": "Выход", + "mammography_plugin": "Start mammogram AI", + "modalities_in_study": "Модальности в исследовании", + "modify": { + "anonymize_button_title": "Анонимизировать", + "anonymize_modal_title": "Анонимизировать", + "autogenerated_dicom_uid": "Автоматически сгенерированные", + "back_button_title": "Назад", + "error_attach_series_to_existing_study_target_does_not_exist_html": "Ошибка при смене серии, исследование с этим StudyInstanceUID не найдено.", + "error_attach_series_to_existing_study_target_unchanged_html": "Ошибка при смене серии, целевое исследование такое же, как текущее исследование серии.", + "error_attach_study_to_existing_patient_target_does_not_exist_html": "Ошибка при смене пациента, пациента с этим ID не найдено. Возможно, вместо этого нужно использоватьИзменить теги исследования.", + "error_modify_any_study_tags_can_not_modify_patient_tags_because_of_other_studies_html": "Ошибка при смене тегов исследования: этот пациент имеет другие исследования. Вместо этого следует использовать функцию Изменить теги пациента .", + "error_modify_any_study_tags_patient_exists_html": "Ошибка при смене тегов исследования: уже существует другой пациент с таким же ID. Вместо этого нужно использовать Изменить пациента.", + "error_modify_patient_tags_another_patient_exists_with_same_patient_id_html": "Ошибка при смене тегов пациента: уже существует другой пациент с таким же ID. Вместо этого следует использовать функцию < strong > Изменить теги пациента .", + "error_modify_unexpected_error_html": "Неожиданная ошибка при модификации, проверьте журналы Orthanc", + "insert_tag": "Вставить тег DICOM", + "job_in_progress": "Модификация обрабатывается", + "modify_button_title": "Модифицировать", + "modify_modal_title": "Модифицировать", + "modify_study_mode_duplicate_html": "Создание модифицированной копии исследования. (с генерацией новых DICOM UIDов и сохранением оригинального исследования)", + "modify_study_mode_keep_uids_html": "Модификация оригинального исследования. (с сохранением исходных DICOM UIDов)", + "modify_study_mode_new_uids_html": "Модификация оригинального исследования. (с генерацией новых DICOM UIDов)", + "remove_tag_tooltip": "Удалить тег", + "remove_tag_undo_tooltip": "Отменить удаление тегов", + "series_step_0_attach_series_to_existing_study_button_title_html": "Изменить исследование", + "series_step_0_attach_series_to_existing_study_html": "Переместить эту серию в существующее исследование.", + "series_step_0_create_new_study_button_title_html": "Создать новое исследование", + "series_step_0_create_new_study_html": "Переместить эту серию в новое исследование.", + "series_step_0_modify_series_button_title_html": "Модифицировать теги серии", + "series_step_0_modify_series_html": "Модифицировать теги только в этой серии?", + "show_modified_resources": "Показать модифицированные ресурсы", + "study_step_0_attach_study_to_existing_patient_button_title_html": "Сменить пациента", + "study_step_0_attach_study_to_existing_patient_html": "Присоединить это исследование к другому пациенту.", + "study_step_0_modify_study_button_title_html": "Изменить теги исследования", + "study_step_0_modify_study_html": "Изменить теги пациента/исследования только в этом исследовании?", + "study_step_0_patient_has_other_studies_button_title_html": "Изменить теги пациента", + "study_step_0_patient_has_other_studies_html": "Общее количество исследований этого пациента: {count} . < br/> Вы хотите изменить пациента во всех этих исследованиях?", + "warning_create_new_study_from_series_html": "Уже существует пациент с другими тегами и с таким же ID. Хотите ли вы использовать существующие имя пациента, пол пациента и дату рождения пациента? " + }, + "my_jobs": "Мои задачи", + "no_modalities": "Ничего", + "no_result_found": "Результатов нет!", + "not_showing_all_results": "Не показаны все результаты. Вы должны уточнить критерии поиска", + "open": "Открыть", + "page_not_found": "Такой страницы нет!", + "plugin": "дополнительный модуль", + "preview": "Предварительный просмотр", + "profile": "Профиль", + "retrieve_and_view": { + "finding_locally": "Проверка наличия исследования локально.", + "finding_remotely": "Поиск исследования в удаленных узлах DICOM.", + "not_found": "Исследование не было найдено ни локально, ни в удаленных узлах DICOM.", + "retrieved_html": "Получено {count} экземпляров.", + "retrieving": "Получение исследования." + }, + "searching": "Поиск...", + "select_files": "Выберите файлы", + "select_folder": "Выберите папку", + "send_to": { + "button_title": "Отправить", + "dicom": "Отправить в узел DICOM", + "dicom_web": "Отправить на сервер DICOMWeb", + "orthanc_peer": "Отправить в другой Orthanc", + "transfers": "Отправить в другой Orthanc (расширенные параметры передачи)" + }, + "series": "Серия", + "series_count_header": "# серий", + "series_plural": "Серии", + "settings": { + "dicom_AET": "DICOM AET", + "dicom_port": "Порт DICON", + "ingest_transcoding": "Транскодирование поступающих данных", + "installed_plugins": "Установлены дополнительные модули", + "orthanc_name": "Имя сервера", + "orthanc_system_info": "Информация о системе", + "orthanc_version": "Версия", + "overwrite_instances": "Заменить экземпляры", + "plugins_not_enabled": "Загруженные дополнительные модули, которые не включены или неверно настроены", + "statistics": "Статистика", + "storage_compression": "Сжатие хранилища", + "storage_size": "Размер хранилища", + "striked_through": "зачеркнутые", + "title": "Настройка", + "verbosity_level": "Уровень подробности" + }, + "share": { + "anonymize": "Анонимизировать?", + "button_title": "Поделиться", + "copy_and_close": "Копировать и закрыть", + "days": "дни", + "expires_in": "Срок действия заканчивается через", + "link": "Ссылка", + "modal_title": "Поделиться исследованием", + "never": "никогда" + }, + "show_errors": "Показать ошибки", + "studies": "Исследования", + "study": "Исследование", + "this_patient_has_no_other_studies": "У этого пациента нет больше исследований.", + "this_patient_has_other_studies": "У этого пациента в целом {count} исследований.", + "this_patient_has_other_studies_show": "Показать их!", + "token": { + "error_token_expired_html": "Ваш токен просрочен.", + "error_token_invalid_html": "Ваш токен недействителен.
Проверьте, вставили ли его полностью, или обратитесь к человеку, который вам его предоставил.", + "error_token_unknown_html": "Ваш токен недействителен.
Проверьте, вставили ли его полностью, или обратитесь к человеку, который вам его предоставил.", + "token_being_checked_html": "Ваш токен проверяется." + }, + "trace": "Трассировка", + "upload": "Загрузить", + "uploaded_studies": "Загруженные исследования", + "verbose": "Подробнее", + "view_in_meddream": "Посмотреть в MedDream", + "view_in_ohif": "Посмотреть в OHIF", + "view_in_ohif_tmtv": "Посмотреть в OHIF в режиме Total Metabolic Tumor Volume", + "view_in_ohif_vr": "Посмотреть в OHIF в режиме Volume Rendering", + "view_in_osimis": "Посмотреть в OsimisViewer", + "view_in_stone": "Посмотреть в StoneViewer", + "view_in_volview": "Посмотреть в VolView", + "view_in_wsi_viewer": "Посмотреть в Whole Slide Imaging Viewer" +} \ No newline at end of file diff --git a/WebApplication/src/locales/si.json b/WebApplication/src/locales/si.json new file mode 100644 index 0000000..2e2d7fd --- /dev/null +++ b/WebApplication/src/locales/si.json @@ -0,0 +1,217 @@ +{ + "all_modalities": "Vse", + "anonymize": "Anonimiziraj", + "cancel": "Prekliči", + "change_password": "Spremeni geslo", + "close": "Zapri", + "copy_orthanc_id": "Kopiraj Orthanc ID", + "date_picker": { + "last_12_months": "Zadnjih 12 mesecev", + "last_month": "Prejšnji mesec", + "last_week": "Prejšnji teden", + "this_month": "Ta mesec", + "this_week": "Ta teden", + "today": "Danes", + "yesterday": "Včeraj" + }, + "default": "Privzeto", + "delete": "Izbriši", + "delete_instance_body": "Ste prepričani, da želite izbrisati ta primerek?
Tega dejanja se ne da razveljaviti!", + "delete_instance_title": "Izbriši primerek?", + "delete_series_body": "Ste prepričani, da želite izbrisati to serijo?
Tega dejanja se ne da razveljaviti!", + "delete_series_title": "Izbriši serijo?", + "delete_studies_body": "Ste prepričani, da želite izbrisati te študije?
Tega dejanja se ne da razveljaviti!", + "delete_studies_title": "Izbriši študije?", + "delete_study_body": "Ste prepričani, da želite izbrisati to študijo?
Tega dejanja se ne da razveljaviti!", + "delete_study_title": "Izbriši študijo?", + "description": "Opis", + "dicom_modalities": "DICOM modalnosti", + "dicom_tags": { + "AccessionNumber": "Pristopna številka", + "BodyPartExamined": "Pregledan del telesa", + "InstanceNumber": "Številka primerka", + "InstitutionName": "Ime ustanove", + "ModalitiesInStudy": "Modalitete v študiji", + "Modality": "Modalnost", + "NumberOfFrames": "Število slik", + "NumberOfStudyRelatedSeries": "Število serij", + "PatientBirthDate": "Datum rojstva pacienta", + "PatientID": "ID pacienta", + "PatientName": "Ime pacienta", + "PatientSex": "Spol pacienta", + "ProtocolName": "Ime protokola", + "ReferringPhysicianName": "Ime napotnega zdravnika", + "RequestingPhysician": "Zdravnik prosilec", + "SOPInstanceUID": "UID primerka SOP", + "SeriesDate": "Datum serije", + "SeriesDescription": "Opis serije", + "SeriesInstanceUID": "UID primerka serije", + "SeriesNumber": "Številka serije", + "SeriesTime": "Čas serije", + "StudyDate": "Datum študije", + "StudyDescription": "Opis študije", + "StudyID": "ID študije", + "StudyInstanceUID": "UID primerka študije", + "StudyTime": "Čas študije", + "seriesCount": "Število serij" + }, + "dicom_web_servers": "DICOM-Web strežnik", + "displaying_latest_studies": "Prikaz najnovejših študij", + "download_dicom_file": "Prenos datoteke DICOM", + "download_dicomdir": "Prenesi datoteko DICOMDIR", + "download_zip": "Prenesi datoteko ZIP", + "drop_files": "Datoteke odvrzi sem ali pa...", + "enter_search": "Vnesi kriterij za iskanje za prikaz rezultatov!", + "error": "Napaka", + "file": "Datoteka", + "files": "datoteke", + "frames": "slike", + "instance": "Primerek", + "instances": "Primerki", + "instances_number": "Število primerkov", + "labels": { + "add_button": "Dodaj", + "add_labels_message_html": "Dodajte te oznake vsem izbranim virom", + "add_labels_placeholder": "Oznake, ki jih želite dodati. Pritisnite Enter, da ustvarite novo oznako.", + "added_labels_message_part_1_html": "Dodane oznake", + "added_labels_message_part_2_html": " do {count} študij", + "clear_all_button": "Odstrani vse", + "clear_all_labels_message_html": "Odstrani vse oznake v vseh izbranih virih", + "cleared_labels_message_part_1_html": "Odstranjene oznake", + "cleared_labels_message_part_2_html": " iz {count} študij", + "edit_labels_button": "Uredi oznake", + "modal_title": "Spremeni oznake v izbranih virih", + "remove_button": "Odstrani", + "remove_labels_message_html": "Odstranite te oznake iz vseh izbranih virov", + "remove_labels_placeholder": "Oznake za odstranitev", + "removed_labels_message_part_1_html": "Odstranjene oznake", + "removed_labels_message_part_2_html": " iz {count} študij", + "study_details_title": "Oznake" + }, + "legacy_ui": "Starejši uporabniški vmesnik", + "loading_latest_studies": "Nalaganje najnovejših študij", + "local_studies": "Vse lokalne študije", + "logout": "Odjava", + "mammography_plugin": "Start mammogram AI", + "modalities_in_study": "Modalitete v študiju", + "modify": { + "anonymize_button_title": "Anonimiziraj", + "anonymize_modal_title": "Anonimiziraj", + "autogenerated_dicom_uid": "Samodejno ustvarjeno", + "back_button_title": "Nazaj", + "error_attach_series_to_existing_study_target_does_not_exist_html": "Napaka pri spreminjanju serije, s tem \"StudyInstanceUID\" ni bilo mogoče najti študije.", + "error_attach_series_to_existing_study_target_unchanged_html": "Napaka pri spreminjanju serije, ciljna študija je enaka trenutni študiji serije.", + "error_attach_study_to_existing_patient_target_does_not_exist_html": "Napaka pri menjavi pacienta. Pacient s tem ID-jem ne obstaja. Poizkusite s Spremenite študijske oznake funkcijo.", + "error_modify_any_study_tags_can_not_modify_patient_tags_because_of_other_studies_html": "Napaka pri spreminjanju oznak študije: ta pacient ima druge študije. Namesto tega uporabite funkcijo Spremenite oznake pacienta.", + "error_modify_any_study_tags_patient_exists_html": "Napaka pri spreminjanju oznak študije: pacient s tem ID-jem že obstaja. Namesto tega uporabite funkcijo Spremeni pacienta/strong>.", + "error_modify_patient_tags_another_patient_exists_with_same_patient_id_html": "Napaka pri spreminjanju oznak pacienta: drug pacient z istim ID-jem že obstaja. Namesto tega uporabite funkcijo Spremenite oznake pacienta.", + "error_modify_unexpected_error_html": "Nepričakovana napaka med spreminjanjem, preverite Orthanc-ove dnevnike", + "insert_tag": "Vstavi DICOM oznako", + "job_in_progress": "Sprememba je v obdelavi", + "modify_button_title": "Spremeni", + "modify_modal_title": "Spremeni", + "modify_series_mode_duplicate_html": "Ustvari spremenjeno kopijo izvirne serije. (ustvarjanje novih DICOM UID-jev in ohranjanje izvirne serije)", + "modify_series_mode_keep_uids_html": "Popravi izvirno serijo. (ohranjanje izvirnih DICOM UID-jev)", + "modify_series_mode_new_uids_html": "Spremeni izvirno serijo. (ustvarjanje novih DICOM UID-jev)", + "modify_study_mode_duplicate_html": "Ustvari spremenjeno kopijo izvirne študije. (ustvarjanje novih DICOM UID-jev in ohranjanje izvirne študije)", + "modify_study_mode_keep_uids_html": "Popravi izvirno študijo. (ohranjanje izvirnih DICOM UID-jev)", + "modify_study_mode_new_uids_html": "Spremeni izvirno študijo. (ustvarjanje novih DICOM UID-jev)", + "remove_tag_tooltip": "Odstrani oznako", + "remove_tag_undo_tooltip": "Razveljavi odstranitev oznake", + "series_step_0_attach_series_to_existing_study_button_title_html": "Spremeni študijo", + "series_step_0_attach_series_to_existing_study_html": "Premakni to serijo v obstoječo študijo.", + "series_step_0_create_new_study_button_title_html": "Ustvari novo študijo", + "series_step_0_create_new_study_html": "Premakni to serijo v novo študijo.", + "series_step_0_modify_series_button_title_html": "Spremeni oznake serije", + "series_step_0_modify_series_html": "Želite spremeniti oznake serije samo v tej seriji?", + "show_modified_resources": "Pokaži spremenjene vire", + "study_step_0_attach_study_to_existing_patient_button_title_html": "Spremeni pacienta", + "study_step_0_attach_study_to_existing_patient_html": "Priloži to študijo drugemu obstoječemu pacientu.", + "study_step_0_modify_study_button_title_html": "Spremeni oznake študije", + "study_step_0_modify_study_html": "Želite spremeniti oznake pacienta/študije samo v tej študiji?", + "study_step_0_patient_has_other_studies_button_title_html": "Spremeni oznake pacientov", + "study_step_0_patient_has_other_studies_html": "Ta pacient ima skupno {count} študij.
Ali želite spremeniti pacienta v vseh teh študijah?", + "warning_create_new_study_from_series_html": "Pacient z istim ID-jem, ampak drugačnimi oznakami, že obstaja. Ali želite uporabiti obstoječe ime pacienta, njegov spol in datum rojstva?" + }, + "my_jobs": "Moja opravila", + "no_modalities": "Noben", + "no_result_found": "Ni rezultatov!", + "not_showing_all_results": "Niso prikazani vsi rezultati. Uporabite bolj specifične iskalne kriterije", + "open": "Odprto", + "page_not_found": "Stran ni najdena!", + "plugin": "vtičnik", + "preview": "Predogled", + "profile": "Profil", + "retrieve_and_view": { + "finding_locally": "Preverjam, ali je študija že na voljo lokalno.", + "finding_remotely": "Iskanje študije v oddaljenih DICOM vozliščih.", + "not_found": "Študija ni bila najdena niti lokalno niti v oddaljenih DICOM vozliščih.", + "retrieved_html": "Pridobljenih {count} primerkov.", + "retrieving": "Pridobivanje študije." + }, + "searching": "Iščem ...", + "select_files": "Izberi datoteke", + "select_folder": "Izberi mapo", + "send_to": { + "button_title": "Pošlji", + "dicom": "Pošlji v DICOM vozlišče", + "dicom_web": "Pošlji na DICOMWeb strežnik", + "orthanc_peer": "Pošlji Orthanc vrstniku", + "transfers": "Pošlji Orthanc vrstniku (napredni prenosi)" + }, + "series": "Serija", + "series_count_header": "# serij", + "series_plural": "Serije", + "settings": { + "dicom_AET": "DICOM AET", + "dicom_port": "DICOM vrata", + "ingest_transcoding": "Prevzemno prekodiranje", + "installed_plugins": "Nameščeni vtičniki", + "orthanc_name": "Ime Orthanc", + "orthanc_system_info": "Informacije o sistemu Orthanc", + "orthanc_version": "Različica Orthanc", + "overwrite_instances": "Prepiši primerke", + "plugins_not_enabled": "Vtičniki, ki so naloženi, vendar niso omogočeni ali niso pravilno konfigurirani, so", + "statistics": "Statistika", + "storage_compression": "Stiskanje shranjevanja", + "storage_size": "Velikost shranjevanja", + "striked_through": "prečrtani", + "title": "Nastavitve", + "verbosity_level": "Nivo beleženja" + }, + "share": { + "anonymize": "Anonimiziraj?", + "button_title": "Deli", + "copy_and_close": "Kopiraj in zapri", + "days": "dni", + "expires_in": "Poteče čez", + "link": "Povezava", + "modal_title": "Deli študijo", + "modal_title_multiple_studies": "Deli {count} študij", + "never": "nikoli" + }, + "show_errors": "Pokaži napake", + "studies": "Študije", + "study": "Študija", + "this_patient_has_no_other_studies": "Ta pacient nima drugih študij.", + "this_patient_has_other_studies": "Ta pacient ima skupno {count} študij.", + "this_patient_has_other_studies_show": "Prikaži jih", + "token": { + "error_token_expired_html": "Vaš žeton je potekel.", + "error_token_invalid_html": "Vaš žeton ni veljaven.
Preverite, ali ste ga prilepili v celoti, ali pa se obrnite na osebo, ki vam ga je posredovala.", + "error_token_unknown_html": "Vaš žeton ni veljaven.
Preverite, ali ste ga prilepili v celoti, ali pa se obrnite na osebo, ki vam ga je posredovala.", + "token_being_checked_html": "Vaš žeton se preverja." + }, + "trace": "Napredno", + "upload": "Naloži", + "uploaded_studies": "Naložene študije", + "verbose": "Podrobno", + "view_in_meddream": "Ogled v MedDream", + "view_in_ohif": "Ogled v OHIF", + "view_in_ohif_tmtv": "Ogled v načinu OHIF Total Metabolic Tumor Volume", + "view_in_ohif_vr": "Ogled v načinu OHIF Volume Rendering", + "view_in_osimis": "Ogled v OsimisViewer", + "view_in_stone": "Ogled v StoneViewer", + "view_in_volview": "Ogled v VolView", + "view_in_wsi_viewer": "Ogled v Whole Slide Imaging Viewer" +} \ No newline at end of file diff --git a/WebApplication/src/locales/uk.json b/WebApplication/src/locales/uk.json new file mode 100644 index 0000000..920f374 --- /dev/null +++ b/WebApplication/src/locales/uk.json @@ -0,0 +1,214 @@ +{ + "all_modalities": "Всі", + "anonymize": "Анонімізувати", + "cancel": "Скасувати", + "change_password": "Змінити пароль", + "close": "Закрити", + "copy_orthanc_id": "Копіювати Orthanc ID", + "date_picker": { + "last_12_months": "За останні 12 місяців", + "last_month": "Минулого місяця", + "last_week": "Минулого тижня", + "this_month": "Цього місяця", + "this_week": "Цього тижня", + "today": "Сьогодні", + "yesterday": "Вчора" + }, + "default": "За замовчуванням", + "delete": "Видалити", + "delete_instance_body": "Ви впевнені, що хочете видалити цей екземпляр?
Цю дію не можна скасувати!", + "delete_instance_title": "Видалити екземпляр?", + "delete_series_body": "Ви впевнені, що хочете видалити ці серії?
Цю дію не можна скасувати!", + "delete_series_title": "Видалити серії?", + "delete_studies_body": "Ви впевнені, що хочете видалити ці дослідження?
Цю дію не можна скасувати!", + "delete_studies_title": "Видалити дослідження?", + "delete_study_body": "Ви впевнені, що хочете видалити це дослідження?
Цю дію не можна скасувати!", + "delete_study_title": "Видалити дослідження?", + "description": "Опис", + "dicom_modalities": "Модальності DICOM", + "dicom_tags": { + "AccessionNumber": "Номер обстеження", + "BodyPartExamined": "Обстежена частина тіла", + "InstanceNumber": "Номер екземпляра", + "InstitutionName": "Назва установи", + "ModalitiesInStudy": "Модальності у дослідженні", + "Modality": "Модальність", + "NumberOfFrames": "Кількість кадрів", + "NumberOfStudyRelatedSeries": "Кількість серій, пов'язаних із дослідженням", + "PatientBirthDate": "Дата народження пацієнта", + "PatientID": "ID пацієнта", + "PatientName": "Ім'я пацієнта", + "PatientSex": "Стать пацієнта", + "ProtocolName": "Назва протоколу", + "ReferringPhysicianName": "Ім'я лікаря, що направив", + "RequestingPhysician": "Лікар, що робить запит", + "SOPInstanceUID": "UID екземпляра SOP", + "SeriesDate": "Дата серії", + "SeriesDescription": "Опис серії", + "SeriesInstanceUID": "UID екземпляра серії", + "SeriesNumber": "Номер серії", + "SeriesTime": "Час серії", + "StudyDate": "Дата дослідження", + "StudyDescription": "Опис дослідження", + "StudyID": "ID дослідження", + "StudyInstanceUID": "UID екземпляра дослідження", + "StudyTime": "Час дослідження", + "seriesCount": "Кількість серій" + }, + "dicom_web_servers": "Сервери DICOM-Web", + "displaying_latest_studies": "Відображення останніх досліджень", + "download_dicom_file": "Завантажити файл DICOM", + "download_dicomdir": "Завантажити DICOMDIR", + "download_zip": "Завантажити ZIP-архів", + "drop_files": "Перетягніть файли сюди або", + "enter_search": "Введіть критерії пошуку, щоб відобразити результати!", + "error": "Помилка", + "file": "Файл", + "files": "файли", + "frames": "кадри", + "instance": "Екземпляр", + "instances": "Екземпляри", + "instances_number": "Кількість екземплярів", + "labels": { + "add_button": "Додати", + "add_labels_message_html": "Додати ці мітки усім вибраним ресурсам", + "add_labels_placeholder": "Мітки, що будуть додані; натисність Enter для створення нової", + "added_labels_message_part_1_html": "Додані мітки ", + "added_labels_message_part_2_html": " до {count} досліджень", + "clear_all_button": "Видалити все", + "clear_all_labels_message_html": "Видалити всі мітки у всіх виділених ресурсах", + "cleared_labels_message_part_1_html": "Видалені мітки ", + "cleared_labels_message_part_2_html": " з {count} досліджень", + "edit_labels_button": "Редагувати мітки", + "modal_title": "Редагування міток у виділених ресурсах", + "remove_button": "Видалити", + "remove_labels_message_html": "Видалити ці мітки з усіх вибраних ресурсів", + "remove_labels_placeholder": "Мітки, що будуть вилучені", + "removed_labels_message_part_1_html": "Видалені мітки ", + "removed_labels_message_part_2_html": " з {count} досліджень", + "study_details_title": "Мітки" + }, + "legacy_ui": "Старий інтерфейс", + "loading_latest_studies": "Завантаження останніх досліджень", + "local_studies": "Усі локальні дослідження", + "logout": "Вихід", + "mammography_plugin": "Start mammogram AI", + "modalities_in_study": "Модальності у дослідженні", + "modify": { + "anonymize_button_title": "Анонімізувати", + "anonymize_modal_title": "Анонімізувати", + "autogenerated_dicom_uid": "Автоматично згенеровані", + "back_button_title": "Взад", + "error_attach_series_to_existing_study_target_does_not_exist_html": "Помилка під час зміни серії, дослідження з цим StudyInstanceUID не знайдено.", + "error_attach_series_to_existing_study_target_unchanged_html": "Помилка під час зміни серії, цільове дослідження таке ж, як поточне дослідження серії.", + "error_attach_study_to_existing_patient_target_does_not_exist_html": "Помилка під час зміни пацієнта, пацієнта з цим ID пацієнта не знайдено. Можливо, замість цього вам слід скористатися функцією Змінити теги дослідження.", + "error_modify_any_study_tags_can_not_modify_patient_tags_because_of_other_studies_html": "Помилка під час зміни тегів дослідження: цей пацієнт має інші дослідження. Замість цього слід використовувати функцію Змінити теги пацієнта.", + "error_modify_any_study_tags_patient_exists_html": "Помилка під час зміни тегів дослідження: уже існує інший пацієнт із таким самим ID пацієнта. Замість цього слід скористатися функцією Змінити пацієнта.", + "error_modify_patient_tags_another_patient_exists_with_same_patient_id_html": "Помилка під час зміни тегів пацієнта: уже існує інший пацієнт із таким самим ID пацієнта. Замість цього слід використовувати функцію Змінити теги пацієнта.", + "error_modify_unexpected_error_html": "Неочікувана помилка під час модифікації, перевірте журнали Orthanc", + "insert_tag": "Вставити тег DICOM", + "job_in_progress": "Модифікація обробляється", + "modify_button_title": "Модифікувати", + "modify_modal_title": "Модифікувати", + "modify_study_mode_duplicate_html": "Створення модифікованої копії дослідження. (з генерацією нових DICOM UIDів ТА збереженням оригінального дослідження)", + "modify_study_mode_keep_uids_html": "Модифікація оригінального дослідження. (зі збереженням оригінальних DICOM UIDів)", + "modify_study_mode_new_uids_html": "Модифікація оригінального дослідження. (з генерацією нових DICOM UIDів)", + "remove_tag_tooltip": "Видалити тег", + "remove_tag_undo_tooltip": "Відмінити видалення тегу", + "series_step_0_attach_series_to_existing_study_button_title_html": "Змінити дослідження", + "series_step_0_attach_series_to_existing_study_html": "Перемістіти цю серію до наявного дослідження.", + "series_step_0_create_new_study_button_title_html": "Створити нове дослідження", + "series_step_0_create_new_study_html": "Перемістити цю серію до нового дослідження.", + "series_step_0_modify_series_button_title_html": "Модифікувати теги серії", + "series_step_0_modify_series_html": "Модифікувати теги серії лише у цій серії?", + "show_modified_resources": "Показати модифіковані ресурси", + "study_step_0_attach_study_to_existing_patient_button_title_html": "Змінити пацієнта", + "study_step_0_attach_study_to_existing_patient_html": "Приєднати це дослідження до іншого наявного пацієнта.", + "study_step_0_modify_study_button_title_html": "Змінити теги дослідження", + "study_step_0_modify_study_html": "Змінити теги пацієнта/дослідження лише в цьому дослідженні?", + "study_step_0_patient_has_other_studies_button_title_html": "Змінити теги пацієнта", + "study_step_0_patient_has_other_studies_html": "Загальна кількість досліджень цього пацієнта: {count}.
Ви бажаєте змінити пацієнта в усіх цих дослідженнях ?", + "warning_create_new_study_from_series_html": "Вже існує пацієнт із іншими тегами і з таким самим ID пацієнта. Чи бажаєте ви використовувати наявні ім'я пацієнта, стать пацієнта і дату народження пацієнта?" + }, + "my_jobs": "Мої завдання", + "no_modalities": "Нічого", + "no_result_found": "Результатів немає!", + "not_showing_all_results": "Не показано всі результати. Ви повинні уточнити критерії пошуку", + "open": "Відкрити", + "page_not_found": "Такої сторінки немає!", + "plugin": "додатковий модуль", + "preview": "Попередній перегляд", + "profile": "Профіль", + "retrieve_and_view": { + "finding_locally": "Перевірка наявності дослідження локально.", + "finding_remotely": "Пошук дослідження у віддалених вузлах DICOM.", + "not_found": "Дослідження не було знайдено ані локально, ані у віддалених вузлах DICOM.", + "retrieved_html": "Отримано {count} екземплярів.", + "retrieving": "Отримання дослідження." + }, + "searching": "Пошук...", + "select_files": "Виберіть файли", + "select_folder": "Виберіть теку", + "send_to": { + "button_title": "Надіслати", + "dicom": "Надіслати до вузла DICOM", + "dicom_web": "Надіслати до сервера DICOMWeb", + "orthanc_peer": "Надіслати до іншого Orthanc", + "transfers": "Надіслати до іншого Orthanc (розширені параметри передавання)" + }, + "series": "Серія", + "series_count_header": "# серій", + "series_plural": "Серії", + "settings": { + "dicom_AET": "DICOM AE Title", + "dicom_port": "Порт DICOM", + "ingest_transcoding": "Транскодування даних, що надходять", + "installed_plugins": "Встановлені додаткові модулі", + "orthanc_name": "Ім'я сервера Orthanc", + "orthanc_system_info": "Інформація про систему Orthanc", + "orthanc_version": "Версія Orthanc", + "overwrite_instances": "Перезаписати екземпляри", + "plugins_not_enabled": "Завантажені додаткові модулі, які не ввімкнені або некоректно налаштовані, ", + "statistics": "Статистика", + "storage_compression": "Стиснення сховища", + "storage_size": "Розмір сховища", + "striked_through": "закреслені", + "title": "Налаштування", + "verbosity_level": "Рівень докладності" + }, + "share": { + "anonymize": "Анонімізувати?", + "button_title": "Поділитись", + "copy_and_close": "Копіювати та закрити", + "days": "дні", + "expires_in": "Строк дії закінчується через", + "link": "Посилання", + "modal_title": "Поділитись дослідженням", + "modal_title_multiple_studies": "Поділитись {count} дослідженнями", + "never": "ніколи" + }, + "show_errors": "Показати помилки", + "studies": "Дослідження", + "study": "Дослідження", + "this_patient_has_no_other_studies": "У цього пацієнта немає більше досліджень.", + "this_patient_has_other_studies": "У цього пацієнта загалом {count} досліджень.", + "this_patient_has_other_studies_show": "Показати їх!", + "token": { + "error_token_expired_html": "Ваш токен прострочений.", + "error_token_invalid_html": "Ваш токен недійсний.
Перевірте, чи вставили його повністю, або зверніться до особи, яка вам його надала.", + "error_token_unknown_html": "Ваш токен недійсний.
Перевірте, чи вставили його повністю, або зверніться до особи, яка вам його надала.", + "token_being_checked_html": "Ваш токен перевіряється." + }, + "trace": "Трасування", + "upload": "Завантажити", + "uploaded_studies": "Завантажені дослідження", + "verbose": "Докладно", + "view_in_meddream": "Подивитись у MedDream", + "view_in_ohif": "Подивитися в OHIF", + "view_in_ohif_tmtv": "Подивитися в OHIF у режимі Total Metabolic Tumor Volume", + "view_in_ohif_vr": "Подивитися в OHIF у режимі Volume Rendering", + "view_in_osimis": "Подивитись у OsimisViewer", + "view_in_stone": "Подивитись у StoneViewer", + "view_in_volview": "Подивитись у VolView", + "view_in_wsi_viewer": "Подивитись у Whole Slide Imaging Viewer" +} \ No newline at end of file diff --git a/WebApplication/src/locales/zh.json b/WebApplication/src/locales/zh.json new file mode 100644 index 0000000..e42c53c --- /dev/null +++ b/WebApplication/src/locales/zh.json @@ -0,0 +1,208 @@ +{ + "all_modalities": "全部", + "anonymize": "匿名化", + "cancel": "取消", + "change_password": "更改密码", + "close": "关闭", + "copy_orthanc_id": "复制Orthanc ID", + "date_picker": { + "last_12_months": "最近12个月", + "last_month": "上个月", + "last_week": "上周", + "this_month": "本月", + "this_week": "本周", + "today": "今天", + "yesterday": "昨天" + }, + "default": "默认", + "delete": "删除", + "delete_instance_body": "您确定要删除此实例吗？
此操作无法撤销！", + "delete_instance_title": "删除实例？", + "delete_series_body": "您确定要删除此系列吗？
此操作无法撤销！", + "delete_series_title": "删除系列？", + "delete_studies_body": "您确定要删除这些研究吗？
此操作无法撤销！", + "delete_studies_title": "删除研究？", + "delete_study_body": "您确定要删除此研究吗？
此操作无法撤销！", + "delete_study_title": "删除研究？", + "description": "描述", + "dicom_modalities": "DICOM模态", + "dicom_tags": { + "AccessionNumber": "访问号", + "BodyPartExamined": "检查的部位", + "InstanceNumber": "实例号", + "InstitutionName": "机构名称", + "ModalitiesInStudy": "研究中的模态", + "Modality": "模态", + "NumberOfFrames": "帧数", + "NumberOfStudyRelatedSeries": "系列数量", + "PatientBirthDate": "患者出生日期", + "PatientID": "患者ID", + "PatientName": "患者姓名", + "PatientSex": "患者性别", + "ProtocolName": "协议名称", + "ReferringPhysicianName": "转诊医师姓名", + "RequestingPhysician": "申请医师", + "SeriesDate": "系列日期", + "SeriesDescription": "系列描述", + "SeriesInstanceUID": "系列实例UID", + "SeriesNumber": "系列号", + "SeriesTime": "系列时间", + "StudyDate": "研究日期", + "StudyDescription": "研究描述", + "StudyID": "研究ID", + "StudyInstanceUID": "研究实例UID", + "StudyTime": "研究时间", + "seriesCount": "系列数量" + }, + "dicom_web_servers": "DICOM-Web服务器", + "displaying_latest_studies": "显示最近的研究", + "download_dicom_file": "下载DICOM文件", + "download_dicomdir": "下载DICOMDIR", + "download_zip": "下载ZIP", + "drop_files": "将文件拖放到此处或", + "enter_search": "输入搜索条件以显示结果！", + "error": "错误", + "file": "文件", + "files": "文件", + "frames": "帧数", + "instance": "实例", + "instances": "实例", + "instances_number": "实例数量", + "labels": { + "add_button": "添加", + "add_labels_message_html": "添加这些标签到所有选定的资源", + "add_labels_placeholder": "要添加的标签，按Enter键创建新标签", + "added_labels_message_part_1_html": "已添加标签", + "added_labels_message_part_2_html": "到{count}个研究", + "clear_all_button": "移除全部", + "clear_all_labels_message_html": "移除全部选定资源的标签", + "cleared_labels_message_part_1_html": "已移除标签", + "cleared_labels_message_part_2_html": "从{count}个研究", + "edit_labels_button": "编辑标签", + "modal_title": "修改选定资源的标签", + "remove_button": "移除", + "remove_labels_message_html": "移除所有选定资源的这些标签", + "remove_labels_placeholder": "要移除的标签", + "removed_labels_message_part_1_html": "已移除标签", + "removed_labels_message_part_2_html": "从{count}个研究" + }, + "legacy_ui": "传统用户界面", + "loading_latest_studies": "正在加载最近的研究", + "local_studies": "所有本地研究", + "logout": "登出", + "mammography_plugin": "Start mammogram AI", + "modalities_in_study": "研究中的模态", + "modify": { + "anonymize_button_title": "匿名化", + "anonymize_modal_title": "匿名化", + "autogenerated_dicom_uid": "自动生成", + "back_button_title": "返回", + "error_attach_series_to_existing_study_target_does_not_exist_html": "更改系列时出错，未找到具有此StudyInstanceUID的研究。", + "error_attach_series_to_existing_study_target_unchanged_html": "更改系列时出错，目标研究与当前系列研究相同。", + "error_attach_study_to_existing_patient_target_does_not_exist_html": "更改患者时出错，未找到具有此PatientID的患者。您应该使用修改研究标签功能。", + "error_modify_any_study_tags_can_not_modify_patient_tags_because_of_other_studies_html": "修改研究标签时出错：该患者有其他研究。您应该使用修改患者标签功能。", + "error_modify_any_study_tags_patient_exists_html": "修改研究标签时出错：已存在具有相同PatientID的其他患者。您应该使用更改患者功能。", + "error_modify_patient_tags_another_patient_exists_with_same_patient_id_html": "修改患者标签时出错：已存在具有相同PatientID的其他患者。您应该使用修改患者标签功能。", + "error_modify_unexpected_error_html": "修改过程中发生意外错误，请检查Orthanc日志", + "insert_tag": "插入DICOM标签", + "job_in_progress": "正在处理修改", + "modify_button_title": "修改", + "modify_modal_title": "修改", + "modify_study_mode_duplicate_html": "创建原始研究的修改副本。（生成新的DICOM UID并保留原始研究）", + "modify_study_mode_keep_uids_html": "修改原始研究。（保留原始DICOM UID）", + "modify_study_mode_new_uids_html": "修改原始研究。（生成新的DICOM UID）", + "remove_tag_tooltip": "移除标签", + "remove_tag_undo_tooltip": "撤销移除标签", + "series_step_0_attach_series_to_existing_study_button_title_html": "更改研究", + "series_step_0_attach_series_to_existing_study_html": "将此系列移至现有研究。", + "series_step_0_create_new_study_button_title_html": "创建新研究", + "series_step_0_create_new_study_html": "将此系列移至新的研究。", + "series_step_0_modify_series_button_title_html": "修改系列标签", + "series_step_0_modify_series_html": "仅修改此系列的系列标签？", + "show_modified_resources": "显示修改后的资源", + "study_step_0_attach_study_to_existing_patient_button_title_html": "更改患者", + "study_step_0_attach_study_to_existing_patient_html": "将此研究附加到其他现有患者。", + "study_step_0_modify_study_button_title_html": "修改研究标签", + "study_step_0_modify_study_html": "仅修改此研究的患者/研究标签？", + "study_step_0_patient_has_other_studies_button_title_html": "修改患者标签", + "study_step_0_patient_has_other_studies_html": "该患者共有{count}个研究。
您是否要在所有这些研究中修改患者？", + "warning_create_new_study_from_series_html": "已存在具有不同标签的具有相同PatientID的患者。您是否要使用现有的PatientName、PatientSex和PatientBirthDate？" + }, + "my_jobs": "我的作业", + "no_modalities": "无", + "no_result_found": "未找到结果！", + "not_showing_all_results": "未显示所有结果。您应该精确您的搜索条件", + "open": "打开", + "page_not_found": "页面未找到！", + "plugin": "插件", + "preview": "预览", + "profile": "配置文件", + "retrieve_and_view": { + "finding_locally": "检查本地是否已存在该研究。", + "finding_remotely": "在远程DICOM节点中搜索该研究。", + "not_found": "未在本地或远程DICOM节点中找到该研究。", + "retrieved_html": "已检索{count}个实例。", + "retrieving": "检索研究。" + }, + "searching": "搜索中...", + "select_files": "选择文件", + "select_folder": "选择文件夹", + "send_to": { + "button_title": "发送", + "dicom": "发送至DICOM节点", + "dicom_web": "发送至DICOMWeb服务器", + "orthanc_peer": "发送至Orthanc对等节点", + "transfers": "发送至Orthanc对等节点（高级传输）" + }, + "series": "系列", + "series_count_header": "系列数", + "series_plural": "系列", + "settings": { + "dicom_AET": "DICOM AET", + "dicom_port": "DICOM端口", + "ingest_transcoding": "摄取转码", + "installed_plugins": "已安装的插件", + "orthanc_name": "Orthanc名称", + "orthanc_system_info": "Orthanc系统信息", + "orthanc_version": "Orthanc版本", + "overwrite_instances": "覆盖实例", + "plugins_not_enabled": "已加载但未启用或配置不正确的插件为", + "statistics": "统计", + "storage_compression": "存储压缩", + "storage_size": "存储大小", + "striked_through": "删除线", + "title": "设置", + "verbosity_level": "详细级别" + }, + "share": { + "anonymize": "匿名化？", + "button_title": "共享", + "copy_and_close": "复制并关闭", + "days": "天", + "expires_in": "过期时间", + "link": "链接", + "modal_title": "共享研究", + "never": "永不" + }, + "show_errors": "显示错误", + "studies": "研究", + "study": "研究", + "this_patient_has_no_other_studies": "该患者没有其他研究。", + "this_patient_has_other_studies": "该患者共有{count}个研究。", + "this_patient_has_other_studies_show": "显示它们！", + "token": { + "error_token_expired_html": "您的令牌已过期。", + "error_token_invalid_html": "您的令牌无效。
请确保完整粘贴或与提供给您的人员联系。", + "error_token_unknown_html": "您的令牌无效。
请确保完整粘贴或与提供给您的人员联系。", + "token_being_checked_html": "正在验证您的令牌。" + }, + "trace": "跟踪", + "upload": "上传", + "uploaded_studies": "已上传的研究", + "verbose": "详细", + "view_in_meddream": "在MedDream中查看", + "view_in_ohif": "在OHIF中查看", + "view_in_osimis": "在OsimisViewer中查看", + "view_in_stone": "在StoneViewer中查看", + "view_in_volview": "在VolView中查看" +} \ No newline at end of file diff --git a/WebApplication/src/main-landing.js b/WebApplication/src/main-landing.js new file mode 100644 index 0000000..b8788d3 --- /dev/null +++ b/WebApplication/src/main-landing.js @@ -0,0 +1,41 @@ +import { createApp } from 'vue' +import AppLanding from './AppLanding.vue' +import i18n from './locales/i18n' +import "bootstrap/dist/css/bootstrap.min.css" +import "bootstrap/dist/js/bootstrap.bundle.min.js" +import "bootstrap-icons/font/bootstrap-icons.css" +import "@fortawesome/fontawesome-free/css/all.min.css" +import store from "./store" +import orthancApi from './orthancApi' +import axios from 'axios' + + +// Names of the params that can contain an authorization token +// If one of these params contain a token, it will be passed as a header +// with each request to the Orthanc API +const VALID_TOKEN_PARAMS = ["token", "auth-token", "authorization"]; + + +// before initialization, we must load part of the configuration to know if we need to enable Keycloak or not +axios.get('../api/pre-login-configuration').then((config) => { + + const app = createApp(AppLanding) + + app.use(store) + app.use(i18n) + + // If there is a param with a token in the params, use it as a header in subsequent calls to the Orthanc API + const params = new URLSearchParams(window.location.search); + + for (let paramName of VALID_TOKEN_PARAMS) { + const paramValue = params.get(paramName); + + if (!paramValue) continue; + + localStorage.setItem(paramName, paramValue); + orthancApi.updateAuthHeader(paramName); + } + + app.mount('#app-landing') + +}); diff --git a/WebApplication/src/main-retrieve-and-view.js b/WebApplication/src/main-retrieve-and-view.js new file mode 100644 index 0000000..9c7bf58 --- /dev/null +++ b/WebApplication/src/main-retrieve-and-view.js @@ -0,0 +1,41 @@ +import { createApp } from 'vue' +import AppRetrieveAndView from './AppRetrieveAndView.vue' +import i18n from './locales/i18n' +import "bootstrap/dist/css/bootstrap.min.css" +import "bootstrap/dist/js/bootstrap.bundle.min.js" +import "bootstrap-icons/font/bootstrap-icons.css" +import "@fortawesome/fontawesome-free/css/all.min.css" +import store from "./store" +import orthancApi from './orthancApi' +import axios from 'axios' + + +// Names of the params that can contain an authorization token +// If one of these params contain a token, it will be passed as a header +// with each request to the Orthanc API +const VALID_TOKEN_PARAMS = ["token", "auth-token", "authorization"]; + + +// before initialization, we must load part of the configuration to know if we need to enable Keycloak or not +axios.get('../api/pre-login-configuration').then((config) => { + + const app = createApp(AppRetrieveAndView) + + app.use(store) + app.use(i18n) + + // If there is a param with a token in the params, use it as a header in subsequent calls to the Orthanc API + const params = new URLSearchParams(window.location.search); + + for (let paramName of VALID_TOKEN_PARAMS) { + const paramValue = params.get(paramName); + + if (!paramValue) continue; + + localStorage.setItem(paramName, paramValue); + orthancApi.updateAuthHeader(paramName); + } + + app.mount('#app-retrieve-and-view') + +}); diff --git a/WebApplication/src/main.js b/WebApplication/src/main.js new file mode 100644 index 0000000..396f409 --- /dev/null +++ b/WebApplication/src/main.js @@ -0,0 +1,115 @@ +import { createApp } from 'vue' +import App from './App.vue' +import i18n from './locales/i18n' +import "bootstrap/dist/css/bootstrap.min.css" +import "bootstrap/dist/js/bootstrap.bundle.min.js" +import "bootstrap-icons/font/bootstrap-icons.css" +import "@fortawesome/fontawesome-free/css/all.min.css" +import "./assets/css/layout.css" +import "./assets/css/common.css" +import store from "./store" +import { router } from './router' +import Keycloak from "keycloak-js" +import orthancApi from './orthancApi' +import axios from 'axios' +import Datepicker from '@vuepic/vue-datepicker'; +import '@vuepic/vue-datepicker/dist/main.css'; +import mitt from "mitt" +import VueObserveVisibility from 'vue3-observe-visibility' + +// Names of the params that can contain an authorization token +// If one of these params contain a token, it will be passed as a header +// with each request to the Orthanc API +const VALID_TOKEN_PARAMS = ["token", "auth-token", "authorization"]; + +// before initialization, we must load part of the configuration to know if we need to enable Keycloak or not +axios.get('../api/pre-login-configuration').then((config) => { + + const app = createApp(App) + const messageBus = mitt(); + + app.use(router) + app.use(store) + app.use(i18n) + app.use(VueObserveVisibility) + app.component('Datepicker', Datepicker); + + app.config.globalProperties.messageBus = messageBus; + + let keycloackConfig = null; + + if (config.data['Keycloak'] && config.data['Keycloak'] != null && config.data['Keycloak']['Enable']) { + console.log("Keycloak is enabled"); + + keycloackConfig = config.data['Keycloak'] + + let initOptions = { + url: keycloackConfig['Url'], + realm: keycloackConfig['Realm'], + clientId: keycloackConfig['ClientId'], + onLoad: 'login-required' + } + + window.keycloak = new Keycloak(initOptions); + + window.keycloak.init({ onLoad: initOptions.onLoad }).then(async (auth) => { + + if (!auth) { + window.location.reload(); + } else { + console.log("Authenticated"); + } + + localStorage.setItem("vue-token", window.keycloak.token); + localStorage.setItem("vue-refresh-token", window.keycloak.refreshToken); + orthancApi.updateAuthHeader(); + + app.mount('#app'); + console.log("App mounted with keycloak, current route is ", router.currentRoute.value.fullPath); + + // keycloak includes state, code and session_state -> the router does not like them -> remove them + const params = new URLSearchParams(router.currentRoute.value.fullPath); + params.delete('state'); + params.delete('code'); + params.delete('session_state'); + const cleanedRoute = decodeURIComponent(params.toString()).replace('/=', '/'); + console.log("App mounted, moving to cleaned route ", cleanedRoute); + await router.push(cleanedRoute); + + // programm token refresh at regular interval + setInterval(() => { + window.keycloak.updateToken(70).then((refreshed) => { + if (refreshed) { + console.log('Token refreshed'); + localStorage.setItem("vue-token", window.keycloak.token); + localStorage.setItem("vue-refresh-token", window.keycloak.refreshToken); + orthancApi.updateAuthHeader(); + } else { + console.log('Token not refreshed, valid for ' + + Math.round(window.keycloak.tokenParsed.exp + window.keycloak.timeSkew - new Date().getTime() / 1000) + ' seconds'); + } + }).catch(() => { + console.log('Failed to refresh token'); + }); + + }, 60000) + + }).catch(() => { + console.log("Could not connect to Keycloak"); + }); + } else { + // If there is a param with a token in the params, use it as a header in subsequent calls to the Orthanc API + const params = new URLSearchParams(window.location.search); + + for (let paramName of VALID_TOKEN_PARAMS) { + const paramValue = params.get(paramName); + + if (!paramValue) continue; + + localStorage.setItem(paramName, paramValue); + orthancApi.updateAuthHeader(paramName); + } + + app.mount('#app') + } +}); diff --git a/WebApplication/src/orthancApi.js b/WebApplication/src/orthancApi.js new file mode 100644 index 0000000..c7e3033 --- /dev/null +++ b/WebApplication/src/orthancApi.js @@ -0,0 +1,682 @@ +import axios from "axios" +import store from "./store" + +import { orthancApiUrl, oe2ApiUrl } from "./globalConfigurations"; + +export default { + updateAuthHeader(headerKey = null) { + axios.defaults.headers.common[headerKey ?? "token"] = localStorage.getItem(headerKey ?? "vue-token") + }, + async loadOe2Configuration() { + return (await axios.get(oe2ApiUrl + "configuration")).data; + }, + async loadDicomWebServers() { + return (await axios.get(orthancApiUrl + "dicom-web/servers")).data; + }, + async loadOrthancPeers() { + return (await axios.get(orthancApiUrl + "peers")).data; + }, + async loadDicomModalities() { + return (await axios.get(orthancApiUrl + "modalities?expand")).data; + }, + async loadSystem() { + return (await axios.get(orthancApiUrl + "system")).data; + }, + async sendToDicomWebServer(resourcesIds, destination) { + const response = (await axios.post(orthancApiUrl + "dicom-web/servers/" + destination + "/stow", { + "Resources" : resourcesIds, + "Synchronous": false + })); + + return response.data['ID']; + }, + async sendToOrthancPeer(resourcesIds, destination) { + const response = (await axios.post(orthancApiUrl + "peers/" + destination + "/store", { + "Resources" : resourcesIds, + "Synchronous": false + })); + + return response.data['ID']; + }, + async sendToOrthancPeerWithTransfers(resources, destination) { + const response = (await axios.post(orthancApiUrl + "transfers/send", { + "Resources" : resources, + "Compression": "gzip", + "Peer": destination, + "Synchronous": false + })); + + return response.data['ID']; + }, + async sendToDicomModality(resourcesIds, destination) { + const response = (await axios.post(orthancApiUrl + "modalities/" + destination + "/store", { + "Resources" : resourcesIds, + "Synchronous": false + })); + + return response.data['ID']; + }, + async getJobStatus(jobId) { + const response = (await axios.get(orthancApiUrl + "jobs/" + jobId)); + return response.data; + }, + async deleteResource(level, orthancId) { + return axios.delete(orthancApiUrl + this.pluralizeResourceLevel(level) + "/" + orthancId); + }, + async deleteResources(resourcesIds) { + return axios.post(orthancApiUrl + "tools/bulk-delete", { + "Resources": resourcesIds + }); + }, + async cancelFindStudies() { + if (window.axiosFindStudiesAbortController) { + window.axiosFindStudiesAbortController.abort(); + window.axiosFindStudiesAbortController = null; + } + }, + async findStudies(filterQuery, labels, LabelsConstraint, orderBy, since) { + await this.cancelFindStudies(); + window.axiosFindStudiesAbortController = new AbortController(); + + let limit = store.state.configuration.uiOptions.MaxStudiesDisplayed; + if (store.state.configuration.hasExtendedFind) { + limit = store.state.configuration.uiOptions.PageLoadSize; + } + + let payload = { + "Level": "Study", + "Limit": limit, + "Query": filterQuery, + "RequestedTags": store.state.configuration.requestedTagsForStudyList, + "Expand": true + }; + + if (labels && labels.length > 0) { + payload["Labels"] = labels; + payload["LabelsConstraint"] = LabelsConstraint; + } + + if (orderBy && orderBy.length > 0) { + payload["OrderBy"] = orderBy; + } + + if (since) { + payload["Since"] = since; + } + + return (await axios.post(orthancApiUrl + "tools/find", payload, + { + signal: window.axiosFindStudiesAbortController.signal + })).data; + }, + async getMostRecentStudiesExtended(label) { + await this.cancelFindStudies(); + window.axiosFindStudiesAbortController = new AbortController(); + + let payload = { + "Level": "Study", + "Limit": store.state.configuration.uiOptions.PageLoadSize, + "Query": {}, + "RequestedTags": store.state.configuration.requestedTagsForStudyList, + "OrderBy" : [{ + 'Type': 'Metadata', + 'Key': 'LastUpdate', + 'Direction': 'DESC' + }], + "Expand": true + }; + if (label) { + payload["Labels"] = [label]; + payload["LabelsConstraint"] = "All"; + } + + return (await axios.post(orthancApiUrl + "tools/find", payload, + { + signal: window.axiosFindStudiesAbortController.signal + })).data; + }, + async getLastChangeId() { + const response = (await axios.get(orthancApiUrl + "changes?last")); + return response.data["Last"]; + }, + async getChanges(since, limit) { + const response = (await axios.get(orthancApiUrl + "changes?since=" + since + "&limit=" + limit)); + return response.data; + }, + async getChangesExtended(to, limit, filter = []) { + let url = orthancApiUrl + "changes?to=" + to + "&limit=" + limit; + if (filter.length > 0) { + url += "&type=" + filter.join(";") + } + const response = (await axios.get(url)); + return response.data; + }, + async getSamePatientStudies(patientTags, tags) { + if (!tags || tags.length == 0) { + console.error("Unable to getSamePatientStudies if 'tags' is not defined or empty"); + return {}; + } + + let query = {}; + for (let tag of tags) { + if (tag in patientTags) { + query[tag] = patientTags[tag]; + } + } + const response = (await axios.post(orthancApiUrl + "tools/find", { + "Level": "Study", + "Query": query, + "Expand": false + })); + return response.data; + }, + async findPatient(patientId) { + const response = (await axios.post(orthancApiUrl + "tools/lookup", patientId)); + if (response.data.length == 1) { + const patient = (await axios.get(orthancApiUrl + "patients/" + response.data[0]['ID'])); + return patient.data; + } else { + return null; + } + }, + async findStudy(studyInstanceUid) { + const response = (await axios.post(orthancApiUrl + "tools/lookup", studyInstanceUid)); + if (response.data.length == 1) { + const study = (await axios.get(orthancApiUrl + "studies/" + response.data[0]['ID'])); + return study.data; + } else { + return null; + } + }, + async studyExists(studyInstanceUid) { + const response = (await axios.post(orthancApiUrl + "tools/lookup", studyInstanceUid)); + return response.data.length >= 1; + }, + async mergeSeriesInExistingStudy({seriesIds, targetStudyId, keepSource}) { + const response = (await axios.post(orthancApiUrl + "studies/" + targetStudyId + "/merge", { + "Resources": seriesIds, + "KeepSource": keepSource, + "Synchronous": false + })); + return response.data['ID']; + }, + async cancelRemoteDicomFind() { + if (window.axiosRemoteDicomFindAbortController) { + window.axiosRemoteDicomFindAbortController.abort(); + window.axiosRemoteDicomFindAbortController = null; + } + }, + async remoteDicomFind(level, remoteModality, filterQuery, isUnique) { + if (isUnique) { + await this.cancelRemoteDicomFind(); + window.axiosRemoteDicomFindAbortController = new AbortController(); + } + + try { + let axiosOptions = {} + if (isUnique) { + axiosOptions['signal'] = window.axiosRemoteDicomFindAbortController.signal + } + const queryResponse = (await axios.post(orthancApiUrl + "modalities/" + remoteModality + "/query", { + "Level": level, + "Query": filterQuery + }, + axiosOptions + )).data; + // console.log(queryResponse); + const answers = (await axios.get(orthancApiUrl + "queries/" + queryResponse["ID"] + "/answers?expand&simplify")).data; + // console.log(answers); + return answers; + } catch (err) + { + console.log("Error during query:", err); // TODO: display error to user + return {}; + } + }, + async qidoRs(level, remoteServer, filterQuery, isUnique){ + if (isUnique) { + await this.cancelQidoRs(); + window.axiosQidoRsAbortController = new AbortController(); + } + + try { + let axiosOptions = {} + if (isUnique) { + axiosOptions['signal'] = window.axiosQidoRsAbortController.signal + } + let uri = null; + if (level == "Study") { + uri = "/studies"; + } else if (level == "Series") { + uri = "/studies/" + filterQuery["StudyInstanceUID"] + "/series"; + delete filterQuery["StudyInstanceUID"]; // we don't need it the filter since it is in the url + } else if (level == "Instance") { + uri = "/studies/" + filterQuery["StudyInstanceUID"] + "/series/" + filterQuery["SeriesInstanceUID"] + "/instances"; + delete filterQuery["StudyInstanceUID"]; // we don't need it the filter since it is in the url + delete filterQuery["SeriesInstanceUID"]; + } + let args = {...filterQuery}; + args["limit"] = String(store.state.configuration.uiOptions.MaxStudiesDisplayed); + args["fuzzymatching"] = "true"; + + const queryResponse = (await axios.post(orthancApiUrl + "dicom-web/servers/" + remoteServer + "/qido", { + "Uri": uri, + "Arguments": args + }, + axiosOptions + )).data; + // transform the response into something similar to a DICOM C-Find API response + let responses = []; + for (let qr of queryResponse) { + let r = {} + for (const [k, v] of Object.entries(qr)) { + if (v.Value) { + r[v.Name] = v.Value; + } + } + responses.push(r); + } + return responses; + } catch (err) + { + console.log("Error during query:", err); // TODO: display error to user + return {}; + } + }, + async cancelQidoRs() { + if (window.axiosQidoRsAbortController) { + window.axiosQidoRsAbortController.abort(); + window.axiosQidoRsAbortController = null; + } + }, + async wadoRsRetrieve(remoteServer, resources){ + const retrieveJob = (await axios.post(orthancApiUrl + "dicom-web/servers/" + remoteServer + "/retrieve", { + "Resources": resources, + "Asynchronous": true + } + )).data; + return retrieveJob["ID"]; + }, + async remoteDicomRetrieveResource(level, remoteModality, filterQuery, targetAet) { + return this.remoteDicomRetrieveResources(level, remoteModality, [filterQuery], targetAet); + }, + async remoteDicomRetrieveResources(level, remoteModality, filterQueries, targetAet) { + const retrieveMethod = this.getRetrieveMethod(remoteModality); + + let uriSegment = "/get"; + let query = { + "Level": level, + "Resources" : filterQueries, + "Synchronous": false + } + + if (retrieveMethod == "C-MOVE") { + query["TargetAet"] = targetAet; + uriSegment = "/move"; + } + + const response = (await axios.post(orthancApiUrl + "modalities/" + remoteModality + uriSegment, query)); + return response.data['ID']; + }, + async remoteModalityEcho(remoteModality) { + return axios.post(orthancApiUrl + "modalities/" + remoteModality + "/echo", {}); + }, + async uploadFile(filecontent) { + return (await axios.post(orthancApiUrl + "instances", filecontent)).data; + }, + async triggerMammographyPlugin(requestBodyData) { + return (await axios.post(orthancApiUrl + "mammography-apply", requestBodyData)).data; + }, + async createDicom(parentId, content, tags) { + return (await axios.post(orthancApiUrl + "tools/create-dicom", { + "Parent": parentId, + "Tags": tags, + "Content": content + })).data + }, + async getPatient(orthancId) { + return (await axios.get(orthancApiUrl + "patients/" + orthancId)).data; + }, + async getStudy(orthancId) { + // returns the same result as a findStudies (including RequestedTags !) + return (await axios.get(orthancApiUrl + "studies/" + orthancId + "?requestedTags=" + store.state.configuration.requestedTagsForStudyList.join(';'))).data; + }, + async getStudySeries(orthancId) { + return (await axios.get(orthancApiUrl + "studies/" + orthancId + "/series")).data; + }, + async getSeriesInstances(orthancId) { + return (await axios.get(orthancApiUrl + "series/" + orthancId + "/instances")).data; + }, + async getSeriesInstancesExtended(orthancId, since) { + const limit = store.state.configuration.uiOptions.PageLoadSize; + let payload = { + "Level": "Instance", + "Limit": limit, + "ParentSeries": orthancId, + "Query": {}, + "OrderBy" : [ + { "Type": "MetadataAsInt", + "Key": "IndexInSeries", + "Direction": "ASC" + } + ], + "Expand": true + }; + + if (since) { + payload["Since"] = since; + } + + const response = (await axios.post(orthancApiUrl + "tools/find", payload)); + return response.data; + }, + async getStudyInstances(orthancId) { + return (await axios.get(orthancApiUrl + "studies/" + orthancId + "/instances")).data; + }, + async getStudyInstancesExpanded(orthancId, requestedTags) { + let url = orthancApiUrl + "studies/" + orthancId + "/instances?expanded"; + if (requestedTags && requestedTags.length > 0) { + url += "&requestedTags=" + requestedTags.join(";") + } + return (await axios.get(url)).data; + }, + async getSeriesParentStudy(orthancId) { + return (await axios.get(orthancApiUrl + "series/" + orthancId + "/study")).data; + }, + async getInstanceParentStudy(orthancId) { + return (await axios.get(orthancApiUrl + "instances/" + orthancId + "/study")).data; + }, + async getResourceStudy(orthancId, level) { + if (level == "study") { + return (await this.getStudy(orthancId)); + } else if (level == "series") { + return (await this.getSeriesParentStudy(orthancId)); + } else if (level == "instance") { + return (await this.getInstanceParentStudy(orthancId)); + } else { + console.error("unsupported level for getResourceStudyId", level); + } + }, + async getInstanceTags(orthancId) { + return (await axios.get(orthancApiUrl + "instances/" + orthancId + "/tags")).data; + }, + async getSimplifiedInstanceTags(orthancId) { + return (await axios.get(orthancApiUrl + "instances/" + orthancId + "/tags?simplify")).data; + }, + async getInstanceHeader(orthancId) { + return (await axios.get(orthancApiUrl + "instances/" + orthancId + "/header")).data; + }, + async getStatistics() { + return (await axios.get(orthancApiUrl + "statistics")).data; + }, + async getPermissionsList() { + return (await axios.get(orthancApiUrl + "auth/settings/permissions")).data; + }, + async getRolesConfig() { + return (await axios.get(orthancApiUrl + "auth/settings/roles")).data; + }, + async setRolesConfig(roles) { + return (await axios.put(orthancApiUrl + "auth/settings/roles", roles)).data; + }, + async getDelayedDeletionStatus() { + return (await axios.get(orthancApiUrl + "plugins/delayed-deletion/status")).data; + }, + async generateUid(level) { + return (await axios.get(orthancApiUrl + "tools/generate-uid?level=" + level)).data; + }, + async setVerboseLevel(level) { + await axios.put(orthancApiUrl + "tools/log-level", level); + }, + + async getVerboseLevel() { + return (await axios.get(orthancApiUrl + "tools/log-level")).data; + }, + + async anonymizeResource({resourceLevel, orthancId, replaceTags={}, removeTags=[]}) { + const response = (await axios.post(orthancApiUrl + this.pluralizeResourceLevel(resourceLevel) + "/" + orthancId + "/anonymize", { + "Replace": replaceTags, + "Remove": removeTags, + "KeepSource": true, + "Force": true, + "Synchronous": false + })) + + return response.data['ID']; + }, + + async modifyResource({resourceLevel, orthancId, replaceTags={}, removeTags=[], keepTags=[], keepSource}) { + const response = (await axios.post(orthancApiUrl + this.pluralizeResourceLevel(resourceLevel) + "/" + orthancId + "/modify", { + "Replace": replaceTags, + "Remove": removeTags, + "Keep": keepTags, + "KeepSource": keepSource, + "KeepLabels": true, + "Force": true, + "Synchronous": false + })) + + return response.data['ID']; + }, + + async loadAllLabels() { + const response = (await axios.get(orthancApiUrl + "tools/labels")); + return response.data; + }, + + async addLabel({studyId, label}) { + await axios.put(orthancApiUrl + "studies/" + studyId + "/labels/" + label, ""); + return label; + }, + + async removeLabel({studyId, label}) { + await axios.delete(orthancApiUrl + "studies/" + studyId + "/labels/" + label); + return label; + }, + + async removeAllLabels(studyId) { + const labels = await this.getLabels(studyId); + let promises = []; + for (let label of labels) { + promises.push(this.removeLabel({ + studyId: studyId, + label: label + })); + } + await Promise.all(promises); + return labels; + }, + + async getLabels(studyId) { + const response = (await axios.get(orthancApiUrl + "studies/" + studyId + "/labels")); + return response.data; + }, + + async updateLabels({studyId, labels}) { + const currentLabels = await this.getLabels(studyId); + const labelsToRemove = currentLabels.filter(x => !labels.includes(x)); + const labelsToAdd = labels.filter(x => !currentLabels.includes(x)); + let promises = []; + + // console.log("labelsToRemove: ", labelsToRemove); + // console.log("labelsToAdd: ", labelsToAdd); + for (const label of labelsToRemove) { + promises.push(this.removeLabel({ + studyId: studyId, + label: label + })); + } + for (const label of labelsToAdd) { + promises.push(this.addLabel({ + studyId: studyId, + label: label + })); + } + await Promise.all(promises); + return labelsToAdd.length > 0 || labelsToRemove.length > 0; + }, + + + + async createToken({tokenType, resourcesIds, level, validityDuration=null, id=null, expirationDate=null}) { + let body = { + "Resources" : [], + "Type": tokenType + } + + for (let resourceId of resourcesIds) { + // the authorization are performed at study level -> get parent study id if needed + const study = await this.getResourceStudy(resourceId, level); + body["Resources"].push({ + "OrthancId": study["ID"], + "DicomUid": study["MainDicomTags"]["StudyInstanceUID"], + "Level": 'study' + }) + } + + if (validityDuration != null) { + body["ValidityDuration"] = validityDuration; + } + + if (expirationDate != null) { + body["ExpirationDate"] = expirationDate.toJSON(); + } + + if (id != null) { + body["Id"] = id; + } + + const response = (await axios.put(orthancApiUrl + "auth/tokens/" + tokenType, body)); + // console.log(response); + + return response.data; + }, + async parseToken(tokenKey, tokenValue) { + const response = (await axios.post(orthancApiUrl + "auth/tokens/decode", { + "TokenKey": tokenKey, + "TokenValue": tokenValue + })) + + return response.data; + }, + async getLabelStudyCount(label) { + const response = (await axios.post(orthancApiUrl + "tools/count-resources", { + "Level": "Study", + "Query": {}, + "Labels": [label], + "LabelsConstraint" : "All" + })); + return response.data["Count"]; + }, + + ////////////////////////////////////////// HELPERS + getOsimisViewerUrl(level, resourceOrthancId) { + return orthancApiUrl + 'osimis-viewer/app/index.html?' + level + '=' + resourceOrthancId; + }, + getStoneViewerUrl(level, resourceDicomUid) { + return orthancApiUrl + 'stone-webviewer/index.html?' + level + '=' + resourceDicomUid; + }, + getVolViewUrl(level, resourceOrthancId) { + const volViewVersion = store.state.configuration.installedPlugins.volview.Version; + const urls = 'urls=[../' + this.pluralizeResourceLevel(level) + '/' + resourceOrthancId + '/archive]'; + if (volViewVersion == '1.0') { + return orthancApiUrl + 'volview/index.html?' + urls; + } else { + return orthancApiUrl + 'volview/index.html?names=[archive.zip]&' + urls; + } + }, + getWsiViewerUrl(seriesOrthancId) { + return orthancApiUrl + 'wsi/app/viewer.html?series=' + seriesOrthancId; + }, + getStoneViewerUrlForBulkStudies(studiesDicomIds) { + return orthancApiUrl + 'stone-webviewer/index.html?study=' + studiesDicomIds.join(","); + }, + getOhifViewerUrlForDicomJson(mode, resourceOrthancId) { + if (mode == 'basic') { + return store.state.configuration.uiOptions.OhifViewer3PublicRoot + 'viewer?url=../studies/' + resourceOrthancId + "/ohif-dicom-json"; + } else if (mode == 'vr') { + return store.state.configuration.uiOptions.OhifViewer3PublicRoot + 'viewer?hangingprotocolId=mprAnd3DVolumeViewport&url=../studies/' + resourceOrthancId + "/ohif-dicom-json"; + } else if (mode == 'tmtv') { + return store.state.configuration.uiOptions.OhifViewer3PublicRoot + 'tmtv?url=../studies/' + resourceOrthancId + "/ohif-dicom-json"; + } else if (mode == 'seg') { + return store.state.configuration.uiOptions.OhifViewer3PublicRoot + 'segmentation?url=../studies/' + resourceOrthancId + "/ohif-dicom-json"; + } else if (mode == 'microscopy') { + return store.state.configuration.uiOptions.OhifViewer3PublicRoot + 'microscopy?url=../studies/' + resourceOrthancId + "/ohif-dicom-json"; + } + }, + getOhifViewerUrlForDicomWeb(mode, resourceDicomUid) { + if (store.state.configuration.uiOptions.EnableOpenInOhifViewer3) { + if (mode == 'basic') { + return store.state.configuration.uiOptions.OhifViewer3PublicRoot + 'viewer?StudyInstanceUIDs=' + resourceDicomUid; + } else if (mode == 'vr') { + return store.state.configuration.uiOptions.OhifViewer3PublicRoot + 'viewer?hangingprotocolId=mprAnd3DVolumeViewport&StudyInstanceUIDs=' + resourceDicomUid; + } else if (mode == 'tmtv') { + return store.state.configuration.uiOptions.OhifViewer3PublicRoot + 'tmtv?StudyInstanceUIDs=' + resourceDicomUid; + } else if (mode == 'seg') { + return store.state.configuration.uiOptions.OhifViewer3PublicRoot + 'segmentation?StudyInstanceUIDs=' + resourceDicomUid; + } else if (mode == 'microscopy') { + return store.state.configuration.uiOptions.OhifViewer3PublicRoot + 'microscopy?StudyInstanceUIDs=' + resourceDicomUid; + } + } else { + return store.state.configuration.uiOptions.OhifViewerPublicRoot + 'Viewer/' + resourceDicomUid; + } + }, + getOhifViewerUrlForDicomWebBulkStudies(mode, studiesDicomIds) { + if (store.state.configuration.uiOptions.EnableOpenInOhifViewer3) { + return this.getOhifViewerUrlForDicomWeb(mode, studiesDicomIds.join(",")); + } else { + return null; + } + }, + getInstancePreviewUrl(orthancId) { + return orthancApiUrl + "instances/" + orthancId + "/preview"; + }, + getInstancePdfUrl(orthancId) { + return orthancApiUrl + "instances/" + orthancId + "/pdf"; + }, + getInstanceDownloadUrl(orthancId) { + return orthancApiUrl + "instances/" + orthancId + "/file"; + }, + getDownloadZipUrl(level, resourceOrthancId) { + return orthancApiUrl + this.pluralizeResourceLevel(level) + '/' + resourceOrthancId + '/archive'; + }, + getBulkDownloadZipUrl(resourcesOrthancId) { + if (resourcesOrthancId.length > 0) + { + return orthancApiUrl + "tools/create-archive?resources=" + resourcesOrthancId.join(','); + } + return undefined; + }, + getBulkDownloadDicomDirUrl(resourcesOrthancId) { + if (resourcesOrthancId.length > 0) + { + return orthancApiUrl + "tools/create-media?resources=" + resourcesOrthancId.join(','); + } + return undefined; + }, + getDownloadDicomDirUrl(level, resourceOrthancId) { + return orthancApiUrl + this.pluralizeResourceLevel(level) + '/' + resourceOrthancId + '/media'; + }, + getApiUrl(level, resourceOrthancId, subroute) { + return orthancApiUrl + this.pluralizeResourceLevel(level) + '/' + resourceOrthancId + subroute; + }, + getRetrieveMethod(modality) { + const defaultRetrieveMethod = store.state.configuration.system.DefaultRetrieveMethod; + if (store.state.configuration.queryableDicomModalities[modality].RetrieveMethod == "SystemDefault") { + return defaultRetrieveMethod; + } else { + return store.state.configuration.queryableDicomModalities[modality]; + } + }, + + pluralizeResourceLevel(level) { + if (level == "study") { + return "studies" + } else if (level == "instance") { + return "instances" + } else if (level == "patient") { + return "patients" + } else if (level == "series") { + return "series" + } + } +} diff --git a/WebApplication/src/router.js b/WebApplication/src/router.js new file mode 100644 index 0000000..320710a --- /dev/null +++ b/WebApplication/src/router.js @@ -0,0 +1,71 @@ +import { createRouter, createWebHashHistory } from 'vue-router' +import Settings from './components/Settings.vue' +import SettingsLabels from './components/SettingsLabels.vue' +import SettingsPermissions from './components/SettingsPermissions.vue' +import StudyList from './components/StudyList.vue' +import SideBar from './components/SideBar.vue' +import NotFound from './components/NotFound.vue' +import { baseOe2Url } from "./globalConfigurations" + +console.log('Base URL for router: ', baseOe2Url); + +function removeKeyCloakStates(to, from, next) { + if (to.path.includes("&state=")) { + // the router does not recognize the &state=... after a redirect from KeyCloak -> simply block it (it works but I don't really understand why !) + console.log("removeKeyCloakStates", to, from); + next(false); + } else { + next(); + } +} + +export const router = createRouter({ + history: createWebHashHistory(baseOe2Url), + routes: [ + { + path: '/', + alias: '/index.html', + components: { + SideBarView: SideBar, + ContentView: StudyList, + }, + }, + { + path: '/filtered-studies', + components: { + SideBarView: SideBar, + ContentView: StudyList, + }, + }, + { + path: '/settings', + components: { + SideBarView: SideBar, + ContentView: Settings, + }, + }, + { + path: '/settings-labels', + components: { + SideBarView: SideBar, + ContentView: SettingsLabels, + }, + }, + { + path: '/settings-permissions', + components: { + SideBarView: SideBar, + ContentView: SettingsPermissions, + }, + }, + { + path: '/:pathMatch(.*)', + beforeEnter: removeKeyCloakStates, + components: { + SideBarView: SideBar, + ContentView: NotFound, + }, + } + + ], +}) diff --git a/WebApplication/src/store/index.js b/WebApplication/src/store/index.js new file mode 100644 index 0000000..2880b8c --- /dev/null +++ b/WebApplication/src/store/index.js @@ -0,0 +1,18 @@ +import { createStore, createLogger } from 'vuex' +import configuration from './modules/configuration' +import studies from './modules/studies' +import jobs from './modules/jobs' +import labels from './modules/labels' + +const debug = process.env.NODE_ENV !== 'production' + +export default createStore({ + modules: { + studies, + configuration, + jobs, + labels + }, + strict: debug, + plugins: debug ? [createLogger()] : [] +}) \ No newline at end of file diff --git a/WebApplication/src/store/modules/configuration.js b/WebApplication/src/store/modules/configuration.js new file mode 100644 index 0000000..95d9b8f --- /dev/null +++ b/WebApplication/src/store/modules/configuration.js @@ -0,0 +1,176 @@ +import api from "../../orthancApi" +import resourceHelpers from "../../helpers/resource-helpers" + +///////////////////////////// STATE +const state = () => ({ + installedPlugins: {}, + orthancPeers: [], + targetDicomWebServers: [], + queryableDicomWebServers: [], + queryableDicomModalities: {}, + targetDicomModalities: {}, + maxStudiesDisplayed: 100, + orthancApiUrl: "../../", + uiOptions: {}, + userProfile: null, + tokens: {}, + loaded: false, + system: {}, + ohifDataSource: "dicom-web", + customLogoUrl: null, + hasCustomLogo: false, + requestedTagsForStudyList: [], + hasExtendedFind: false, + hasExtendedChanges: false, +}) + +///////////////////////////// GETTERS +const getters = { +} + +///////////////////////////// MUTATIONS + +const mutations = { + setUiOptions(state, { uiOptions }) { + state.uiOptions = uiOptions; + + if (uiOptions.StudyListColumns.indexOf('modalities') != -1) { + state.requestedTagsForStudyList.push('ModalitiesInStudy') + } + if (uiOptions.StudyListColumns.indexOf('instancesCount') != -1 || uiOptions.StudyListColumns.indexOf('seriesAndInstancesCount') != -1) { + state.requestedTagsForStudyList.push('NumberOfStudyRelatedInstances') + } + if (uiOptions.StudyListColumns.indexOf('seriesCount') != -1 || uiOptions.StudyListColumns.indexOf('seriesAndInstancesCount') != -1) { + state.requestedTagsForStudyList.push('NumberOfStudyRelatedSeries') + } + if (uiOptions.EnableReportQuickButton) { + state.requestedTagsForStudyList.push('SOPClassesInStudy'); // to detect PDF files + } + }, + setUserProfile(state, { profile }) { + state.userProfile = profile; + }, + setInstalledPlugin(state, { plugin, pluginConfiguration }) { + state.installedPlugins[plugin] = pluginConfiguration; + }, + setDicomWebServers(state, { dicomWebServers }) { // TODO: split in two + state.targetDicomWebServers = dicomWebServers; + state.queryableDicomWebServers = dicomWebServers; + }, + setOhifDataSource(state, { ohifDataSource }) { + state.ohifDataSource = ohifDataSource; + }, + setOrthancPeers(state, { orthancPeers }) { + state.orthancPeers = orthancPeers; + }, + setDicomModalities(state, { dicomModalities }) { // TODO: split in two + state.queryableDicomModalities = dicomModalities; + state.targetDicomModalities = dicomModalities; + }, + setSystem(state, { system }) { + state.system = system; + state.hasExtendedFind = "Capabilities" in state.system && state.system.Capabilities.HasExtendedFind; + state.hasExtendedChanges = "Capabilities" in state.system && state.system.Capabilities.HasExtendedChanges; + }, + setLoaded(state) { + state.loaded = true; + }, + setTokens(state, { tokens }) { + state.tokens = tokens; + }, + setCustomLogo(state, { customLogoUrl, hasCustomLogo }) { + state.hasCustomLogo = hasCustomLogo; + state.customLogoUrl = customLogoUrl; + } + +} + +///////////////////////////// ACTIONS + +const actions = { + async load({ commit, state}) { + await this.dispatch('configuration/loadOe2Configuration'); + + if (state.uiOptions.EnableSendTo) { + try { + const orthancPeers = await api.loadOrthancPeers(); + commit('setOrthancPeers', { orthancPeers: orthancPeers}); + } catch (err) { + console.warn("can not get Orthanc peers - not authorized ?") + } + } + + if (state.uiOptions.EnableSendTo || state.uiOptions.EnableDicomModalities) { + try { + const dicomModalities = await api.loadDicomModalities(); + commit('setDicomModalities', { dicomModalities: dicomModalities}); + } catch (err) { + console.warn("can not get DICOM modalities - not authorized ?") + } + } + + const system = await api.loadSystem(); + commit('setSystem', { system: system}); + + commit('setLoaded'); + }, + async loadOe2Configuration({ commit }) { + const oe2Config = await api.loadOe2Configuration(); + commit('setUiOptions', { uiOptions: oe2Config['UiOptions']}); + commit('setTokens', { tokens: oe2Config['Tokens']}); + + if ('Profile' in oe2Config) { + commit('setUserProfile', { profile: oe2Config['Profile']}); + } + document._mustTranslateDicomTags = oe2Config['UiOptions']['TranslateDicomTags']; + + if ('HasCustomLogo' in oe2Config) { + let customLogoUrl = null; + if ('CustomLogoUrl' in oe2Config) { + customLogoUrl = oe2Config['CustomLogoUrl'] + } + commit('setCustomLogo', { customLogoUrl: customLogoUrl, hasCustomLogo: oe2Config['HasCustomLogo']}); + } + + if ('CustomTitle' in oe2Config) { + document.title = oe2Config['CustomTitle']; + } else { + document.title = "Orthanc Explorer 2"; + } + + if ('UiOptions' in oe2Config && 'PatientNameFormatting' in oe2Config['UiOptions'] && 'PatientNameCapture' in oe2Config['UiOptions']) { + resourceHelpers.patientNameCapture = oe2Config['UiOptions']['PatientNameCapture']; + resourceHelpers.patientNameFormatting = oe2Config['UiOptions']['PatientNameFormatting']; + } + + for (const [pluginName, pluginConfiguration] of Object.entries(oe2Config['Plugins'])) { + + commit('setInstalledPlugin', { plugin: pluginName, pluginConfiguration: pluginConfiguration}) + + if (pluginName === "dicom-web") { + try { + const dicomWebServers = await api.loadDicomWebServers(); + commit('setDicomWebServers', { dicomWebServers: dicomWebServers}); + } catch (err) { + console.warn("can not get DicomWEB servers - not authorized ?") + } + } else if (pluginName === "ohif") { + commit('setOhifDataSource', { ohifDataSource: pluginConfiguration["DataSource"]}) + } + + } + + }, +} + + + +///////////////////////////// EXPORT + +export default { + namespaced: true, + state, + getters, + mutations, + actions, +} \ No newline at end of file diff --git a/WebApplication/src/store/modules/i18n.js b/WebApplication/src/store/modules/i18n.js new file mode 100644 index 0000000..e7af5b4 --- /dev/null +++ b/WebApplication/src/store/modules/i18n.js @@ -0,0 +1,21 @@ +let allLanguages = [ + { name: "English", key: "en" }, + { name: "Deutsch", key: "de" }, + { name: "Español", key: "es" }, + { name: "Français", key: "fr" }, + { name: "Italiano", key: "it" }, + { name: "ქართული", key: "ka" }, + { name: "Русский", key: "ru" }, + { name: "Slovensko", key: "si" }, + { name: "Українська", key: "uk" }, + { name: '中文', key: 'zh' } + // { name: 'Português', key: 'pt' }, + // { name: 'Deutsche', key: 'de' }, + // { name: 'Nederlands', key: 'nl' }, + // { name: '日本語', key: 'jp' }, + // { name: 'বাংলা', key: 'bn' }, + // { name: 'Bahasa', key: 'xn' }, + // { name: 'हिंदू', key: 'hi' }, + // { name: 'Kiswahili', key: 'sw' }, +] +export default allLanguages; \ No newline at end of file diff --git a/WebApplication/src/store/modules/jobs.js b/WebApplication/src/store/modules/jobs.js new file mode 100644 index 0000000..3b5d7c3 --- /dev/null +++ b/WebApplication/src/store/modules/jobs.js @@ -0,0 +1,73 @@ +import api from "../../orthancApi" + +// job = { +// 'id': '123' +// 'name': "Send to DICOM PACS" +// 'isRunning': false, +// 'status': //response from orthanc /jobs/... +// } + +///////////////////////////// STATE +const state = () => ({ + jobs: {}, // map of jobs + jobsIds: [], // jobs ids created by the user during this session + maxJobsInHistory: 5 +}) + +///////////////////////////// GETTERS +const getters = { +} + +///////////////////////////// MUTATIONS + +const mutations = { + addJob(state, { jobId, name }) { + const job = { + 'id': jobId, + 'name': name, + 'isRunning': true, + 'status': null + } + state.jobsIds.push(jobId); + state.jobs[jobId] = job; + }, + removeJob(state, { jobId }) { + const pos = state.jobsIds.indexOf(jobId); + if (pos >= 0) { + state.jobsIds.splice(pos, 1); + } + delete state.jobs[jobId]; + } +} + +///////////////////////////// ACTIONS + +const actions = { + addJob({ commit, state }, payload) { + const jobId = payload['jobId']; + const name = payload['name']; + commit('addJob', { jobId: jobId, name: name }); + + if (this.state.configuration.uiOptions.MaxMyJobsHistorySize > 0) { + while (state.jobsIds.length > this.state.configuration.uiOptions.MaxMyJobsHistorySize) { + commit('removeJob', { jobId: state.jobsIds[0] }) + } + } + }, + removeJob({ commit }, payload) { + const jobId = payload['jobId']; + commit('removeJob', { jobId: jobId }); + }, +} + + + +///////////////////////////// EXPORT + +export default { + namespaced: true, + state, + getters, + mutations, + actions, +} \ No newline at end of file diff --git a/WebApplication/src/store/modules/labels.js b/WebApplication/src/store/modules/labels.js new file mode 100644 index 0000000..067f4e9 --- /dev/null +++ b/WebApplication/src/store/modules/labels.js @@ -0,0 +1,39 @@ +import api from "../../orthancApi" + +///////////////////////////// STATE +const state = () => ({ + allLabels: [] // all labels in Orthanc +}) + +///////////////////////////// GETTERS +const getters = { +} + +///////////////////////////// MUTATIONS + +const mutations = { + setLabels(state, { allLabels }) { + state.allLabels = allLabels; + } +} + +///////////////////////////// ACTIONS + +const actions = { + async refresh({ commit }) { + const allLabels = await api.loadAllLabels(); + commit('setLabels', { allLabels: allLabels }); + } +} + + + +///////////////////////////// EXPORT + +export default { + namespaced: true, + state, + getters, + mutations, + actions, +} \ No newline at end of file diff --git a/WebApplication/src/store/modules/studies.js b/WebApplication/src/store/modules/studies.js new file mode 100644 index 0000000..4f117a3 --- /dev/null +++ b/WebApplication/src/store/modules/studies.js @@ -0,0 +1,369 @@ +import api from "../../orthancApi" +import SourceType from "../../helpers/source-type"; +import store from "../../store" + +const _clearedFilter = { + StudyDate : "", + AccessionNumber: "", + PatientID: "", + PatientName: "", + PatientBirthDate: "", + StudyDescription: "", + StudyInstanceUID: "", + ModalitiesInStudy: "", +} + +///////////////////////////// STATE +const state = () => ({ + studies: [], // studies as returned by tools/find + studiesIds: [], + dicomTagsFilters: {..._clearedFilter}, + labelFilters: [], + orderByFilters: [], + statistics: {}, + isSearching: false, + selectedStudiesIds: [], + selectedStudies: [], + sourceType: SourceType.LOCAL_ORTHANC, + remoteSource: null, +}) + +function insert_wildcards(initialValue) { + // 'filter' -> *filter* (by default, adds the wildcard before and after) + // '"filter' -> filter* (a double quote means "no wildcard") + // 'filter"' -> *filter (a double quote means "no wildcard") + // '"filter"' -> filter (= exact match) + let finalValue = '*' + initialValue.replaceAll('"', '*') + '*'; + return finalValue.replaceAll('**', ''); +} + +async function get_studies_shared(context, append) { + const commit = context.commit; + const state = context.state; + const getters = context.getters; + + if (!append) { + commit('setStudiesIds', { studiesIds: [] }); + commit('setStudies', { studies: [] }); + } + + try { + commit('setIsSearching', { isSearching: true}); + let studies = []; + + if (state.sourceType == SourceType.LOCAL_ORTHANC) { + let orderBy = [...state.orderByFilters]; + if (state.orderByFilters.length == 0) { + orderBy.push({'Type': 'Metadata', 'Key': 'LastUpdate', 'Direction': 'DESC'}) + } + let since = (append ? state.studiesIds.length : null); + + if (!store.state.configuration.hasExtendedFind) { + orderBy = null; + } + studies = (await api.findStudies(getters.filterQuery, state.labelFilters, "All", orderBy, since)); + } else if (state.sourceType == SourceType.REMOTE_DICOM || state.sourceType == SourceType.REMOTE_DICOM_WEB) { + // make sure to fill all columns of the StudyList + let filters = { + "PatientBirthDate": "", + "PatientID": "", + "PatientName": "", + "AccessionNumber": "", + "PatientBirthDate": "", + "StudyDescription": "", + "StudyDate": "" + }; + + // request values for e.g ModalitiesInStudy, NumberOfStudyRelatedSeries + for (let t of store.state.configuration.requestedTagsForStudyList) { + filters[t] = ""; + } + + // overwrite with the filtered values + for (const [k, v] of Object.entries(getters.filterQuery)) { + filters[k] = v; + } + + let remoteStudies; + if (state.sourceType == SourceType.REMOTE_DICOM) { + remoteStudies = (await api.remoteDicomFind("Study", state.remoteSource, filters, true /* isUnique */)); + } else if (state.sourceType == SourceType.REMOTE_DICOM_WEB) { + remoteStudies = (await api.qidoRs("Study", state.remoteSource, filters, true /* isUnique */)); + } + + // copy the tags in MainDicomTags, ... to have a common study structure between local and remote studies + studies = remoteStudies.map(s => { return {"MainDicomTags": s, "PatientMainDicomTags": s, "RequestedTags": s, "ID": s["StudyInstanceUID"]} }); + } + + studies = studies.map(s => {return {...s, "sourceType": state.sourceType} }); + let studiesIds = studies.map(s => s['ID']); + + if (!append) { + commit('setStudiesIds', { studiesIds: studiesIds }); + commit('setStudies', { studies: studies }); + } else { + commit('extendStudiesIds', { studiesIds: studiesIds }); + commit('extendStudies', { studies: studies }); + } + } catch (err) { + console.log("Find studies cancelled", err); + } finally { + commit('setIsSearching', { isSearching: false}); + } +} + +///////////////////////////// GETTERS +const getters = { + filterQuery: (state) => { + let query = {}; + for (const [k, v] of Object.entries(state.dicomTagsFilters)) { + if (v && v.length >= 1 && k != 'labels') { + if (['StudyDate', 'PatientBirthDate'].indexOf(k) != -1) { + // for dates, accept only exactly 8 chars + if (v.length >= 8) { + query[k] = v; + } + } else if (['StudyInstanceUID', 'ModalitiesInStudy'].indexOf(k) != -1) { + // exact match + query[k] = v; + } else { + // wildcard match for all other fields + query[k] = insert_wildcards(v); + } + } + } + return query; + }, + isFilterEmpty: (state) => { + for (const [k, v] of Object.entries(state.dicomTagsFilters)) { + if (k == 'ModalitiesInStudy') { + if (v && v != 'NONE') { + return false; + } + } else { + if (v && v.length >= 1) { + return false; + } + } + } + // dicomTags filter is empty, check the labels + return (!state.labelsFilter || state.labelsFilter.length == 0); + } +} + +///////////////////////////// MUTATIONS + +const mutations = { + setStudiesIds(state, { studiesIds }) { + state.studiesIds = studiesIds; + }, + setStudies(state, { studies }) { + state.studies = studies; + }, + extendStudiesIds(state, { studiesIds }) { + state.studiesIds.push(...studiesIds); + }, + extendStudies(state, { studies }) { + state.studies.push(...studies); + }, + addStudy(state, { studyId, study }) { + if (!state.studiesIds.includes(studyId)) { + state.studiesIds.push(studyId); + state.studies.push(study); + } else { + for (let s in state.studies) { + if (state.studies[s].ID == studyId) { + state.studies[s] = study; + } + } + } + }, + setFilter(state, { dicomTagName, value }) { + state.dicomTagsFilters[dicomTagName] = value; + }, + clearFilter(state) { + state.dicomTagsFilters = {..._clearedFilter}; + state.labelFilters = []; + }, + setLabelFilters(state, { labels }) { + state.labelFilters = []; + for (let f of labels) { + state.labelFilters.push(f); + } + }, + setOrderByFilters(state, { orderBy }) { + console.log("setOrderByFilters"); + state.orderByFilters = []; + for (let f of orderBy) { + state.orderByFilters.push(f); + } + }, + setSource(state, { sourceType, remoteSource }) { + state.sourceType = sourceType; + state.remoteSource = remoteSource; + }, + deleteStudy(state, {studyId}) { + const pos = state.studiesIds.indexOf(studyId); + if (pos >= 0) { + state.studiesIds.splice(pos, 1); + } + state.studies = state.studies.filter(s => s["ID"] != studyId); + + // also delete from selection + const pos2 = state.selectedStudiesIds.indexOf(studyId); + if (pos2 >= 0) { + state.selectedStudiesIds.splice(pos, 1); + } + }, + refreshStudyLabels(state, {studyId, labels}) { + for (const i in state.studies) { + if (state.studies[i].ID == studyId) { + state.studies[i].Labels = labels + } + } + }, + setStatistics(state, {statistics}) { + state.statistics = statistics; + }, + setIsSearching(state, {isSearching}) { + state.isSearching = isSearching; + }, + selectStudy(state, {studyId, isSelected}) { + if (isSelected && !state.selectedStudiesIds.includes(studyId)) { + state.selectedStudiesIds.push(studyId); + state.selectedStudies = state.studies.filter(s => state.selectedStudiesIds.includes(s["ID"])); + } else if (!isSelected) { + const pos = state.selectedStudiesIds.indexOf(studyId); + if (pos >= 0) { + state.selectedStudiesIds.splice(pos, 1); + state.selectedStudies = state.selectedStudies.filter(s => s["ID"] != studyId); + } + } + }, + selectAllStudies(state, {isSelected}) { + if (isSelected) { + state.selectedStudiesIds = [...state.studiesIds]; + state.selectedStudies = [...state.studies]; + } else { + state.selectedStudiesIds = []; + state.selectedStudies = []; + } + + } +} + +///////////////////////////// ACTIONS + +const actions = { + async initialLoad({ commit, state}) { + this.dispatch('studies/loadStatistics'); + }, + async updateFilter({ commit }, payload) { + const dicomTagName = payload['dicomTagName']; + const value = payload['value']; + commit('setFilter', { dicomTagName, value }) + + this.dispatch('studies/reloadFilteredStudies'); + }, + async updateFilterNoReload({ commit }, payload) { + const dicomTagName = payload['dicomTagName']; + const value = payload['value']; + commit('setFilter', { dicomTagName, value }) + }, + async updateLabelFilterNoReload({ commit }, payload) { + const labels = payload['labels']; + commit('setLabelFilters', { labels }) + }, + async updateOrderByNoReload({ commit }, payload) { + const orderBy = payload['orderBy']; + commit('setOrderByFilters', { orderBy }) + }, + async updateOrderBy({ commit }, payload) { + const orderBy = payload['orderBy']; + commit('setOrderByFilters', { orderBy }) + + this.dispatch('studies/reloadFilteredStudies'); + }, + + async updateSource({ commit }, payload) { + const sourceType = payload['source-type']; + const remoteSource = payload['remote-source']; + commit('setSource', { sourceType, remoteSource }); + commit('selectAllStudies', { isSelected: false}); // clear selection when changing source + }, + async clearFilter({ commit, state }) { + commit('clearFilter'); + + this.dispatch('studies/reloadFilteredStudies'); + }, + async clearFilterNoReload({ commit }) { + commit('clearFilter'); + }, + async clearStudies({ commit }) { + commit('setStudiesIds', { studiesIds: [] }); + commit('setStudies', { studies: [] }); + }, + async extendFilteredStudies({ commit, getters, state }) { + get_studies_shared({ commit, getters, state }, true); + }, + async reloadFilteredStudies({ commit, getters, state }) { + get_studies_shared({ commit, getters, state }, false); + }, + async cancelSearch() { + await api.cancelFindStudies(); + }, + async loadStatistics({ commit }) { + const statistics = (await api.getStatistics()); + commit('setStatistics', { statistics: statistics }); + }, + async deleteStudy({ commit }, payload) { + const studyId = payload['studyId']; + commit('deleteStudy', { studyId }); + this.dispatch('studies/loadStatistics'); + }, + async addStudy({ commit }, payload) { + const studyId = payload['studyId']; + const study = payload['study']; + const reloadStats = payload['reloadStats']; + commit('addStudy', { studyId: studyId, study: study }); + if (reloadStats) { + this.dispatch('studies/loadStatistics'); + } + }, + async selectStudy({ commit }, payload) { + const studyId = payload['studyId']; + const isSelected = payload['isSelected']; + commit('selectStudy', { studyId: studyId, isSelected: isSelected}); + }, + async selectAllStudies({ commit }, payload) { + const isSelected = payload['isSelected']; + commit('selectAllStudies', { isSelected: isSelected}); + }, + async reloadStudy({ commit }, payload) { + const studyId = payload['studyId']; + const study = payload['study']; + commit('addStudy', { studyId: studyId, study: study }); + this.dispatch('studies/loadStatistics'); + }, + async refreshStudiesLabels({ commit }, payload) { + const studiesIds = payload['studiesIds']; + + for (const studyId of studiesIds) { + const labels = await api.getLabels(studyId); + + commit('refreshStudyLabels', { studyId: studyId, labels: labels}); + } + }, +} + + + +///////////////////////////// EXPORT + +export default { + namespaced: true, + state, + getters, + mutations, + actions, +} \ No newline at end of file diff --git a/WebApplication/token-landing.html b/WebApplication/token-landing.html new file mode 100644 index 0000000..5cad213 --- /dev/null +++ b/WebApplication/token-landing.html @@ -0,0 +1,13 @@ + + + + + + + OE2 Token landing + + +
+ + + diff --git a/WebApplication/vite.config.js b/WebApplication/vite.config.js new file mode 100644 index 0000000..fa72112 --- /dev/null +++ b/WebApplication/vite.config.js @@ -0,0 +1,40 @@ +import { defineConfig } from 'vite' +import { resolve } from 'path' +import vue from '@vitejs/plugin-vue' + +// https://vitejs.dev/config/ +export default defineConfig({ + assetsInclude: './src/assets', + base: '', + plugins: [vue()], + server: { + host: true, + port: 3000 + }, + build: { + chunkSizeWarningLimit: 1000, + rollupOptions: { + input: { + main: resolve(__dirname, 'index.html'), + landing: resolve(__dirname, 'token-landing.html'), + retrieve: resolve(__dirname, 'retrieve-and-view.html') + }, + } + }, + css: { + postcss: { // to avoid this warning: https://github.com/vitejs/vite/discussions/5079 + plugins: [ + { + postcssPlugin: 'internal:charset-removal', + AtRule: { + charset: (atRule) => { + if (atRule.name === 'charset') { + atRule.remove(); + } + } + } + } + ] + } + } +}) diff --git a/release-notes.md b/release-notes.md new file mode 100644 index 0000000..4039a77 --- /dev/null +++ b/release-notes.md @@ -0,0 +1,556 @@ +Pending changes +=============== + +Changes: + - Experimental new configuration "Tokens.RequiredForLinks" can be set to false + when using HTTP Basic authentication together with the authorization plugin + (https://discourse.orthanc-server.org/t/user-based-access-control-with-label-based-resource-access/5454). + + +1.7.1 (2025-01-22) +================== + +Fixes: + - Added status text in job progress bar. + - When retrieving a study from a remote DICOM modality, use the default retrieve method: + C-GET or C-MOVE. + - Fixed empty PatientName column when querying a remote DICOM modality. + - Fixed a few small issues when navigating between local and remote studies. + + +1.7.0 (2024-12-19) +================== + +Changes: + - When Orthanc DB supports "ExtendedFind" (SQLite in 1.12.5+ and PosgreSQL 7.0+): + - new features in the local studies list: + - Allow sorting by columns + - Optimized loading of "most-recent" studies + - Load the following studies when scrolling to the bottom of the current list. + - New configuration "EnableLabelsCount" to enable/disable the display of the number of studies with each label. + - The "MaxStudiesDisplayed" configuration is not taken into account anymore for + the local study list since we have implemented "infinite-scroll". However, the option + is still used when performing remote DicomWEB queries. + - New configuration "PageLoadSize" that defines the number of items that are loaded when scrolling the study or instance list. + - The "StudyListContentIfNoSearch" configuration is not taken into account and always considered as "most-recents". + - New "order-by" argument in the url to open the UI directly on a search result, e.g: + http://localhost:8042/ui/app/#/filtered-studies?StudyDate=20231213-20241213&order-by=DicomTag,StudyDate,ASC;DicomTag,PatientName,ASC;Metadata,LastUpdate,DESC + - Disable some UI components on ReadOnly systems. + - The study list header is now sticking on top of the screen. + - Quick report icon: now display the SeriesDate - SeriesDescription in a tooltip. + +Fixes: + - When modifying studies, dates selected from the DatePicker were not always taken into account. + - Fixed the criteria to display the OHIF Segmentation viewer. + - Fixed display of invalid dates like 00000000. + - Fixed compatibility with OHIF 1.4 if OHIF.DataSource is not defined. + + +1.6.4 (2024-10-10) +================== + +Changes: + - new configuration "EnableViewerQuickButton" to enable/disable a button + to open a viewer directly from the study list (default value: true). + - new configuration "EnableReportQuickButton" to enable/disable a button + to open a PDF report directly from the study list if a PDF report isavailable + in the study. (default value: false). + Note that, with Orthanc version up to 1.12.4, this option may slow down the + display of the study list but this will be solved in the next Orthanc version. + +Fixes: + - When modifying studies, dates selected from the DatePicker were not always taken into account. + - Primary viewer icon was not visible when using an external OHIF viewer. + + +1.6.2 (2024-09-23) +================== + +Changes: + - Added a clickable icon to open the primary viewer without expanding the study. + - Added a clickable icon to open a PDF report without expanding the study. + - new configuration "CustomFavIconPath" to customize the FavIcon + - new configuration "CustomTitle" to customize the tab/window title + - new configurations to modify the PatientName display: + - "PatientNameCapture", a Javascript regular expression to capture the words of PatientName + - "PatientNameFormatting", a replacement expression using the captured words + +Fixes: + - Fixed (again) the "UiOptions.EnableApiViewMenu" configuration that was not taken into account. The API View button was never visible. + + +1.6.1 (2024-08-29) +================== + +Changes: + - new configuration values for "UiOptions.StudyListColumns": + - "instancesCount" to show the number of instances in a study + - "seriesAndInstancesCount" to show the number of series/instances in a study. This now replaces "seriesCount" in the default configuration. + +Fixes: + - Fixed the "UiOptions.EnableApiViewMenu" configuration that was not taken into account. The API View button was always visible. + - [Issue #65](https://github.com/orthanc-server/orthanc-explorer-2/issues/65) SeriesCount column is empty. + - [Issue #63](https://github.com/orthanc-server/orthanc-explorer-2/issues/63) This/last week selection in Date picker now starts on monday. + - [Bug #232](https://orthanc.uclouvain.be/bugs/show_bug.cgi?id=232) Clarified compilation instructions and use LOCAL dist folder by default. + + +1.6.0 (2024-08-02) +================== + +Changes: + - POSSIBLE BREAKING CHANGE: the Osimis viewer button is not listed anymore by default. In order + to re-enable it, you must provide it to the "UiOptions.ViewersOrdering" configuration. + - Orthanc Explorer 2 is now the default Orthanc UI when the plugin is installed. + - Refactored the Remote Study List when browsing remote DICOM Modalities. It is now identical to the main + local study list with a reduced list of actions (only the retrieve action is available). + - the /ui/app/#/filtered-remote-studies has been replaced by /ui/app/#/filtered-studies?source-type=dicom&remote-source=... + - Now providing the ability to browse remote DICOMWeb servers. + - Authorization tokens can be provided in the URL as query args e.g: http://localhost:8042/ui/app/?token=my-token + or /ui/app/filtered-studies?StudyDescription=PET&token=my-token and these tokens will be included as HTTP headers + in all requests issued by OE2. Note that the query args must be positioned before the '#' in the URL. + List of valid tokens are "token", "auth-token", "authorization". + - Now sorting the results of a search by StudyDate. + + +Fixes: + - Labels list was not displayed in the "Permissions" edition UI. + - Opening /ui/app now redirects to /ui/app/ instead of failing opening the UI. + + +1.5.1 (2024-07-03) +================== + +Fixes: + - Broken interface when the auth-service was not configured to implement the role/permission API + + +1.5.0 (2024-06-27) +================== + +Changes: + - Implemented a new permission UI in case you are using OE2 together with Keycloak and an authorisation service that implements a role/permission API. + - New configuration "AvailableLabels" to forbid creation of labels that are not defined in this list. If the list is empty, anyone can create any new label. + +Fixes: + - [Issue #57](https://github.com/orthanc-server/orthanc-explorer-2/issues/57) Avoid double calls to tools/find when selecting a label or clicking on `search` button + - In the settings page, the status of the python plugin was not correct. + + +1.4.1 (2024-06-05) +================== + +Changes: +- Settings: if the [Delayed Deletion plugin](https://orthanc.uclouvain.be/book/plugins/delayed-deletion-plugin.html) + is enabled, display the number of files pending deletion. + +Fixes: + - Prevent using invalid characters when adding labels to a study. + - [Issue #58](https://github.com/orthanc-server/orthanc-explorer-2/issues/58) Upload function only uploads the first file. + + +1.4.0 (2024-05-16) +================== + +Changes: +- Added a "Add series" button to the study to create new series from PDF, images or STL files + - New configurations: + - "EnableAddSeries" + - "AddSeriesDefaultTags" + +Fixes: + - [Issue #51](https://github.com/orthanc-server/orthanc-explorer-2/issues/51) Stop calling /changes once all studies are displayed. + - [Issue #52](https://github.com/orthanc-server/orthanc-explorer-2/issues/52) Removed duplicate calls to /studies/../series and /series/../instances. + - [Issue #53](https://github.com/orthanc-server/orthanc-explorer-2/issues/53) Changing selection in Modalities in Study works immediately even if `"StudyListSearchMode": "search-button"`. + - [Issue #54](https://github.com/orthanc-server/orthanc-explorer-2/issues/54) OHIF disappeared after #52 fix + - [Issue #55](https://github.com/orthanc-server/orthanc-explorer-2/issues/55) DateFormat not respected + introduced DatePicker in the Modification Modal. + - Removed duplicate calls to /tools/find in Modification modal + + +1.3.0 (2024-03-25) +================== + +Changes: +- Theming the interface: + - New configurations: + - "Theme" to select the default "light" or "dark" theme. + - "CustomCssPath" to complement the default CSS by a custom one. + - "CustomLogoPath" to provide your own custom logo from disk. + - "CustomLogoUrl" to provide your own custom logo from an external url. + - "DateFormat" to customize the date format in study list and in the date pickers. +- OHIF Integration: + - Added support for `Segmentation` and `Microscopy` modes. The `Microscopy` + mode is disabled by default since it is not stable yet in OHIF. + - You can now enable/disable OHIF viewer modes by including/removing them + from the `ViewersOrdering` configuration. + - OHIF buttons are now visible/hidden depending on the content of the study. +- Configurations: + - Updated default values for `ViewersIcons` and `ViewersOrdering`. +- Added date pickers in the Remote Study List (when performing searches on + remote modalities) +- When editing a study, it is now possible to add an `OtherPatientIDs` DICOM tag. + +Internals: + - Updated all JS libraries. + + +1.2.2 (2024-02-16) +================== + +Changes: +- Now keeping labels when modifying a study or a series. + This fix requires Orthanc 1.12.3. +- Added Slovenian translations +- Now showing the DICOM header content at instance level (TransferSyntax, ...) +- Instance preview now handles PDF correctly. +- Now displaying #Patients and MaximumPatientCount in Settings. + + +Fixes: +- fixed delete on multiple selection in Firefox + + +1.2.1 (2024-01-03) +================== + +Fixes: +- Handle quotes correctly when "PatientBirthDate" is defined in "ShowSamePatientStudiesFilter" +- fix #42: Studies disappear from list when unselecting them. +- fix #34: Enable copy button when context is not secure. + + +1.2.0 (2023-12-19) +================== + +Changes: +- Added a button to download multiple studies at once (only available if running an + Orthanc version > 1.12.1 - not officially released at the time this plugin was + released) +- Bew configuration "UiOptions.ShowSamePatientStudiesFilter" to list the tags that + are used to identify studies belonging to the same patient. +- Added Russian translations +- Added a button to share multiple studies at once. +- Now displaying the MaximumStorageSize in the settings page. +- New configurations "UiOptions.Modifications.SeriesAllowedModes" & "UiOptions.Modifications.SeriesDefaultMode" + to configure how series are modified. If only one option is available, it is not displayed and the + default option is selected. +- In "Modify Patient Tags", allow applying changes even if nothing has changed e.g. to apply all current + Patient tags to all studies with the same Patient ID. + +Fixes: +- fix #43: Missing 'ModalitiesInStudy' in response in remote system QR breaks search result preview. + + +1.1.3 (2023-10-04) +================== + +Fixes: +- fix target of 'open Orthanc Explorer 2' button in legacy OE +- repair tables background color (bug in 1.1.2) + +1.1.2 (2023-10-03) +================== + +Fixes: +- new labels now appears/disappears on the side bar when they are created/deleted from a study +- study labels are listed correctly when reoopening a study + + +1.1.1 (2023-09-18) +================== + +Changes: +- added German translations +- show username in side bar + +Fixes: +- internal: fixed a typo in tools/find request +- fix UI loading when user is not authorized to access to DicomWEB servers +- #30: preserve double spaces in tag values. +- fix labels filtering + +1.1.0 (2023-08-16) +================== + +Fixes: +- fixed an XSS vulnerability (many thanks to Abebe Hailu from kth.se) + +1.0.3 (2023-07-14) +================== + +Changes: +- added support for opening the WSI viewer on series + +1.0.2 (2023-06-27) +================= + +Fixes: +- fix ModalitiesInStudy filtering +- fix links to uploaded studies + + +1.0.1 (2023-06-21) +================= + +Changes: +- added support for OHIF plugin: + - new default value for the 'OhifViewer3PublicRoot' configuration: '/ohif/' + - now displaying 3 buttons to open OHIF in basic mode, Volume Rendering and TMTV modes + - 2 more viewers can be listed in 'ViewersIcons' and in 'ViewersOrdering': "ohif-vr" & "ohif-tmtv" +- added support for labels + - new 'UiOptions.EnableEditLabels' configuration +- added support for VolView 1.1 plugin +- 'StudyListColumns' can now contain any DICOM Tag that is stored as a MainDicomTag or ExtraMainDicomTag +- added Ukrainian and Chinese translations thanks to Stephen D. Scotti, 'Franklin' and Juriy Cherednichock + +Fixes: +- use auth token for /preview if required + + +0.9.3 (2023-05-15) +================== + +Changes: +- allow opening MedDream viewer on multiple studies +- new italian translations thanks to Stefano Feroldi +- new georgian translations thanks to Yomarbuzz + +Fixes: +- improved integration with OHIF v3 and keycloak + + +0.9.2 (2023-04-17) +================== + +Changes: +- new configuration 'StudyListContentIfNoSearch' to replace 'StudyListEmptyIfNoSearch'. Allowed values are + "empty", "most-recents" (default) +- configuration 'StudyListEmptyIfNoSearch' is now deprecated. You should now use "StudyListContentIfNoSearch": "empty". +- now reporting the status of Multitenant DICOM plugin in the settings page +- added button "Open Orthanc Explorer 2" in Orthanc Explorer +- new configuration 'EnableOpenInOhifViewer3' and 'OhifViewer3PublicRoot' + +Fixes: +- In the settings page, the status of the python plugin was not correct. + + +0.8.2 (2023-03-27) +================== + +Fixes: +- If OE2 configuration did not include "UiOptions" section, the UI failed to run correctly. + +Changes: +- Added an icon to open a study or a series in VolView +- In the settings page, do not show buttons to open plugin UI if user-permissions are enabled, these UI + wouldn't work anyway since they do not support tokens. + +0.8.1 (2023-03-24) +================== + +Fixes: +- Since the introduction of multiple selections, is was not possible to open the StoneViewer on a single study +- Auth tokens were not refreshed correctly. + +0.8.0 (2023-03-22) +================== + +Changes: +- Allow actions on multiple studies: + - open StoneViewer + - send to + - delete +- Refactored the Study List headers to show bulk action buttons + +Fixes: +- #9 EnableAnonimization spelled wrong in configuration file: you should now use UiOptions.EnableAnonymization instead. Both spellings + are currently accepted but only the new spelling might be accepted in future versions. + +0.7.0 (2023-03-17) +================== + +Changes: +- Introduced a Date Picker for the StudyDate and PatientBirthDate +- Introduced user-permissions and authorization tokens linked to the authorization plugin and new auth-service API +- Configuration: new "Tokens" section +- new "landing" page at /ui/app/token-landing.html?token=... to validate tokens and display a user friendly message if the token + is invalid. Redirects to the viewer if the token is valid. +- new "landing" page at /ui/app/retrieve-and-view.html?StudyInstanceUID=1.2.3....&modality=pacs&viewer=stone-viewer to open the viewer + on a study that might already be stored in Orthanc or, if not, that can be fetched from a DICOM modality. + +BREAKING CHANGES: +- Shares: removed anonymized shares +- Shares: is now using the authorization plugin to generate tokens. This requires the new auth-service API +- Shares: removed "Shares" configuration section, part of it has been moved to the "Tokens" section + + +0.6.0 (2023-02-03) +================== + +Changes: +- allow modification of series and studies +- allow anonymization of series and studies +- new configuration 'Modifications' +- new configuration 'TranslateDicomTags' +- new configurations 'StudyMainDicomTags', 'PatientMainDicomTags' to define the list of tags to display in the study details +- new link to open all studies from the same patient + +Note: the 'Modify' and 'Anonymization' dialog are only available in English in this version. + +0.5.1 (2022-12-20) +================== + +Changes: +- report correct status for object storage plugins +- improved french translations + +Fixes: +- fix default values for AvailableLanguages to all languages + +0.5.0 (2022-12-16) +================== + +Changes: +- added multi-language support +- new configurations: 'AvailableLanguages', 'DefaultLanguage' +- shares: enable "stone-viewer-publication" type + +Fixes: +- WO-63: instant-link only works if EnableShares is true + +0.4.3 (2022-11-03) +================== + +Changes: +- added 2 configurations to chose the viewer icons and the order in which they appear: + 'ViewersOrdering' and 'ViewersIcons'. The default configuration is identical to the 0.4.1 behaviour. +- adapted orthanc-share API + +0.4.2 (2022-10-28) +================== + +Changes: +- implement study sharing UI for orthanc-share project (still confidential, will be presented at OrthancCon 2022) +- open MedDream with a one time token if connected with orthanc-share project +- reorganized icons for viewers to always use 'eye' and 'eye-fill' for the first 2 enabled viewers. + +Fixes: +- SendTo and ApiView dropdown menu mixed up when both enabled + + +0.4.1 (2022-09-07) +================== + +Changes: +- new `EnableSendTo` option to enable/disable the `SendTo` button + +Fixes: +- SendTo and ApiView dropdown menu were mixed up + + + +0.4.0 (2022-08-30) +================== + +Changes: +- new simplified interface to query DICOM modalities and retrieve study. + It does not allow yet browsing distant series/instances. Still a work in progress ! +- show C-Echo status of DICOM modalities. +- allow controling wildcards in text search to implement exact or partial match. + The default remains a partial match -> if you enter a `filterValue` text in a filter, + Orthanc will search for `*filterValue*`. By adding a `"` at the beginning or at the end of the text, you force an exact match at the beggining or at the end of the text. + + +Fixes: +- improved redirection when running behind a reverse-proxy +- support of dynamic linking against the system-wide Orthanc framework library +- support of LSB (Linux Standard Base) compilation + +Maintenance: +- upgraded all npm dependencies + +0.3.3 (2022-06-09) +================== + +Changes: +- added a button 'open in MedDream Viewer' +- added buttons to change log levels in settings page +- added 'transfer to peer' using the Transfers plugin + +- new configurations: + - "EnableOpenInMedDreamViewer" + - "MedDreamViewerPublicRoot" + +Fixes: +- display ReferringPhyisician, RequestingPhysician and InstitutionName in study list +- fix GDCM plugin status in settings page + +0.3.2 (2022-06-01) +================== + +Changes: +- showing 'searching' status and allow cancelling search + +- new configuration: + - "StudyListEmptyIfNoSearch" + + +0.3.1 (2022-05-31) +================== + +Changes: +- added a button 'open in OHIF Viewer' +- introduced two search modes "search-as-you-type" (suitable for small DBs) or "search-button" (suitable for large DB) + +- new configurations: + - "EnableOpenInOhifViewer" + - "OhifViewerPublicRoot" + - "StudyListSearchMode" + - "StudyListSearchAsYouTypeMinChars" + - "StudyListSearchAsYouTypeDelay" + + +0.3.0 (2022-05-23) +================== + +Changes: +- fixed 'send to peer' +- added 'send to modality' +- now displaying the transfer jobs created by 'send to peer', 'send to modality', 'send to dicom-web' + +- new configuration: + - "MaxMyJobsHistorySize" + +0.2.2 (2022-05-19) +================== + +Changes: +- show Orthanc "Name" in side bar +- changed color of Orthanc logo to white +- improved relative URL computation when running behind a reverse proxy +- added an 'expand' query argument with values to expand studies, series ... to use with only a few resources ! + ``` + http://localhost:8042/ui/app/#/filtered-studies?StudyInstanceUID=1.2.3&expand + http://localhost:8042/ui/app/#/filtered-studies?StudyInstanceUID=1.2.3&expand=study + http://localhost:8042/ui/app/#/filtered-studies?StudyInstanceUID=1.2.3&expand=series + http://localhost:8042/ui/app/#/filtered-studies?StudyInstanceUID=1.2.3&expand=instance + ``` +- new configurations: + - "ShowOrthancName" + - "EnableDownloadZip" + - "EnableDownloadDicomDir" + - "EnableDownloadDicomFile" + +0.2.1 (2022-05-13) +================== + +Changes: +- new default root is now '/ui/' + +Fixes: +- allow display of patient tags in upload report +- upload: avoid calling /statistics for each instance (now only once per study uploaded) + +0.2.0 (2022-05-12) +================== + +initial release diff --git a/scripts/check-translations.py b/scripts/check-translations.py new file mode 100644 index 0000000..d1e1553 --- /dev/null +++ b/scripts/check-translations.py @@ -0,0 +1,82 @@ +#!/usr/bin/python3 + +import pathlib +import json +import glob +import pprint + +here = pathlib.Path(__file__).parent.resolve() + +reference_file_path = str(here / '../WebApplication/src/locales/en.json') +language_files_path = glob.glob(str(here / '../WebApplication/src/locales/*.json')) +source_files_path = glob.glob(str(here / '../WebApplication/src/**/*.vue'), recursive=True) + +with open(reference_file_path, 'rb') as f: + reference_content = json.load(f) + +# check if all entries in the default language file are being used +all_source_files_content = "" +for source_file in source_files_path: + with open(source_file, "rt") as f: + all_source_files_content += f.read() + +# collect all keys +all_keys = [] +def add_keys(node, prefix, all_keys): + for key in node: + if isinstance(node[key], dict): + add_keys(node[key], prefix=f"{key}.", all_keys=all_keys) + else: + all_keys.append(f"{prefix}{key}") + +add_keys(reference_content, "", all_keys=all_keys) + +for key in all_keys: + translations_text = [ + f'"{key}"', + f"'{key}'" + ] + found = False + for translation_text in translations_text: + if translation_text in all_source_files_content: + found = True + break + + if not found: + print(f"translation '{key}' does not seem to be used") + + +def compare_json_node(reference, value, prefix, missings = [], excessives = []): + for key in reference: + if not key in value: + missings.append(f"{prefix}{key}") + + elif isinstance(reference[key], dict): + compare_json_node(reference[key], value[key], prefix=f"{key}.", missings=missings, excessives=excessives) + for key in value: + if not key in reference: + excessives.append(f"{prefix}{key}") + + +for path in language_files_path: + if path != reference_file_path: + with open(path, 'rb') as f: + language_content = json.load(f) + + missings = [] + excessives = [] + + compare_json_node(reference_content, language_content, prefix="", missings=missings, excessives=excessives) + + if len(missings) > 0: + print(f">>> {path}, missing nodes in translation:") + for missing in missings: + print(f" {missing}") + + if len(excessives) > 0: + print(f">>> {path}, unused nodes in translation:") + for excessive in excessives: + print(f" {excessive}") + + if len(missings) == 0 and len(excessives) == 0: + print(f">>> {path}, translation is complete !") diff --git a/scripts/logs/.gitignore b/scripts/logs/.gitignore new file mode 100644 index 0000000..bf0824e --- /dev/null +++ b/scripts/logs/.gitignore @@ -0,0 +1 @@ +*.log \ No newline at end of file diff --git a/scripts/nginx-dev.conf b/scripts/nginx-dev.conf new file mode 100644 index 0000000..5023db7 --- /dev/null +++ b/scripts/nginx-dev.conf @@ -0,0 +1,80 @@ +# Local config to run orthanc and development UI on the same domain +# Uses port 9999 + +# `events` section is mandatory +events { + worker_connections 1024; # Default: 1024 +} + +http { + + # prevent nginx sync issues on OSX + proxy_buffering off; + include /etc/nginx/mime.types; + + server { # on port 9999: real time "run dev" server + listen 9999 default_server; + client_max_body_size 4G; + access_log logs/nginx-access.log; + error_log logs/nginx-error.log; + + # set $orthanc http://192.168.0.8:8042; + set $orthanc 'http://127.0.0.1:8043'; + + # Orthanc when accessed from the 'run dev' server + location ~* ^/(patients|studies|instances|series|plugins|system|tools|statistics|modalities|dicom-web|osimis-viewer|ohif|stone-webviewer|peers|jobs|transfers|queries|auth|app|volview|changes|wsi) { + + proxy_set_header HOST $host; + proxy_set_header X-Real-IP $remote_addr; + + proxy_pass $orthanc; + } + + location /ui/api/ { + proxy_set_header HOST $host; + proxy_set_header X-Real-IP $remote_addr; + + #rewrite (.*) /ui$1 break; + proxy_pass $orthanc; + } + + location /ui/app/customizable/ { + proxy_set_header HOST $host; + proxy_set_header X-Real-IP $remote_addr; + + #rewrite (.*) /ui$1 break; + proxy_pass $orthanc; + } + + # Frontend development server + location /ui/app/ { + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header HOST $host; + rewrite /ui/app(.*) $1 break; + + proxy_pass http://127.0.0.1:3000; + } + + location / { + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header HOST $host; + + proxy_pass http://127.0.0.1:3000; + } + + location /orthanc/ { + # URL to open in your browser: http://localhost:9999/orthanc/ui/ + + proxy_pass $orthanc; + rewrite /orthanc(.*) $1 break; + proxy_set_header Host $http_host; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_request_buffering off; + proxy_max_temp_file_size 0; + client_max_body_size 0; + } + + } +} diff --git a/scripts/start-nginx.sh b/scripts/start-nginx.sh new file mode 100644 index 0000000..5e00d2c --- /dev/null +++ b/scripts/start-nginx.sh @@ -0,0 +1,11 @@ +#!/bin/bash + +set -o errexit +set -o xtrace + + +SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd ) + +nginx -p $SCRIPT_DIR -c $SCRIPT_DIR/nginx-dev.conf + + diff --git a/scripts/stop-nginx.sh b/scripts/stop-nginx.sh new file mode 100644 index 0000000..835fd21 --- /dev/null +++ b/scripts/stop-nginx.sh @@ -0,0 +1,11 @@ +#!/bin/bash + +set -o errexit +set -o xtrace + + +SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd ) + +nginx -p $SCRIPT_DIR -c $SCRIPT_DIR/nginx-dev.conf -s stop + + diff --git a/tests/manual-tests.md b/tests/manual-tests.md new file mode 100644 index 0000000..fcc03ea --- /dev/null +++ b/tests/manual-tests.md @@ -0,0 +1,163 @@ +I know, this is old style manual tests ! Anyone willing to automate this is pretty welcome ! + + +Modifications +============= + +Prerequisites: + +- make sure there are no patients whose `PatientID` starts with `TEST` +- upload the test study from `tests/stimuli/TEST_1` + +Study modification +------------------ + + +Edit study tags to create a modified copy: +- on Study `Test CT`, `Modify Study tags` and change: + - `PatientBirthDate = 19500630` + - `PatientID = TEST_2` + - `PatientName = Test2` + - `AccessionNumber = 2345` + - `StudyDate = 20150101` + - `StudyID = 2` + - Insert `InstitutionName = MY` + - Remove `StudyDescription` + - select "Create a modified copy of the original study" + - Apply + - Check: You should now have 2 studies for `PatientID = TEST*` + - Check the new study has changed its tags + +Edit study tags 'in place': +- on the new Study (the one without `StudyDescription`), first copy-paste the `StudyInstanceUID` somewhere + - click `Modify Study tags`, and change: + - `StudyDate = 20200101` + - select "Modify the original study. (keeping the original DICOM UIDs)" + - Apply + - Check: + - `StudyDate == 20200101` + - `StudyInstanceUID` has not changed + + +Edit study tags, can not be used to edit a patient who already has other studies +- on the new Study (the one whose `PatientID==2`), `Modify Study tags` and change: + - `PatientID = TEST_1` + - don't change other Patient tags + - try all 3 modification mode options + - Apply + - Check: you should get an error telling you to use `Change Patient` + +Edit study tags, can be used to create a new patient +- on the new Study (the one whose `PatientID==2`), `Modify Study tags` and change: + - `PatientID = TEST_3` + - `PatientName = Test3` + - don't change other Patient tags + - select "Create a modified copy of the original study" + - Apply + - Check: you should now have 3 studies and 3 patients + +Attach study to a non existing patient +- on any Study, `Change patient` and set: + - `PatientID = NO_SUCH_PATIENT` + - Apply + - Check: you should get en error telling you to use `Modify Study tags` instead + +Attach study to an existing patient, keep DICOM UIDs +- on Study from `PatientID = TEST_3`, `Change patient` and set: + - `PatientID = TEST_1` + - select "Modify the original study. (keeping the original DICOM UIDs)" + - Apply + - Check: + - Patient `TEST_1` shall now have 2 studies + - the Patient tags shall be identical in both studies + +Edit patient birth date in multiple studies +- on a study from `PatientID = TEST_1`, 'Modify Patient tags' and set: + - `PatientBirthDate = 19100101` + - select "Modify the original study. (keeping the original DICOM UIDs)" + - Apply + - Check: + - `PatientBirthDate` has changed in all studies, + +Edit patient ID in multiple studies +- on a study from `PatientID = TEST_1`, 'Modify Patient tags' and set: + - `PatientID = TEST_4` + - select "Modify the original study. (keeping the original DICOM UIDs)" + - Apply + - Check: + - `PatientID` has changed in all studies, + +Edit patient ID in multiple studies +- on a study from `PatientID = TEST_4`, 'Modify Patient tags' and set: + - `PatientID = TEST_1` + - select "Create a modified copy of the original study" + - Apply + - Check: + - there are duplicate studies for Patient `TEST_1` and `TEST_4` + +Anonymize study +- on any study, 'Anonymize study': + - make sure `PatientID` and `PatientName` have been pre-filled + - set a `StudyDescription` + - Apply + - Check: + - the anonymized study has been created, the original study is still present + + +Series modification +------------------ + +Preparation: +- delete all studies from `TEST*` patient +- upload the test study again +- on Study `Test CT`, `Modify Study tags` and change: + - `AccessionNumber = 2345` + - `StudyDate = 20150101` + - `StudyID = 2` + - `StudyDescription = Test CT 2` + - select "Create a modified copy of the original study" + - Apply +- you should now have 2 studies for the `TEST_1` patient + +Edit series tags to move it to an existing study: +- on the series from `Test CT 2`, `Change study` : + - `StudyInstanceUID = 1.2.4` + - click `Modify` -> you should get an error + - `StudyInstanceUID = 1.2.3` + - click `Modify` + - Check: + - you now have 2 series in the `Test CT` study + - `StudyDate` tags of instances from both series should be set to `20100630` + +Move series to a new study: +- on one of the series, `Create new study` and change: + - `PatientID = TEST_1` + - `StudyDescription = TEST CT 3` + - click `Modify` -> you should have a warning telling you that this patient exists with different tags -> `Modify` + - Check: + - you should now have 2 studies for patient `TEST*` + +Move series to a new study (2): +- on the series from `TEST CT 3`, `Create new study` and change: + - `PatientID = TEST_2` + - `PatientName = Test2` + - `PatientBirthDate = 20000101` + - `StudyDescription = TEST CT 4` + - click `Modify` + - Check: + - you should now have 2 studies for patient `TEST*` + - the `Test CT 3 ` series shall have been deleted + +Edit series tags: +- on the series from `TEST CT 4`, `Modify series tags` and change: + - `Modality = CR` + - click `Modify` + - Check: + - the modality shall have been updated in the series (and in the study list) + +Anonymize series: +- on the series from `TEST CT 4`, `Anonymize series` and change: + - make sure `PatientID` and `PatientName` have been pre-filled + - click `Anonymize` + - Check: + - the anonymized series (and so study) has been created, the original series is still present diff --git a/tests/stimuli/TEST_1/10.dcm b/tests/stimuli/TEST_1/10.dcm new file mode 100644 index 0000000..368747f Binary files /dev/null and b/tests/stimuli/TEST_1/10.dcm differ diff --git a/tests/stimuli/TEST_1/12.dcm b/tests/stimuli/TEST_1/12.dcm new file mode 100644 index 0000000..9b52d65 Binary files /dev/null and b/tests/stimuli/TEST_1/12.dcm differ