Mercurial > hg > orthanc
annotate OrthancFramework/Sources/HttpServer/WebDavStorage.cpp @ 4233:ca2a55a62c81
implementation of DELETE in class WebDavStorage
| author | Sebastien Jodogne <s.jodogne@gmail.com> |
|---|---|
| date | Wed, 07 Oct 2020 13:19:53 +0200 |
| parents | 688435755466 |
| children | c8754c4c1862 |
| rev | line source |
|---|---|
| 4230 | 1 /** |
| 2 * Orthanc - A Lightweight, RESTful DICOM Store | |
| 3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics | |
| 4 * Department, University Hospital of Liege, Belgium | |
| 5 * Copyright (C) 2017-2020 Osimis S.A., Belgium | |
| 6 * | |
| 7 * This program is free software: you can redistribute it and/or | |
| 8 * modify it under the terms of the GNU Lesser General Public License | |
| 9 * as published by the Free Software Foundation, either version 3 of | |
| 10 * the License, or (at your option) any later version. | |
| 11 * | |
| 12 * This program is distributed in the hope that it will be useful, but | |
| 13 * WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 15 * Lesser General Public License for more details. | |
| 16 * | |
| 17 * You should have received a copy of the GNU Lesser General Public | |
| 18 * License along with this program. If not, see | |
| 19 * <http://www.gnu.org/licenses/>. | |
| 20 **/ | |
| 21 | |
| 22 | |
| 23 #include "../PrecompiledHeaders.h" | |
| 24 #include "WebDavStorage.h" | |
| 25 | |
| 26 #include "../OrthancException.h" | |
| 27 #include "../SystemToolbox.h" | |
| 28 #include "../TemporaryFile.h" | |
| 29 #include "../Toolbox.h" | |
| 30 | |
| 31 namespace Orthanc | |
| 32 { | |
| 33 class WebDavStorage::StorageFile : public boost::noncopyable | |
| 34 { | |
| 35 private: | |
| 36 std::unique_ptr<TemporaryFile> file_; | |
| 37 std::string content_; | |
| 38 MimeType mime_; | |
| 39 boost::posix_time::ptime time_; | |
| 40 | |
| 41 void Touch() | |
| 42 { | |
| 43 time_ = boost::posix_time::second_clock::universal_time(); | |
| 44 } | |
| 45 | |
| 46 public: | |
| 47 StorageFile() : | |
| 48 mime_(MimeType_Binary) | |
| 49 { | |
| 50 Touch(); | |
| 51 } | |
| 52 | |
| 53 void SetContent(const std::string& content, | |
| 54 MimeType mime, | |
| 55 bool isMemory) | |
| 56 { | |
| 57 if (isMemory) | |
| 58 { | |
| 59 content_ = content; | |
| 60 file_.reset(); | |
| 61 } | |
| 62 else | |
| 63 { | |
| 64 content_.clear(); | |
| 65 file_.reset(new TemporaryFile); | |
| 66 file_->Write(content); | |
| 67 } | |
| 68 | |
| 69 mime_ = mime; | |
| 70 Touch(); | |
| 71 } | |
| 72 | |
| 73 MimeType GetMimeType() const | |
| 74 { | |
| 75 return mime_; | |
| 76 } | |
| 77 | |
| 78 void GetContent(std::string& target) const | |
| 79 { | |
| 80 if (file_.get() == NULL) | |
| 81 { | |
| 82 target = content_; | |
| 83 } | |
| 84 else | |
| 85 { | |
| 86 file_->Read(target); | |
| 87 } | |
| 88 } | |
| 89 | |
| 90 const boost::posix_time::ptime& GetTime() const | |
| 91 { | |
| 92 return time_; | |
| 93 } | |
| 94 | |
| 95 uint64_t GetContentLength() const | |
| 96 { | |
| 97 if (file_.get() == NULL) | |
| 98 { | |
| 99 return content_.size(); | |
| 100 } | |
| 101 else | |
| 102 { | |
| 103 return file_->GetFileSize(); | |
| 104 } | |
| 105 } | |
| 106 }; | |
| 107 | |
| 108 | |
| 109 class WebDavStorage::StorageFolder : public boost::noncopyable | |
| 110 { | |
| 111 private: | |
| 112 typedef std::map<std::string, StorageFile*> Files; | |
| 113 typedef std::map<std::string, StorageFolder*> Subfolders; | |
| 114 | |
|
4233
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
115 Files files_; |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
116 Subfolders subfolders_; |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
117 boost::posix_time::ptime time_; |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
118 |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
119 void Touch() |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
120 { |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
121 time_ = boost::posix_time::second_clock::universal_time(); |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
122 } |
| 4230 | 123 |
| 124 void CheckName(const std::string& name) | |
| 125 { | |
| 126 if (name.empty() || | |
| 127 name.find('/') != std::string::npos || | |
| 128 name.find('\\') != std::string::npos || | |
| 129 name.find('\0') != std::string::npos) | |
| 130 { | |
| 131 throw OrthancException(ErrorCode_ParameterOutOfRange, | |
| 132 "Bad resource name for WebDAV: " + name); | |
| 133 } | |
| 134 } | |
| 135 | |
| 136 bool IsExisting(const std::string& name) const | |
| 137 { | |
| 138 return (files_.find(name) != files_.end() || | |
| 139 subfolders_.find(name) != subfolders_.end()); | |
| 140 } | |
| 141 | |
| 142 public: | |
|
4233
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
143 StorageFolder() |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
144 { |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
145 Touch(); |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
146 } |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
147 |
| 4230 | 148 ~StorageFolder() |
| 149 { | |
| 150 for (Files::iterator it = files_.begin(); it != files_.end(); ++it) | |
| 151 { | |
| 152 assert(it->second != NULL); | |
| 153 delete it->second; | |
| 154 } | |
| 155 | |
| 156 for (Subfolders::iterator it = subfolders_.begin(); it != subfolders_.end(); ++it) | |
| 157 { | |
| 158 assert(it->second != NULL); | |
| 159 delete it->second; | |
| 160 } | |
| 161 } | |
| 162 | |
|
4233
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
163 const boost::posix_time::ptime& GetModificationTime() const |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
164 { |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
165 return time_; |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
166 } |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
167 |
| 4230 | 168 const StorageFile* LookupFile(const std::string& name) const |
| 169 { | |
| 170 Files::const_iterator found = files_.find(name); | |
| 171 if (found == files_.end()) | |
| 172 { | |
| 173 return NULL; | |
| 174 } | |
| 175 else | |
| 176 { | |
| 177 assert(found->second != NULL); | |
| 178 return found->second; | |
| 179 } | |
| 180 } | |
| 181 | |
| 182 bool CreateSubfolder(const std::string& name) | |
| 183 { | |
| 184 CheckName(name); | |
| 185 | |
| 186 if (IsExisting(name)) | |
| 187 { | |
| 188 LOG(ERROR) << "WebDAV folder already existing: " << name; | |
| 189 return false; | |
| 190 } | |
| 191 else | |
| 192 { | |
| 193 subfolders_[name] = new StorageFolder; | |
|
4233
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
194 Touch(); |
| 4230 | 195 return true; |
| 196 } | |
| 197 } | |
| 198 | |
| 199 bool StoreFile(const std::string& name, | |
| 200 const std::string& content, | |
| 201 MimeType mime, | |
| 202 bool isMemory) | |
| 203 { | |
| 204 CheckName(name); | |
| 205 | |
| 206 if (subfolders_.find(name) != subfolders_.end()) | |
| 207 { | |
| 208 LOG(ERROR) << "WebDAV folder already existing: " << name; | |
| 209 return false; | |
| 210 } | |
| 211 | |
| 212 Files::iterator found = files_.find(name); | |
| 213 if (found == files_.end()) | |
| 214 { | |
| 215 std::unique_ptr<StorageFile> f(new StorageFile); | |
| 216 f->SetContent(content, mime, isMemory); | |
| 217 files_[name] = f.release(); | |
| 218 } | |
| 219 else | |
| 220 { | |
| 221 assert(found->second != NULL); | |
| 222 found->second->SetContent(content, mime, isMemory); | |
| 223 } | |
| 224 | |
|
4233
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
225 Touch(); |
| 4230 | 226 return true; |
| 227 } | |
| 228 | |
| 229 StorageFolder* LookupFolder(const std::vector<std::string>& path) | |
| 230 { | |
| 231 if (path.empty()) | |
| 232 { | |
| 233 return this; | |
| 234 } | |
| 235 else | |
| 236 { | |
| 237 Subfolders::const_iterator found = subfolders_.find(path[0]); | |
| 238 if (found == subfolders_.end()) | |
| 239 { | |
| 240 return NULL; | |
| 241 } | |
| 242 else | |
| 243 { | |
| 244 assert(found->second != NULL); | |
| 245 | |
| 246 std::vector<std::string> p(path.begin() + 1, path.end()); | |
| 247 return found->second->LookupFolder(p); | |
| 248 } | |
| 249 } | |
| 250 } | |
| 251 | |
| 252 void ListCollection(Collection& collection) const | |
| 253 { | |
| 254 for (Files::const_iterator it = files_.begin(); it != files_.end(); ++it) | |
| 255 { | |
| 256 assert(it->second != NULL); | |
| 257 | |
| 258 std::unique_ptr<File> f(new File(it->first)); | |
| 259 f->SetContentLength(it->second->GetContentLength()); | |
| 260 f->SetCreationTime(it->second->GetTime()); | |
| 261 collection.AddResource(f.release()); | |
| 262 } | |
| 263 | |
| 264 for (Subfolders::const_iterator it = subfolders_.begin(); it != subfolders_.end(); ++it) | |
| 265 { | |
|
4233
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
266 std::unique_ptr<Folder> f(new Folder(it->first)); |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
267 f->SetModificationTime(it->second->GetModificationTime()); |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
268 collection.AddResource(f.release()); |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
269 } |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
270 } |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
271 |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
272 bool DeleteItem(const std::vector<std::string>& path) |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
273 { |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
274 if (path.size() == 0) |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
275 { |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
276 throw OrthancException(ErrorCode_InternalError); |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
277 } |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
278 else if (path.size() == 1) |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
279 { |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
280 { |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
281 Files::iterator f = files_.find(path[0]); |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
282 if (f != files_.end()) |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
283 { |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
284 assert(f->second != NULL); |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
285 delete f->second; |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
286 files_.erase(f); |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
287 Touch(); |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
288 return true; |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
289 } |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
290 } |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
291 |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
292 { |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
293 Subfolders::iterator f = subfolders_.find(path[0]); |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
294 if (f != subfolders_.end()) |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
295 { |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
296 assert(f->second != NULL); |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
297 delete f->second; |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
298 subfolders_.erase(f); |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
299 Touch(); |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
300 return true; |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
301 } |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
302 } |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
303 |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
304 return false; |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
305 } |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
306 else |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
307 { |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
308 Subfolders::iterator f = subfolders_.find(path[0]); |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
309 if (f != subfolders_.end()) |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
310 { |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
311 assert(f->second != NULL); |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
312 |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
313 std::vector<std::string> p(path.begin() + 1, path.end()); |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
314 if (f->second->DeleteItem(p)) |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
315 { |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
316 Touch(); |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
317 return true; |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
318 } |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
319 else |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
320 { |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
321 return false; |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
322 } |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
323 } |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
324 else |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
325 { |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
326 return false; |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
327 } |
| 4230 | 328 } |
| 329 } | |
| 330 }; | |
| 331 | |
| 332 | |
| 333 WebDavStorage::StorageFolder* WebDavStorage::LookupParentFolder(const std::vector<std::string>& path) | |
| 334 { | |
| 335 if (path.empty()) | |
| 336 { | |
| 337 throw OrthancException(ErrorCode_ParameterOutOfRange); | |
| 338 } | |
| 339 | |
| 340 std::vector<std::string> p(path.begin(), path.end() - 1); | |
| 341 return root_->LookupFolder(p); | |
| 342 } | |
| 343 | |
| 344 | |
| 345 WebDavStorage::WebDavStorage(bool isMemory) : | |
| 346 root_(new StorageFolder), | |
| 347 isMemory_(isMemory) | |
| 348 { | |
| 349 } | |
| 350 | |
| 351 | |
| 352 bool WebDavStorage::IsExistingFolder(const std::vector<std::string>& path) | |
| 353 { | |
| 354 boost::recursive_mutex::scoped_lock lock(mutex_); | |
| 355 | |
| 356 return (root_->LookupFolder(path) != NULL); | |
| 357 } | |
| 358 | |
| 359 | |
| 360 bool WebDavStorage::ListCollection(Collection& collection, | |
| 361 const std::vector<std::string>& path) | |
| 362 { | |
| 363 boost::recursive_mutex::scoped_lock lock(mutex_); | |
| 364 | |
| 365 const StorageFolder* folder = root_->LookupFolder(path); | |
| 366 if (folder == NULL) | |
| 367 { | |
| 368 return false; | |
| 369 } | |
| 370 else | |
| 371 { | |
| 372 folder->ListCollection(collection); | |
| 373 return true; | |
| 374 } | |
| 375 } | |
| 376 | |
| 377 | |
| 378 bool WebDavStorage::GetFileContent(MimeType& mime, | |
| 379 std::string& content, | |
| 380 boost::posix_time::ptime& modificationTime, | |
| 381 const std::vector<std::string>& path) | |
| 382 { | |
| 383 boost::recursive_mutex::scoped_lock lock(mutex_); | |
| 384 | |
| 385 const StorageFolder* folder = LookupParentFolder(path); | |
| 386 if (folder == NULL) | |
| 387 { | |
| 388 return false; | |
| 389 } | |
| 390 else | |
| 391 { | |
| 392 const StorageFile* file = folder->LookupFile(path.back()); | |
| 393 if (file == NULL) | |
| 394 { | |
| 395 return false; | |
| 396 } | |
| 397 else | |
| 398 { | |
| 399 mime = file->GetMimeType(); | |
| 400 file->GetContent(content); | |
| 401 modificationTime = file->GetTime(); | |
| 402 return true; | |
| 403 } | |
| 404 } | |
| 405 } | |
| 406 | |
| 407 | |
| 408 bool WebDavStorage::StoreFile(const std::string& content, | |
| 409 const std::vector<std::string>& path) | |
| 410 { | |
| 411 boost::recursive_mutex::scoped_lock lock(mutex_); | |
| 412 | |
| 413 StorageFolder* folder = LookupParentFolder(path); | |
| 414 if (folder == NULL) | |
| 415 { | |
| 416 LOG(WARNING) << "Inexisting folder in WebDAV: " << Toolbox::FlattenUri(path); | |
| 417 return false; | |
| 418 } | |
| 419 else | |
| 420 { | |
| 421 LOG(INFO) << "Storing " << content.size() | |
| 422 << " bytes in WebDAV bucket: " << Toolbox::FlattenUri(path);; | |
| 423 | |
| 424 MimeType mime = SystemToolbox::AutodetectMimeType(path.back()); | |
| 425 return folder->StoreFile(path.back(), content, mime, isMemory_); | |
| 426 } | |
| 427 } | |
| 428 | |
| 429 | |
| 430 bool WebDavStorage::CreateFolder(const std::vector<std::string>& path) | |
| 431 { | |
| 432 boost::recursive_mutex::scoped_lock lock(mutex_); | |
| 433 | |
| 434 StorageFolder* folder = LookupParentFolder(path); | |
| 435 if (folder == NULL) | |
| 436 { | |
| 437 LOG(WARNING) << "Inexisting folder in WebDAV: " << Toolbox::FlattenUri(path); | |
| 438 return false; | |
| 439 } | |
| 440 else | |
| 441 { | |
| 442 LOG(INFO) << "Creating folder in WebDAV bucket: " << Toolbox::FlattenUri(path); | |
| 443 return folder->CreateSubfolder(path.back()); | |
| 444 } | |
| 445 } | |
|
4232
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4230
diff
changeset
|
446 |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4230
diff
changeset
|
447 |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4230
diff
changeset
|
448 bool WebDavStorage::DeleteItem(const std::vector<std::string>& path) |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4230
diff
changeset
|
449 { |
|
4233
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
450 if (path.empty()) |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
451 { |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
452 return false; // Cannot delete the root |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
453 } |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
454 else |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
455 { |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
456 boost::recursive_mutex::scoped_lock lock(mutex_); |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
457 |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
458 LOG(INFO) << "Deleting from WebDAV bucket: " << Toolbox::FlattenUri(path); |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
459 return root_->DeleteItem(path); |
|
ca2a55a62c81
implementation of DELETE in class WebDavStorage
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4232
diff
changeset
|
460 } |
|
4232
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4230
diff
changeset
|
461 } |
| 4230 | 462 } |