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 } |