Mercurial > hg > orthanc
annotate OrthancServer/OrthancRestApi.cpp @ 173:68dae290d5fa Orthanc-0.2.3-Paulus
fix
| author | Sebastien Jodogne <s.jodogne@gmail.com> |
|---|---|
| date | Mon, 19 Nov 2012 13:50:19 +0100 |
| parents | da7e915202c7 |
| children |
| rev | line source |
|---|---|
| 0 | 1 /** |
| 62 | 2 * Orthanc - A Lightweight, RESTful DICOM Store |
| 0 | 3 * Copyright (C) 2012 Medical Physics Department, CHU of Liege, |
| 4 * Belgium | |
| 5 * | |
| 6 * This program is free software: you can redistribute it and/or | |
| 7 * modify it under the terms of the GNU General Public License as | |
| 8 * published by the Free Software Foundation, either version 3 of the | |
| 9 * License, or (at your option) any later version. | |
| 136 | 10 * |
| 11 * In addition, as a special exception, the copyright holders of this | |
| 12 * program give permission to link the code of its release with the | |
| 13 * OpenSSL project's "OpenSSL" library (or with modified versions of it | |
| 14 * that use the same license as the "OpenSSL" library), and distribute | |
| 15 * the linked executables. You must obey the GNU General Public License | |
| 16 * in all respects for all of the code used other than "OpenSSL". If you | |
| 17 * modify file(s) with this exception, you may extend this exception to | |
| 18 * your version of the file(s), but you are not obligated to do so. If | |
| 19 * you do not wish to do so, delete this exception statement from your | |
| 20 * version. If you delete this exception statement from all source files | |
| 21 * in the program, then also delete it here. | |
| 0 | 22 * |
| 23 * This program is distributed in the hope that it will be useful, but | |
| 24 * WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 26 * General Public License for more details. | |
| 27 * | |
| 28 * You should have received a copy of the GNU General Public License | |
| 29 * along with this program. If not, see <http://www.gnu.org/licenses/>. | |
| 30 **/ | |
| 31 | |
| 32 | |
| 62 | 33 #include "OrthancRestApi.h" |
| 0 | 34 |
| 62 | 35 #include "OrthancInitialization.h" |
| 0 | 36 #include "FromDcmtkBridge.h" |
| 37 #include "../Core/Uuid.h" | |
|
171
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
38 #include "../Core/DicomFormat/DicomArray.h" |
| 0 | 39 |
| 40 #include <dcmtk/dcmdata/dcistrmb.h> | |
| 41 #include <dcmtk/dcmdata/dcfilefo.h> | |
| 42 #include <boost/lexical_cast.hpp> | |
|
171
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
43 #include <glog/logging.h> |
| 0 | 44 |
| 62 | 45 namespace Orthanc |
| 0 | 46 { |
| 47 static void SendJson(HttpOutput& output, | |
| 48 const Json::Value& value) | |
| 49 { | |
| 50 Json::StyledWriter writer; | |
| 51 std::string s = writer.write(value); | |
| 52 output.AnswerBufferWithContentType(s, "application/json"); | |
| 53 } | |
| 54 | |
|
35
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
55 |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
56 static void SimplifyTagsRecursion(Json::Value& target, |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
57 const Json::Value& source) |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
58 { |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
59 assert(source.isObject()); |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
60 |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
61 target = Json::objectValue; |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
62 Json::Value::Members members = source.getMemberNames(); |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
63 |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
64 for (size_t i = 0; i < members.size(); i++) |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
65 { |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
66 const Json::Value& v = source[members[i]]; |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
67 const std::string& name = v["Name"].asString(); |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
68 const std::string& type = v["Type"].asString(); |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
69 |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
70 if (type == "String") |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
71 { |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
72 target[name] = v["Value"].asString(); |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
73 } |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
74 else if (type == "TooLong" || |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
75 type == "Null") |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
76 { |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
77 target[name] = Json::nullValue; |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
78 } |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
79 else if (type == "Sequence") |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
80 { |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
81 const Json::Value& array = v["Value"]; |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
82 assert(array.isArray()); |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
83 |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
84 Json::Value children = Json::arrayValue; |
| 126 | 85 for (Json::Value::ArrayIndex i = 0; i < array.size(); i++) |
|
35
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
86 { |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
87 Json::Value c; |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
88 SimplifyTagsRecursion(c, array[i]); |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
89 children.append(c); |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
90 } |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
91 |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
92 target[name] = children; |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
93 } |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
94 else |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
95 { |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
96 assert(0); |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
97 } |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
98 } |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
99 } |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
100 |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
101 |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
102 static void SimplifyTags(Json::Value& target, |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
103 const FileStorage& storage, |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
104 const std::string& fileUuid) |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
105 { |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
106 std::string s; |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
107 storage.ReadFile(s, fileUuid); |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
108 |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
109 Json::Value source; |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
110 Json::Reader reader; |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
111 if (!reader.parse(s, source)) |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
112 { |
| 62 | 113 throw OrthancException("Corrupted JSON file"); |
|
35
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
114 } |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
115 |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
116 SimplifyTagsRecursion(target, source); |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
117 } |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
118 |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
119 |
|
171
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
120 static bool GetTagContent(HttpOutput& output, |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
121 const FileStorage& storage, |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
122 const std::string& fileUuid, |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
123 const UriComponents& uri) |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
124 { |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
125 // TODO: Implement a true caching mechanism! |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
126 static boost::mutex mutex_; |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
127 static std::string lastFileUuid_; |
| 173 | 128 static std::auto_ptr<DcmFileFormat> dicomFile_; |
|
171
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
129 |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
130 boost::mutex::scoped_lock lock(mutex_); |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
131 |
| 173 | 132 if (dicomFile_.get() == NULL || |
| 133 fileUuid != lastFileUuid_) | |
|
171
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
134 { |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
135 LOG(INFO) << "Parsing file " << fileUuid; |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
136 std::string content; |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
137 storage.ReadFile(content, fileUuid); |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
138 |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
139 DcmInputBufferStream is; |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
140 if (content.size() > 0) |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
141 { |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
142 is.setBuffer(&content[0], content.size()); |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
143 } |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
144 is.setEos(); |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
145 |
| 173 | 146 dicomFile_.reset(new DcmFileFormat); |
| 147 | |
| 148 if (!dicomFile_->read(is).good()) | |
|
171
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
149 { |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
150 return false; |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
151 } |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
152 |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
153 lastFileUuid_ = fileUuid; |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
154 } |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
155 else |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
156 { |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
157 LOG(INFO) << "Already parsed file " << fileUuid; |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
158 } |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
159 |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
160 if (uri.size() == 3) |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
161 { |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
162 DicomMap dicomSummary; |
| 173 | 163 FromDcmtkBridge::Convert(dicomSummary, *dicomFile_->getDataset()); |
|
171
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
164 |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
165 DicomArray a(dicomSummary); |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
166 |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
167 Json::Value target = Json::arrayValue; |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
168 for (size_t i = 0; i < a.GetSize(); i++) |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
169 { |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
170 char b[16]; |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
171 sprintf(b, "%04x-%04x", a.GetElement(i).GetTagGroup(), |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
172 a.GetElement(i).GetTagElement()); |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
173 target.append(b); |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
174 } |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
175 |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
176 SendJson(output, target); |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
177 return true; |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
178 } |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
179 |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
180 if (uri.size() == 4) |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
181 { |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
182 if (uri[3].size() != 9 || |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
183 uri[3][4] != '-') |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
184 { |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
185 return false; |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
186 } |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
187 |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
188 unsigned int group, element; |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
189 if (sscanf(uri[3].c_str(), "%04x-%04x", &group, &element) != 2) |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
190 { |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
191 return false; |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
192 } |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
193 |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
194 DcmTagKey tag(group, element); |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
195 DcmElement* item = NULL; |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
196 |
| 173 | 197 if (dicomFile_->getDataset()->findAndGetElement(tag, item).good() && |
|
171
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
198 item != NULL) |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
199 { |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
200 std::string buffer; |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
201 buffer.resize(65536); |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
202 Uint32 length = item->getLength(); |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
203 Uint32 offset = 0; |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
204 |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
205 while (offset < length) |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
206 { |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
207 Uint32 nbytes; |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
208 if (length - offset < buffer.size()) |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
209 { |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
210 nbytes = length - offset; |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
211 } |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
212 else |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
213 { |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
214 nbytes = buffer.size(); |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
215 } |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
216 |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
217 output.SendOkHeader("application/octet-stream"); |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
218 if (item->getPartialValue(&buffer[0], offset, nbytes).good()) |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
219 { |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
220 output.Send(&buffer[0], nbytes); |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
221 offset += nbytes; |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
222 } |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
223 else |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
224 { |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
225 return true; |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
226 } |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
227 } |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
228 |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
229 return true; |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
230 } |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
231 else |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
232 { |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
233 return false; |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
234 } |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
235 } |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
236 |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
237 return false; |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
238 } |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
239 |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
240 |
| 62 | 241 bool OrthancRestApi::Store(Json::Value& result, |
| 50 | 242 const std::string& postData) |
| 0 | 243 { |
| 244 // Prepare an input stream for the memory buffer | |
| 245 DcmInputBufferStream is; | |
| 246 if (postData.size() > 0) | |
| 247 { | |
| 248 is.setBuffer(&postData[0], postData.size()); | |
| 249 } | |
| 250 is.setEos(); | |
| 251 | |
|
34
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
8
diff
changeset
|
252 //printf("[%d]\n", postData.size()); |
| 0 | 253 |
| 254 DcmFileFormat dicomFile; | |
| 255 if (dicomFile.read(is).good()) | |
| 256 { | |
| 257 DicomMap dicomSummary; | |
| 258 FromDcmtkBridge::Convert(dicomSummary, *dicomFile.getDataset()); | |
| 259 | |
| 260 Json::Value dicomJson; | |
| 261 FromDcmtkBridge::ToJson(dicomJson, *dicomFile.getDataset()); | |
| 262 | |
| 263 std::string instanceUuid; | |
| 264 StoreStatus status = StoreStatus_Failure; | |
| 265 if (postData.size() > 0) | |
| 266 { | |
| 267 status = index_.Store | |
| 268 (instanceUuid, storage_, reinterpret_cast<const char*>(&postData[0]), | |
| 269 postData.size(), dicomSummary, dicomJson, ""); | |
| 270 } | |
| 271 | |
| 272 switch (status) | |
| 273 { | |
| 274 case StoreStatus_Success: | |
| 275 result["ID"] = instanceUuid; | |
| 276 result["Path"] = "/instances/" + instanceUuid; | |
| 277 result["Status"] = "Success"; | |
| 278 return true; | |
| 279 | |
| 280 case StoreStatus_AlreadyStored: | |
| 281 result["ID"] = instanceUuid; | |
| 282 result["Path"] = "/instances/" + instanceUuid; | |
| 283 result["Status"] = "AlreadyStored"; | |
| 284 return true; | |
| 285 | |
| 286 default: | |
| 287 return false; | |
| 288 } | |
| 289 } | |
| 290 | |
| 291 return false; | |
| 292 } | |
| 293 | |
| 62 | 294 void OrthancRestApi::ConnectToModality(DicomUserConnection& c, |
| 50 | 295 const std::string& name) |
| 0 | 296 { |
| 297 std::string aet, address; | |
| 298 int port; | |
| 299 GetDicomModality(name, aet, address, port); | |
| 62 | 300 c.SetLocalApplicationEntityTitle(GetGlobalStringParameter("DicomAet", "ORTHANC")); |
| 0 | 301 c.SetDistantApplicationEntityTitle(aet); |
| 302 c.SetDistantHost(address); | |
| 303 c.SetDistantPort(port); | |
| 304 c.Open(); | |
| 305 } | |
| 306 | |
| 62 | 307 bool OrthancRestApi::MergeQueryAndTemplate(DicomMap& result, |
| 50 | 308 const std::string& postData) |
| 0 | 309 { |
| 310 Json::Value query; | |
| 311 Json::Reader reader; | |
| 312 | |
| 313 if (!reader.parse(postData, query) || | |
| 8 | 314 query.type() != Json::objectValue) |
| 0 | 315 { |
| 316 return false; | |
| 317 } | |
| 318 | |
| 319 Json::Value::Members members = query.getMemberNames(); | |
| 320 for (size_t i = 0; i < members.size(); i++) | |
| 321 { | |
| 322 DicomTag t = FromDcmtkBridge::FindTag(members[i]); | |
| 323 result.SetValue(t, query[members[i]].asString()); | |
| 324 } | |
| 325 | |
| 326 return true; | |
| 327 } | |
| 328 | |
| 62 | 329 bool OrthancRestApi::DicomFindPatient(Json::Value& result, |
| 50 | 330 DicomUserConnection& c, |
| 331 const std::string& postData) | |
| 0 | 332 { |
| 333 DicomMap m; | |
| 334 DicomMap::SetupFindPatientTemplate(m); | |
| 335 if (!MergeQueryAndTemplate(m, postData)) | |
| 336 { | |
| 337 return false; | |
| 338 } | |
| 339 | |
| 340 DicomFindAnswers answers; | |
| 341 c.FindPatient(answers, m); | |
| 342 answers.ToJson(result); | |
| 343 return true; | |
| 344 } | |
| 345 | |
| 62 | 346 bool OrthancRestApi::DicomFindStudy(Json::Value& result, |
| 50 | 347 DicomUserConnection& c, |
| 348 const std::string& postData) | |
| 0 | 349 { |
| 350 DicomMap m; | |
| 351 DicomMap::SetupFindStudyTemplate(m); | |
| 352 if (!MergeQueryAndTemplate(m, postData)) | |
| 353 { | |
| 354 return false; | |
| 355 } | |
| 356 | |
| 80 | 357 if (m.GetValue(DICOM_TAG_ACCESSION_NUMBER).AsString().size() <= 2 && |
| 358 m.GetValue(DICOM_TAG_PATIENT_ID).AsString().size() <= 2) | |
| 0 | 359 { |
| 360 return false; | |
| 361 } | |
| 362 | |
| 363 DicomFindAnswers answers; | |
| 364 c.FindStudy(answers, m); | |
| 365 answers.ToJson(result); | |
| 366 return true; | |
| 367 } | |
| 368 | |
| 62 | 369 bool OrthancRestApi::DicomFindSeries(Json::Value& result, |
| 50 | 370 DicomUserConnection& c, |
| 371 const std::string& postData) | |
| 0 | 372 { |
| 373 DicomMap m; | |
| 374 DicomMap::SetupFindSeriesTemplate(m); | |
| 375 if (!MergeQueryAndTemplate(m, postData)) | |
| 376 { | |
| 377 return false; | |
| 378 } | |
| 379 | |
| 80 | 380 if ((m.GetValue(DICOM_TAG_ACCESSION_NUMBER).AsString().size() <= 2 && |
| 381 m.GetValue(DICOM_TAG_PATIENT_ID).AsString().size() <= 2) || | |
| 382 m.GetValue(DICOM_TAG_STUDY_INSTANCE_UID).AsString().size() <= 2) | |
| 0 | 383 { |
| 384 return false; | |
| 385 } | |
| 386 | |
| 387 DicomFindAnswers answers; | |
| 388 c.FindSeries(answers, m); | |
| 389 answers.ToJson(result); | |
| 390 return true; | |
| 391 } | |
| 392 | |
| 62 | 393 bool OrthancRestApi::DicomFind(Json::Value& result, |
| 50 | 394 DicomUserConnection& c, |
| 395 const std::string& postData) | |
| 0 | 396 { |
| 397 DicomMap m; | |
| 398 DicomMap::SetupFindPatientTemplate(m); | |
| 399 if (!MergeQueryAndTemplate(m, postData)) | |
| 400 { | |
| 401 return false; | |
| 402 } | |
| 403 | |
| 404 DicomFindAnswers patients; | |
| 405 c.FindPatient(patients, m); | |
| 406 | |
| 407 // Loop over the found patients | |
| 408 result = Json::arrayValue; | |
| 409 for (size_t i = 0; i < patients.GetSize(); i++) | |
| 410 { | |
| 411 Json::Value patient(Json::objectValue); | |
| 412 FromDcmtkBridge::ToJson(patient, patients.GetAnswer(i)); | |
| 413 | |
| 414 DicomMap::SetupFindStudyTemplate(m); | |
| 415 if (!MergeQueryAndTemplate(m, postData)) | |
| 416 { | |
| 417 return false; | |
| 418 } | |
| 80 | 419 m.CopyTagIfExists(patients.GetAnswer(i), DICOM_TAG_PATIENT_ID); |
| 0 | 420 |
| 421 DicomFindAnswers studies; | |
| 422 c.FindStudy(studies, m); | |
| 423 | |
| 424 patient["Studies"] = Json::arrayValue; | |
| 425 | |
| 426 // Loop over the found studies | |
| 427 for (size_t j = 0; j < studies.GetSize(); j++) | |
| 428 { | |
| 429 Json::Value study(Json::objectValue); | |
| 430 FromDcmtkBridge::ToJson(study, studies.GetAnswer(j)); | |
| 431 | |
| 432 DicomMap::SetupFindSeriesTemplate(m); | |
| 433 if (!MergeQueryAndTemplate(m, postData)) | |
| 434 { | |
| 435 return false; | |
| 436 } | |
| 80 | 437 m.CopyTagIfExists(studies.GetAnswer(j), DICOM_TAG_PATIENT_ID); |
| 438 m.CopyTagIfExists(studies.GetAnswer(j), DICOM_TAG_STUDY_INSTANCE_UID); | |
| 0 | 439 |
| 440 DicomFindAnswers series; | |
| 441 c.FindSeries(series, m); | |
| 442 | |
| 443 // Loop over the found series | |
| 444 study["Series"] = Json::arrayValue; | |
| 445 for (size_t k = 0; k < series.GetSize(); k++) | |
| 446 { | |
| 447 Json::Value series2(Json::objectValue); | |
| 448 FromDcmtkBridge::ToJson(series2, series.GetAnswer(k)); | |
| 449 study["Series"].append(series2); | |
| 450 } | |
| 451 | |
| 452 patient["Studies"].append(study); | |
| 453 } | |
| 454 | |
| 455 result.append(patient); | |
| 456 } | |
| 457 | |
| 458 return true; | |
| 459 } | |
| 460 | |
| 461 | |
| 462 | |
| 62 | 463 bool OrthancRestApi::DicomStore(Json::Value& result, |
| 50 | 464 DicomUserConnection& c, |
| 465 const std::string& postData) | |
| 0 | 466 { |
| 467 Json::Value found(Json::objectValue); | |
| 468 | |
| 469 if (!Toolbox::IsUuid(postData)) | |
| 470 { | |
| 471 // This is not a UUID, assume this is a DICOM instance | |
| 472 c.Store(postData); | |
| 473 } | |
| 474 else if (index_.GetSeries(found, postData)) | |
| 475 { | |
| 476 // The UUID corresponds to a series | |
| 126 | 477 for (Json::Value::ArrayIndex i = 0; i < found["Instances"].size(); i++) |
| 0 | 478 { |
| 479 std::string uuid = found["Instances"][i].asString(); | |
| 480 Json::Value instance(Json::objectValue); | |
| 481 if (index_.GetInstance(instance, uuid)) | |
| 482 { | |
| 483 std::string content; | |
| 484 storage_.ReadFile(content, instance["FileUuid"].asString()); | |
| 485 c.Store(content); | |
| 486 } | |
| 487 else | |
| 488 { | |
| 489 return false; | |
| 490 } | |
| 491 } | |
| 492 } | |
| 493 else if (index_.GetInstance(found, postData)) | |
| 494 { | |
| 495 // The UUID corresponds to an instance | |
| 496 std::string content; | |
| 497 storage_.ReadFile(content, found["FileUuid"].asString()); | |
| 498 c.Store(content); | |
| 499 } | |
| 500 else | |
| 501 { | |
| 502 return false; | |
| 503 } | |
| 504 | |
| 505 return true; | |
| 506 } | |
| 507 | |
| 508 | |
| 62 | 509 OrthancRestApi::OrthancRestApi(ServerIndex& index, |
| 50 | 510 const std::string& path) : |
| 0 | 511 index_(index), |
| 512 storage_(path) | |
| 513 { | |
| 514 GetListOfDicomModalities(modalities_); | |
| 515 } | |
| 516 | |
| 517 | |
| 62 | 518 void OrthancRestApi::Handle( |
| 0 | 519 HttpOutput& output, |
| 520 const std::string& method, | |
| 521 const UriComponents& uri, | |
| 522 const Arguments& headers, | |
| 523 const Arguments& arguments, | |
| 524 const std::string& postData) | |
| 525 { | |
| 526 if (uri.size() == 0) | |
| 527 { | |
| 528 if (method == "GET") | |
| 529 { | |
|
85
ebce15865cce
relative redirection
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
80
diff
changeset
|
530 output.Redirect("app/explorer.html"); |
| 0 | 531 } |
| 532 else | |
| 533 { | |
| 534 output.SendMethodNotAllowedError("GET"); | |
| 535 } | |
| 536 | |
| 537 return; | |
| 538 } | |
| 539 | |
| 540 bool existingResource = false; | |
| 541 Json::Value result(Json::objectValue); | |
| 542 | |
| 543 | |
| 151 | 544 // Version information ------------------------------------------------------ |
| 545 | |
| 546 if (uri.size() == 1 && uri[0] == "system") | |
| 547 { | |
| 548 if (method == "GET") | |
| 549 { | |
| 550 result = Json::Value(Json::objectValue); | |
| 551 result["Version"] = ORTHANC_VERSION; | |
| 552 result["Name"] = GetGlobalStringParameter("Name", ""); | |
| 553 existingResource = true; | |
| 554 } | |
| 555 else | |
| 556 { | |
| 557 output.SendMethodNotAllowedError("GET,POST"); | |
| 558 return; | |
| 559 } | |
| 560 } | |
| 561 | |
| 562 | |
| 0 | 563 // List all the instances --------------------------------------------------- |
| 564 | |
| 565 if (uri.size() == 1 && uri[0] == "instances") | |
| 566 { | |
| 567 if (method == "GET") | |
| 568 { | |
| 569 result = Json::Value(Json::arrayValue); | |
| 570 index_.GetAllUuids(result, "Instances"); | |
| 571 existingResource = true; | |
| 572 } | |
| 573 else if (method == "POST") | |
| 574 { | |
| 575 // Add a new instance to the storage | |
| 576 if (Store(result, postData)) | |
| 577 { | |
| 578 SendJson(output, result); | |
| 579 return; | |
| 580 } | |
| 581 else | |
| 582 { | |
| 62 | 583 output.SendHeader(Orthanc_HttpStatus_415_UnsupportedMediaType); |
| 0 | 584 return; |
| 585 } | |
| 586 } | |
| 587 else | |
| 588 { | |
| 589 output.SendMethodNotAllowedError("GET,POST"); | |
| 590 return; | |
| 591 } | |
| 592 } | |
| 593 | |
| 594 | |
| 595 // List all the patients, studies or series --------------------------------- | |
| 596 | |
| 597 if (uri.size() == 1 && | |
| 598 (uri[0] == "series" || | |
| 599 uri[0] == "studies" || | |
| 600 uri[0] == "patients")) | |
| 601 { | |
| 602 if (method == "GET") | |
| 603 { | |
| 604 result = Json::Value(Json::arrayValue); | |
| 605 | |
| 606 if (uri[0] == "instances") | |
| 607 index_.GetAllUuids(result, "Instances"); | |
| 608 else if (uri[0] == "series") | |
| 609 index_.GetAllUuids(result, "Series"); | |
| 610 else if (uri[0] == "studies") | |
| 611 index_.GetAllUuids(result, "Studies"); | |
| 612 else if (uri[0] == "patients") | |
| 613 index_.GetAllUuids(result, "Patients"); | |
| 614 | |
| 615 existingResource = true; | |
| 616 } | |
| 617 else | |
| 618 { | |
| 619 output.SendMethodNotAllowedError("GET"); | |
| 620 return; | |
| 621 } | |
| 622 } | |
| 623 | |
| 624 | |
| 625 // Information about a single object ---------------------------------------- | |
| 626 | |
| 627 else if (uri.size() == 2 && | |
| 628 (uri[0] == "instances" || | |
| 629 uri[0] == "series" || | |
| 630 uri[0] == "studies" || | |
| 631 uri[0] == "patients")) | |
| 632 { | |
| 633 if (method == "GET") | |
| 634 { | |
| 635 if (uri[0] == "patients") | |
| 636 { | |
| 637 existingResource = index_.GetPatient(result, uri[1]); | |
| 638 } | |
| 639 else if (uri[0] == "studies") | |
| 640 { | |
| 641 existingResource = index_.GetStudy(result, uri[1]); | |
| 642 } | |
| 643 else if (uri[0] == "series") | |
| 644 { | |
| 645 existingResource = index_.GetSeries(result, uri[1]); | |
| 646 } | |
| 647 else if (uri[0] == "instances") | |
| 648 { | |
| 649 existingResource = index_.GetInstance(result, uri[1]); | |
| 650 } | |
| 651 } | |
| 652 else if (method == "DELETE") | |
| 653 { | |
| 654 if (uri[0] == "patients") | |
| 655 { | |
| 656 existingResource = index_.DeletePatient(result, uri[1]); | |
| 657 } | |
| 658 else if (uri[0] == "studies") | |
| 659 { | |
| 660 existingResource = index_.DeleteStudy(result, uri[1]); | |
| 661 } | |
| 662 else if (uri[0] == "series") | |
| 663 { | |
| 664 existingResource = index_.DeleteSeries(result, uri[1]); | |
| 665 } | |
| 666 else if (uri[0] == "instances") | |
| 667 { | |
| 668 existingResource = index_.DeleteInstance(result, uri[1]); | |
| 669 } | |
| 670 | |
| 671 if (existingResource) | |
| 672 { | |
| 673 result["Status"] = "Success"; | |
| 674 } | |
| 675 } | |
| 676 else | |
| 677 { | |
| 678 output.SendMethodNotAllowedError("GET,DELETE"); | |
| 679 return; | |
| 680 } | |
| 681 } | |
| 682 | |
| 683 | |
| 684 // Get the DICOM or the JSON file of one instance --------------------------- | |
| 685 | |
| 686 else if (uri.size() == 3 && | |
| 687 uri[0] == "instances" && | |
| 688 (uri[2] == "file" || | |
|
34
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
8
diff
changeset
|
689 uri[2] == "tags" || |
|
35
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
690 uri[2] == "simplified-tags")) |
| 0 | 691 { |
|
155
93e1b0e3b83a
filenames when downloading json/dicom
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
151
diff
changeset
|
692 std::string fileUuid, contentType, filename; |
| 0 | 693 if (uri[2] == "file") |
| 694 { | |
| 695 existingResource = index_.GetDicomFile(fileUuid, uri[1]); | |
| 696 contentType = "application/dicom"; | |
|
155
93e1b0e3b83a
filenames when downloading json/dicom
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
151
diff
changeset
|
697 filename = fileUuid + ".dcm"; |
| 0 | 698 } |
|
34
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
8
diff
changeset
|
699 else if (uri[2] == "tags" || |
|
35
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
700 uri[2] == "simplified-tags") |
| 0 | 701 { |
| 702 existingResource = index_.GetJsonFile(fileUuid, uri[1]); | |
| 703 contentType = "application/json"; | |
|
155
93e1b0e3b83a
filenames when downloading json/dicom
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
151
diff
changeset
|
704 filename = fileUuid + ".json"; |
| 0 | 705 } |
| 706 | |
| 707 if (existingResource) | |
| 708 { | |
|
35
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
709 if (uri[2] == "simplified-tags") |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
710 { |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
711 Json::Value v; |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
712 SimplifyTags(v, storage_, fileUuid); |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
713 SendJson(output, v); |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
714 return; |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
715 } |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
716 else |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
717 { |
|
155
93e1b0e3b83a
filenames when downloading json/dicom
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
151
diff
changeset
|
718 output.AnswerFile(storage_, fileUuid, contentType, filename.c_str()); |
|
35
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
719 return; |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
34
diff
changeset
|
720 } |
| 0 | 721 } |
| 722 } | |
| 723 | |
| 724 | |
| 725 else if (uri.size() == 3 && | |
| 726 uri[0] == "instances" && | |
|
53
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
727 uri[2] == "frames") |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
728 { |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
729 Json::Value instance(Json::objectValue); |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
730 existingResource = index_.GetInstance(instance, uri[1]); |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
731 |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
732 if (existingResource) |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
733 { |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
734 result = Json::arrayValue; |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
735 |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
736 unsigned int numberOfFrames = 1; |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
737 try |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
738 { |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
739 Json::Value tmp = instance["MainDicomTags"]["NumberOfFrames"]; |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
740 numberOfFrames = boost::lexical_cast<unsigned int>(tmp.asString()); |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
741 } |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
742 catch (boost::bad_lexical_cast) |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
743 { |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
744 } |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
745 |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
746 for (unsigned int i = 0; i < numberOfFrames; i++) |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
747 { |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
748 result.append(i); |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
749 } |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
750 } |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
751 } |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
752 |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
753 |
|
171
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
754 else if (uri.size() >= 3 && |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
755 uri[0] == "instances" && |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
756 uri[2] == "content") |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
757 { |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
758 Json::Value instance(Json::objectValue); |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
759 std::string fileUuid; |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
760 existingResource = index_.GetDicomFile(fileUuid, uri[1]); |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
761 |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
762 if (existingResource) |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
763 { |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
764 if (GetTagContent(output, storage_, fileUuid, uri)) |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
765 { |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
766 return; |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
767 } |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
768 else |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
769 { |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
770 existingResource = false; |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
771 } |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
772 } |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
773 } |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
774 |
|
da7e915202c7
quick and dirty access to raw tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
155
diff
changeset
|
775 |
|
53
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
776 else if (uri[0] == "instances" && |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
777 ((uri.size() == 3 && |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
778 (uri[2] == "preview" || |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
779 uri[2] == "image-uint8" || |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
780 uri[2] == "image-uint16")) || |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
781 (uri.size() == 5 && |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
782 uri[2] == "frames" && |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
783 (uri[4] == "preview" || |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
784 uri[4] == "image-uint8" || |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
785 uri[4] == "image-uint16")))) |
| 0 | 786 { |
| 787 std::string uuid; | |
| 788 existingResource = index_.GetDicomFile(uuid, uri[1]); | |
| 789 | |
|
53
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
790 std::string action = uri[2]; |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
791 |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
792 unsigned int frame = 0; |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
793 if (existingResource && |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
794 uri.size() == 5) |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
795 { |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
796 // Access to multi-frame image |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
797 action = uri[4]; |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
798 try |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
799 { |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
800 frame = boost::lexical_cast<unsigned int>(uri[3]); |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
801 } |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
802 catch (boost::bad_lexical_cast) |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
803 { |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
804 existingResource = false; |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
805 } |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
806 } |
|
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
807 |
| 0 | 808 if (existingResource) |
| 809 { | |
| 810 std::string dicomContent, png; | |
| 811 storage_.ReadFile(dicomContent, uuid); | |
| 812 try | |
| 813 { | |
|
53
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
814 if (action == "preview") |
|
42
ea48f38afe5f
access to raw images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
41
diff
changeset
|
815 { |
|
53
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
816 FromDcmtkBridge::ExtractPngImage(png, dicomContent, frame, ImageExtractionMode_Preview); |
|
42
ea48f38afe5f
access to raw images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
41
diff
changeset
|
817 } |
|
53
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
818 else if (action == "image-uint8") |
|
42
ea48f38afe5f
access to raw images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
41
diff
changeset
|
819 { |
|
53
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
820 FromDcmtkBridge::ExtractPngImage(png, dicomContent, frame, ImageExtractionMode_UInt8); |
|
42
ea48f38afe5f
access to raw images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
41
diff
changeset
|
821 } |
|
53
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
822 else if (action == "image-uint16") |
|
42
ea48f38afe5f
access to raw images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
41
diff
changeset
|
823 { |
|
53
293038baf8f1
access to multi-frame images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
50
diff
changeset
|
824 FromDcmtkBridge::ExtractPngImage(png, dicomContent, frame, ImageExtractionMode_UInt16); |
|
42
ea48f38afe5f
access to raw images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
41
diff
changeset
|
825 } |
|
ea48f38afe5f
access to raw images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
41
diff
changeset
|
826 else |
|
ea48f38afe5f
access to raw images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
41
diff
changeset
|
827 { |
| 62 | 828 throw OrthancException(ErrorCode_InternalError); |
|
42
ea48f38afe5f
access to raw images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
41
diff
changeset
|
829 } |
|
ea48f38afe5f
access to raw images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
41
diff
changeset
|
830 |
| 0 | 831 output.AnswerBufferWithContentType(png, "image/png"); |
| 832 return; | |
| 833 } | |
| 62 | 834 catch (OrthancException&) |
| 0 | 835 { |
|
85
ebce15865cce
relative redirection
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
80
diff
changeset
|
836 std::string root = ""; |
|
ebce15865cce
relative redirection
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
80
diff
changeset
|
837 for (size_t i = 1; i < uri.size(); i++) |
|
ebce15865cce
relative redirection
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
80
diff
changeset
|
838 { |
|
ebce15865cce
relative redirection
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
80
diff
changeset
|
839 root += "../"; |
|
ebce15865cce
relative redirection
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
80
diff
changeset
|
840 } |
|
ebce15865cce
relative redirection
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
80
diff
changeset
|
841 |
| 129 | 842 output.Redirect(root + "app/images/unsupported.png"); |
| 0 | 843 return; |
| 844 } | |
| 845 } | |
| 846 } | |
| 847 | |
| 848 | |
| 849 | |
| 850 // Changes API -------------------------------------------------------------- | |
| 851 | |
| 852 if (uri.size() == 1 && uri[0] == "changes") | |
| 853 { | |
| 854 if (method == "GET") | |
| 855 { | |
| 856 const static unsigned int MAX_RESULTS = 100; | |
| 857 | |
| 858 std::string filter = GetArgument(arguments, "filter", ""); | |
| 859 int64_t since; | |
| 860 unsigned int limit; | |
| 861 try | |
| 862 { | |
| 863 since = boost::lexical_cast<int64_t>(GetArgument(arguments, "since", "0")); | |
| 864 limit = boost::lexical_cast<unsigned int>(GetArgument(arguments, "limit", "0")); | |
| 865 } | |
| 866 catch (boost::bad_lexical_cast) | |
| 867 { | |
| 62 | 868 output.SendHeader(Orthanc_HttpStatus_400_BadRequest); |
| 0 | 869 return; |
| 870 } | |
| 871 | |
| 872 if (limit == 0 || limit > MAX_RESULTS) | |
| 873 { | |
| 874 limit = MAX_RESULTS; | |
| 875 } | |
| 876 | |
| 877 if (!index_.GetChanges(result, since, filter, limit)) | |
| 878 { | |
| 62 | 879 output.SendHeader(Orthanc_HttpStatus_400_BadRequest); |
| 0 | 880 return; |
| 881 } | |
| 882 | |
| 883 existingResource = true; | |
| 884 } | |
| 885 else | |
| 886 { | |
| 887 output.SendMethodNotAllowedError("GET"); | |
| 888 return; | |
| 889 } | |
| 890 } | |
| 891 | |
| 892 | |
| 893 // DICOM bridge ------------------------------------------------------------- | |
| 894 | |
| 895 if (uri.size() == 1 && | |
| 896 uri[0] == "modalities") | |
| 897 { | |
| 898 if (method == "GET") | |
| 899 { | |
| 900 result = Json::Value(Json::arrayValue); | |
| 901 existingResource = true; | |
| 902 | |
| 903 for (Modalities::const_iterator it = modalities_.begin(); | |
| 904 it != modalities_.end(); it++) | |
| 905 { | |
| 906 result.append(*it); | |
| 907 } | |
| 908 } | |
| 909 else | |
| 910 { | |
| 911 output.SendMethodNotAllowedError("GET"); | |
| 912 return; | |
| 913 } | |
| 914 } | |
| 915 | |
| 916 if ((uri.size() == 2 || | |
| 917 uri.size() == 3) && | |
| 918 uri[0] == "modalities") | |
| 919 { | |
| 920 if (modalities_.find(uri[1]) == modalities_.end()) | |
| 921 { | |
| 922 // Unknown modality | |
| 923 } | |
| 924 else if (uri.size() == 2) | |
| 925 { | |
| 926 if (method != "GET") | |
| 927 { | |
| 928 output.SendMethodNotAllowedError("POST"); | |
| 929 return; | |
| 930 } | |
| 931 else | |
| 932 { | |
| 933 existingResource = true; | |
| 934 result = Json::arrayValue; | |
| 935 result.append("find-patient"); | |
| 936 result.append("find-study"); | |
| 937 result.append("find-series"); | |
| 938 result.append("find"); | |
| 939 result.append("store"); | |
| 940 } | |
| 941 } | |
| 942 else if (uri.size() == 3) | |
| 943 { | |
| 944 if (uri[2] != "find-patient" && | |
| 945 uri[2] != "find-study" && | |
| 946 uri[2] != "find-series" && | |
| 947 uri[2] != "find" && | |
| 948 uri[2] != "store") | |
| 949 { | |
| 950 // Unknown request | |
| 951 } | |
| 952 else if (method != "POST") | |
| 953 { | |
| 954 output.SendMethodNotAllowedError("POST"); | |
| 955 return; | |
| 956 } | |
| 957 else | |
| 958 { | |
| 959 DicomUserConnection connection; | |
| 960 ConnectToModality(connection, uri[1]); | |
| 961 existingResource = true; | |
| 962 | |
| 963 if ((uri[2] == "find-patient" && !DicomFindPatient(result, connection, postData)) || | |
| 964 (uri[2] == "find-study" && !DicomFindStudy(result, connection, postData)) || | |
| 965 (uri[2] == "find-series" && !DicomFindSeries(result, connection, postData)) || | |
| 966 (uri[2] == "find" && !DicomFind(result, connection, postData)) || | |
| 967 (uri[2] == "store" && !DicomStore(result, connection, postData))) | |
| 968 { | |
| 62 | 969 output.SendHeader(Orthanc_HttpStatus_400_BadRequest); |
| 0 | 970 return; |
| 971 } | |
| 972 } | |
| 973 } | |
| 974 } | |
| 975 | |
| 976 | |
| 977 if (existingResource) | |
| 978 { | |
| 979 SendJson(output, result); | |
| 980 } | |
| 981 else | |
| 982 { | |
| 62 | 983 output.SendHeader(Orthanc_HttpStatus_404_NotFound); |
| 0 | 984 } |
| 985 } | |
| 986 } |