1
14
15 package com.liferay.portlet.documentlibrary.webdav;
16
17 import com.liferay.documentlibrary.DuplicateFileException;
18 import com.liferay.portal.DuplicateLockException;
19 import com.liferay.portal.InvalidLockException;
20 import com.liferay.portal.NoSuchLockException;
21 import com.liferay.portal.kernel.exception.PortalException;
22 import com.liferay.portal.kernel.log.Log;
23 import com.liferay.portal.kernel.log.LogFactoryUtil;
24 import com.liferay.portal.kernel.util.FileUtil;
25 import com.liferay.portal.kernel.util.StringPool;
26 import com.liferay.portal.kernel.util.StringUtil;
27 import com.liferay.portal.kernel.util.Validator;
28 import com.liferay.portal.kernel.webdav.BaseResourceImpl;
29 import com.liferay.portal.kernel.webdav.BaseWebDAVStorageImpl;
30 import com.liferay.portal.kernel.webdav.Resource;
31 import com.liferay.portal.kernel.webdav.Status;
32 import com.liferay.portal.kernel.webdav.WebDAVException;
33 import com.liferay.portal.kernel.webdav.WebDAVRequest;
34 import com.liferay.portal.kernel.webdav.WebDAVUtil;
35 import com.liferay.portal.kernel.workflow.WorkflowConstants;
36 import com.liferay.portal.model.Lock;
37 import com.liferay.portal.security.auth.PrincipalException;
38 import com.liferay.portal.service.ServiceContext;
39 import com.liferay.portal.util.PropsValues;
40 import com.liferay.portal.webdav.LockException;
41 import com.liferay.portlet.asset.service.AssetTagLocalServiceUtil;
42 import com.liferay.portlet.documentlibrary.DuplicateFolderNameException;
43 import com.liferay.portlet.documentlibrary.NoSuchFileEntryException;
44 import com.liferay.portlet.documentlibrary.NoSuchFolderException;
45 import com.liferay.portlet.documentlibrary.model.DLFileEntry;
46 import com.liferay.portlet.documentlibrary.model.DLFileVersion;
47 import com.liferay.portlet.documentlibrary.model.DLFolder;
48 import com.liferay.portlet.documentlibrary.model.DLFolderConstants;
49 import com.liferay.portlet.documentlibrary.service.DLFileEntryLocalServiceUtil;
50 import com.liferay.portlet.documentlibrary.service.DLFileEntryServiceUtil;
51 import com.liferay.portlet.documentlibrary.service.DLFileVersionLocalServiceUtil;
52 import com.liferay.portlet.documentlibrary.service.DLFolderServiceUtil;
53
54 import java.io.File;
55 import java.io.InputStream;
56
57 import java.util.ArrayList;
58 import java.util.List;
59
60 import javax.servlet.http.HttpServletRequest;
61 import javax.servlet.http.HttpServletResponse;
62
63
69 public class DLWebDAVStorageImpl extends BaseWebDAVStorageImpl {
70
71 public int copyCollectionResource(
72 WebDAVRequest webDavRequest, Resource resource, String destination,
73 boolean overwrite, long depth)
74 throws WebDAVException {
75
76 try {
77 String[] destinationArray = WebDAVUtil.getPathArray(
78 destination, true);
79
80 long companyId = webDavRequest.getCompanyId();
81
82 long parentFolderId = DLFolderConstants.DEFAULT_PARENT_FOLDER_ID;
83
84 try {
85 parentFolderId = getParentFolderId(companyId, destinationArray);
86 }
87 catch (NoSuchFolderException nsfe) {
88 return HttpServletResponse.SC_CONFLICT;
89 }
90
91 DLFolder folder = (DLFolder)resource.getModel();
92
93 long groupId = WebDAVUtil.getGroupId(companyId, destination);
94 String name = WebDAVUtil.getResourceName(destinationArray);
95 String description = folder.getDescription();
96
97 ServiceContext serviceContext = new ServiceContext();
98
99 serviceContext.setAddCommunityPermissions(
100 isAddCommunityPermissions(groupId));
101 serviceContext.setAddGuestPermissions(true);
102
103 int status = HttpServletResponse.SC_CREATED;
104
105 if (overwrite) {
106 if (deleteResource(
107 groupId, parentFolderId, name,
108 webDavRequest.getLockUuid())) {
109
110 status = HttpServletResponse.SC_NO_CONTENT;
111 }
112 }
113
114 if (depth == 0) {
115 DLFolderServiceUtil.addFolder(
116 groupId, parentFolderId, name, description, serviceContext);
117 }
118 else {
119 DLFolderServiceUtil.copyFolder(
120 groupId, folder.getFolderId(), parentFolderId, name,
121 description, serviceContext);
122 }
123
124 return status;
125 }
126 catch (DuplicateFolderNameException dfne) {
127 return HttpServletResponse.SC_PRECONDITION_FAILED;
128 }
129 catch (PrincipalException pe) {
130 return HttpServletResponse.SC_FORBIDDEN;
131 }
132 catch (Exception e) {
133 throw new WebDAVException(e);
134 }
135 }
136
137 public int copySimpleResource(
138 WebDAVRequest webDavRequest, Resource resource, String destination,
139 boolean overwrite)
140 throws WebDAVException {
141
142 File file = null;
143
144 try {
145 String[] destinationArray = WebDAVUtil.getPathArray(
146 destination, true);
147
148 long companyId = webDavRequest.getCompanyId();
149
150 long parentFolderId = DLFolderConstants.DEFAULT_PARENT_FOLDER_ID;
151
152 try {
153 parentFolderId = getParentFolderId(companyId, destinationArray);
154 }
155 catch (NoSuchFolderException nsfe) {
156 return HttpServletResponse.SC_CONFLICT;
157 }
158
159 DLFileEntry fileEntry = (DLFileEntry)resource.getModel();
160
161 long groupId = WebDAVUtil.getGroupId(companyId, destination);
162 long userId = webDavRequest.getUserId();
163 String name = WebDAVUtil.getResourceName(destinationArray);
164 String title = WebDAVUtil.getResourceName(destinationArray);
165 String description = fileEntry.getDescription();
166 String versionDescription = StringPool.BLANK;
167 String extraSettings = fileEntry.getExtraSettings();
168
169 file = FileUtil.createTempFile(
170 FileUtil.getExtension(fileEntry.getName()));
171
172 InputStream is = DLFileEntryLocalServiceUtil.getFileAsStream(
173 fileEntry.getCompanyId(), userId, fileEntry.getGroupId(),
174 fileEntry.getFolderId(), fileEntry.getName());
175
176 FileUtil.write(file, is);
177
178 ServiceContext serviceContext = new ServiceContext();
179
180 serviceContext.setAddCommunityPermissions(
181 isAddCommunityPermissions(groupId));
182 serviceContext.setAddGuestPermissions(true);
183
184 int status = HttpServletResponse.SC_CREATED;
185
186 if (overwrite) {
187 if (deleteResource(
188 groupId, parentFolderId, title,
189 webDavRequest.getLockUuid())) {
190
191 status = HttpServletResponse.SC_NO_CONTENT;
192 }
193 }
194
195 DLFileEntryServiceUtil.addFileEntry(
196 groupId, parentFolderId, name, title, description,
197 versionDescription, extraSettings, file, serviceContext);
198
199 return status;
200 }
201 catch (DuplicateFileException dfe) {
202 return HttpServletResponse.SC_PRECONDITION_FAILED;
203 }
204 catch (DuplicateFolderNameException dfne) {
205 return HttpServletResponse.SC_PRECONDITION_FAILED;
206 }
207 catch (LockException le) {
208 return WebDAVUtil.SC_LOCKED;
209 }
210 catch (PrincipalException pe) {
211 return HttpServletResponse.SC_FORBIDDEN;
212 }
213 catch (Exception e) {
214 throw new WebDAVException(e);
215 }
216 finally {
217 if (file != null) {
218 file.delete();
219 }
220 }
221 }
222
223 public int deleteResource(WebDAVRequest webDavRequest)
224 throws WebDAVException {
225
226 try {
227 Resource resource = getResource(webDavRequest);
228
229 if (resource == null) {
230 return HttpServletResponse.SC_NOT_FOUND;
231 }
232
233 Object model = resource.getModel();
234
235 if (model instanceof DLFolder) {
236 DLFolder folder = (DLFolder)model;
237
238 DLFolderServiceUtil.deleteFolder(folder.getFolderId());
239 }
240 else {
241 DLFileEntry fileEntry = (DLFileEntry)model;
242
243 if (isLocked(fileEntry, webDavRequest.getLockUuid())) {
244 return WebDAVUtil.SC_LOCKED;
245 }
246
247 DLFileEntryServiceUtil.deleteFileEntry(
248 fileEntry.getGroupId(), fileEntry.getFolderId(),
249 fileEntry.getName());
250 }
251
252 return HttpServletResponse.SC_NO_CONTENT;
253 }
254 catch (PrincipalException pe) {
255 return HttpServletResponse.SC_FORBIDDEN;
256 }
257 catch (Exception e) {
258 throw new WebDAVException(e);
259 }
260 }
261
262 public Resource getResource(WebDAVRequest webDavRequest)
263 throws WebDAVException {
264
265 try {
266 String[] pathArray = webDavRequest.getPathArray();
267
268 long companyId = webDavRequest.getCompanyId();
269 long parentFolderId = getParentFolderId(companyId, pathArray);
270 String name = WebDAVUtil.getResourceName(pathArray);
271
272 if (Validator.isNull(name)) {
273 String path = getRootPath() + webDavRequest.getPath();
274
275 return new BaseResourceImpl(path, StringPool.BLANK, getToken());
276 }
277
278 try {
279 DLFolder folder = DLFolderServiceUtil.getFolder(
280 webDavRequest.getGroupId(), parentFolderId, name);
281
282 if ((folder.getParentFolderId() != parentFolderId) ||
283 (webDavRequest.getGroupId() != folder.getGroupId())) {
284
285 throw new NoSuchFolderException();
286 }
287
288 return toResource(webDavRequest, folder, false);
289 }
290 catch (NoSuchFolderException nsfe) {
291 try {
292 String titleWithExtension = name;
293
294 DLFileEntry fileEntry =
295 DLFileEntryServiceUtil.getFileEntryByTitle(
296 webDavRequest.getGroupId(), parentFolderId,
297 titleWithExtension);
298
299 return toResource(webDavRequest, fileEntry, false);
300 }
301 catch (NoSuchFileEntryException nsfee) {
302 return null;
303 }
304 }
305 }
306 catch (Exception e) {
307 throw new WebDAVException(e);
308 }
309 }
310
311 public List<Resource> getResources(WebDAVRequest webDavRequest)
312 throws WebDAVException {
313
314 try {
315 long folderId = getFolderId(
316 webDavRequest.getCompanyId(), webDavRequest.getPathArray());
317
318 List<Resource> folders = getFolders(webDavRequest, folderId);
319 List<Resource> fileEntries = getFileEntries(
320 webDavRequest, folderId);
321
322 List<Resource> resources = new ArrayList<Resource>(
323 folders.size() + fileEntries.size());
324
325 resources.addAll(folders);
326 resources.addAll(fileEntries);
327
328 return resources;
329 }
330 catch (Exception e) {
331 throw new WebDAVException(e);
332 }
333 }
334
335 public boolean isSupportsClassTwo() {
336 return true;
337 }
338
339 public Status lockResource(
340 WebDAVRequest webDavRequest, String owner, long timeout)
341 throws WebDAVException {
342
343 Resource resource = getResource(webDavRequest);
344
345 Lock lock = null;
346 int status = HttpServletResponse.SC_OK;
347
348 try {
349 if (resource == null) {
350 status = HttpServletResponse.SC_CREATED;
351
352 String[] pathArray = webDavRequest.getPathArray();
353
354 long companyId = webDavRequest.getCompanyId();
355 long groupId = webDavRequest.getGroupId();
356 long parentFolderId = getParentFolderId(companyId, pathArray);
357 String name = WebDAVUtil.getResourceName(pathArray);
358
359 String title = name;
360 String description = StringPool.BLANK;
361 String versionDescription = StringPool.BLANK;
362 String extraSettings = StringPool.BLANK;
363
364 File file = FileUtil.createTempFile(
365 FileUtil.getExtension(name));
366
367 file.createNewFile();
368
369 ServiceContext serviceContext = new ServiceContext();
370
371 serviceContext.setAddCommunityPermissions(
372 isAddCommunityPermissions(groupId));
373 serviceContext.setAddGuestPermissions(true);
374
375 DLFileEntry fileEntry = DLFileEntryServiceUtil.addFileEntry(
376 groupId, parentFolderId, name, title, description,
377 versionDescription, extraSettings, file, serviceContext);
378
379 resource = toResource(webDavRequest, fileEntry, false);
380 }
381
382 if (resource instanceof DLFileEntryResourceImpl) {
383 DLFileEntry fileEntry = (DLFileEntry)resource.getModel();
384
385 lock = DLFileEntryServiceUtil.lockFileEntry(
386 fileEntry.getGroupId(), fileEntry.getFolderId(),
387 fileEntry.getName(), owner, timeout);
388 }
389 else {
390 boolean inheritable = false;
391
392 long depth = WebDAVUtil.getDepth(
393 webDavRequest.getHttpServletRequest());
394
395 if (depth != 0) {
396 inheritable = true;
397 }
398
399 DLFolder folder = (DLFolder)resource.getModel();
400
401 lock = DLFolderServiceUtil.lockFolder(
402 folder.getFolderId(), owner, inheritable, timeout);
403 }
404 }
405 catch (Exception e) {
406
407
409 if (!(e instanceof DuplicateLockException)) {
410 throw new WebDAVException(e);
411 }
412
413 status = WebDAVUtil.SC_LOCKED;
414 }
415
416 return new Status(lock, status);
417 }
418
419 public Status makeCollection(WebDAVRequest webDavRequest)
420 throws WebDAVException {
421
422 try {
423 HttpServletRequest request = webDavRequest.getHttpServletRequest();
424
425 if (request.getContentLength() > 0) {
426 return new Status(
427 HttpServletResponse.SC_UNSUPPORTED_MEDIA_TYPE);
428 }
429
430 String[] pathArray = webDavRequest.getPathArray();
431
432 long companyId = webDavRequest.getCompanyId();
433 long groupId = webDavRequest.getGroupId();
434 long parentFolderId = getParentFolderId(companyId, pathArray);
435 String name = WebDAVUtil.getResourceName(pathArray);
436 String description = StringPool.BLANK;
437
438 ServiceContext serviceContext = new ServiceContext();
439
440 serviceContext.setAddCommunityPermissions(
441 isAddCommunityPermissions(groupId));
442 serviceContext.setAddGuestPermissions(true);
443
444 DLFolderServiceUtil.addFolder(
445 groupId, parentFolderId, name, description, serviceContext);
446
447 String location = StringUtil.merge(pathArray, StringPool.SLASH);
448
449 return new Status(location, HttpServletResponse.SC_CREATED);
450 }
451 catch (DuplicateFolderNameException dfne) {
452 return new Status(HttpServletResponse.SC_METHOD_NOT_ALLOWED);
453 }
454 catch (DuplicateFileException dfe) {
455 return new Status(HttpServletResponse.SC_METHOD_NOT_ALLOWED);
456 }
457 catch (NoSuchFolderException nsfe) {
458 return new Status(HttpServletResponse.SC_CONFLICT);
459 }
460 catch (PrincipalException pe) {
461 return new Status(HttpServletResponse.SC_FORBIDDEN);
462 }
463 catch (Exception e) {
464 throw new WebDAVException(e);
465 }
466 }
467
468 public int moveCollectionResource(
469 WebDAVRequest webDavRequest, Resource resource, String destination,
470 boolean overwrite)
471 throws WebDAVException {
472
473 try {
474 String[] destinationArray = WebDAVUtil.getPathArray(
475 destination, true);
476
477 DLFolder folder = (DLFolder)resource.getModel();
478
479 long companyId = webDavRequest.getCompanyId();
480 long groupId = WebDAVUtil.getGroupId(companyId, destinationArray);
481 long folderId = folder.getFolderId();
482 long parentFolderId = getParentFolderId(
483 companyId, destinationArray);
484 String name = WebDAVUtil.getResourceName(destinationArray);
485 String description = folder.getDescription();
486
487 ServiceContext serviceContext = new ServiceContext();
488
489 int status = HttpServletResponse.SC_CREATED;
490
491 if (overwrite) {
492 if (deleteResource(
493 groupId, parentFolderId, name,
494 webDavRequest.getLockUuid())) {
495
496 status = HttpServletResponse.SC_NO_CONTENT;
497 }
498 }
499
500 DLFolderServiceUtil.updateFolder(
501 folderId, parentFolderId, name, description, serviceContext);
502
503 return status;
504 }
505 catch (PrincipalException pe) {
506 return HttpServletResponse.SC_FORBIDDEN;
507 }
508 catch (DuplicateFolderNameException dfne) {
509 return HttpServletResponse.SC_PRECONDITION_FAILED;
510 }
511 catch (Exception e) {
512 throw new WebDAVException(e);
513 }
514 }
515
516 public int moveSimpleResource(
517 WebDAVRequest webDavRequest, Resource resource, String destination,
518 boolean overwrite)
519 throws WebDAVException {
520
521 try {
522 String[] destinationArray = WebDAVUtil.getPathArray(
523 destination, true);
524
525 DLFileEntry fileEntry = (DLFileEntry)resource.getModel();
526
527 if (isLocked(fileEntry, webDavRequest.getLockUuid())) {
528 return WebDAVUtil.SC_LOCKED;
529 }
530
531 long companyId = webDavRequest.getCompanyId();
532 long groupId = WebDAVUtil.getGroupId(companyId, destinationArray);
533 long userId = webDavRequest.getUserId();
534 long parentFolderId = getParentFolderId(
535 companyId, destinationArray);
536 String name = fileEntry.getName();
537 String sourceFileName = null;
538 String title = WebDAVUtil.getResourceName(destinationArray);
539 String description = fileEntry.getDescription();
540 String versionDescription = StringPool.BLANK;
541 String extraSettings = fileEntry.getExtraSettings();
542 byte[] bytes = null;
543
544 String[] assetTagNames = AssetTagLocalServiceUtil.getTagNames(
545 DLFileEntry.class.getName(), fileEntry.getFileEntryId());
546
547 ServiceContext serviceContext = new ServiceContext();
548
549 serviceContext.setAssetTagNames(assetTagNames);
550
551 int status = HttpServletResponse.SC_CREATED;
552
553 if (overwrite) {
554 if (deleteResource(
555 groupId, parentFolderId, title,
556 webDavRequest.getLockUuid())) {
557
558 status = HttpServletResponse.SC_NO_CONTENT;
559 }
560 }
561
562
564 if (webDavRequest.isMac()) {
565 try {
566 DLFileEntry destFileEntry =
567 DLFileEntryServiceUtil.getFileEntryByTitle(
568 groupId, parentFolderId, title);
569
570 InputStream is =
571 DLFileEntryLocalServiceUtil.getFileAsStream(
572 fileEntry.getCompanyId(), userId,
573 fileEntry.getGroupId(), fileEntry.getFolderId(),
574 fileEntry.getName());
575
576 bytes = FileUtil.getBytes(is);
577
578 DLFileEntryServiceUtil.updateFileEntry(
579 groupId, parentFolderId, parentFolderId,
580 destFileEntry.getName(), destFileEntry.getTitle(),
581 destFileEntry.getTitle(),
582 destFileEntry.getDescription(), versionDescription,
583 false, destFileEntry.getExtraSettings(), bytes,
584 serviceContext);
585
586 DLFileEntryServiceUtil.deleteFileEntry(
587 fileEntry.getGroupId(), fileEntry.getFolderId(),
588 fileEntry.getName());
589
590 return status;
591 }
592 catch (NoSuchFileEntryException nsfee) {
593 }
594 }
595
596 DLFileEntryServiceUtil.updateFileEntry(
597 fileEntry.getGroupId(), fileEntry.getFolderId(), parentFolderId,
598 name, sourceFileName, title, description, versionDescription,
599 false, extraSettings, bytes, serviceContext);
600
601 return status;
602 }
603 catch (PrincipalException pe) {
604 return HttpServletResponse.SC_FORBIDDEN;
605 }
606 catch (DuplicateFileException dfe) {
607 return HttpServletResponse.SC_PRECONDITION_FAILED;
608 }
609 catch (DuplicateFolderNameException dfne) {
610 return HttpServletResponse.SC_PRECONDITION_FAILED;
611 }
612 catch (LockException le) {
613 return WebDAVUtil.SC_LOCKED;
614 }
615 catch (Exception e) {
616 throw new WebDAVException(e);
617 }
618 }
619
620 public int putResource(WebDAVRequest webDavRequest) throws WebDAVException {
621 File file = null;
622
623 try {
624 HttpServletRequest request = webDavRequest.getHttpServletRequest();
625
626 String[] pathArray = webDavRequest.getPathArray();
627
628 long companyId = webDavRequest.getCompanyId();
629 long groupId = webDavRequest.getGroupId();
630 long parentFolderId = getParentFolderId(companyId, pathArray);
631 String name = WebDAVUtil.getResourceName(pathArray);
632 String title = name;
633 String description = StringPool.BLANK;
634 String versionDescription = StringPool.BLANK;
635 String extraSettings = StringPool.BLANK;
636
637 ServiceContext serviceContext = new ServiceContext();
638
639 serviceContext.setAddCommunityPermissions(
640 isAddCommunityPermissions(groupId));
641 serviceContext.setAddGuestPermissions(true);
642
643 if (PropsValues.DL_WEBDAV_SAVE_TO_SINGLE_VERSION) {
644 serviceContext.setWorkflowAction(
645 WorkflowConstants.ACTION_SAVE_DRAFT);
646 }
647
648 try {
649 DLFileEntry entry = DLFileEntryServiceUtil.getFileEntryByTitle(
650 groupId, parentFolderId, name);
651
652 if (isLocked(entry, webDavRequest.getLockUuid())) {
653 return WebDAVUtil.SC_LOCKED;
654 }
655
656 name = entry.getName();
657 description = entry.getDescription();
658 extraSettings = entry.getExtraSettings();
659
660 String[] assetTagNames = AssetTagLocalServiceUtil.getTagNames(
661 DLFileEntry.class.getName(), entry.getFileEntryId());
662
663 serviceContext.setAssetTagNames(assetTagNames);
664
665 file = FileUtil.createTempFile(FileUtil.getExtension(name));
666
667 FileUtil.write(file, request.getInputStream());
668
669 DLFileEntryServiceUtil.updateFileEntry(
670 groupId, parentFolderId, parentFolderId, name, title, title,
671 description, versionDescription, false, extraSettings, file,
672 serviceContext);
673 }
674 catch (NoSuchFileEntryException nsfee) {
675 file = FileUtil.createTempFile(FileUtil.getExtension(name));
676
677 FileUtil.write(file, request.getInputStream());
678
679 DLFileEntryServiceUtil.addFileEntry(
680 groupId, parentFolderId, name, title, description,
681 versionDescription, extraSettings, file, serviceContext);
682 }
683
684 return HttpServletResponse.SC_CREATED;
685 }
686 catch (PrincipalException pe) {
687 return HttpServletResponse.SC_FORBIDDEN;
688 }
689 catch (NoSuchFolderException nsfe) {
690 return HttpServletResponse.SC_CONFLICT;
691 }
692 catch (PortalException pe) {
693 if (_log.isWarnEnabled()) {
694 _log.warn(pe, pe);
695 }
696
697 return HttpServletResponse.SC_CONFLICT;
698 }
699 catch (Exception e) {
700 throw new WebDAVException(e);
701 }
702 finally {
703 if (file != null) {
704 file.delete();
705 }
706 }
707 }
708
709 public Lock refreshResourceLock(
710 WebDAVRequest webDavRequest, String uuid, long timeout)
711 throws WebDAVException {
712
713 Resource resource = getResource(webDavRequest);
714
715 Lock lock = null;
716
717 try {
718 if (resource instanceof DLFileEntryResourceImpl) {
719 lock = DLFileEntryServiceUtil.refreshFileEntryLock(
720 uuid, timeout);
721 }
722 else {
723 lock = DLFolderServiceUtil.refreshFolderLock(uuid, timeout);
724 }
725 }
726 catch (Exception e) {
727 throw new WebDAVException(e);
728 }
729
730 return lock;
731 }
732
733 public boolean unlockResource(WebDAVRequest webDavRequest, String token)
734 throws WebDAVException {
735
736 Resource resource = getResource(webDavRequest);
737
738 try {
739 if (resource instanceof DLFileEntryResourceImpl) {
740 DLFileEntry fileEntry = (DLFileEntry)resource.getModel();
741
742 if (PropsValues.DL_WEBDAV_HOLD_LOCK) {
743 return true;
744 }
745
746 if (PropsValues.DL_WEBDAV_SAVE_TO_SINGLE_VERSION) {
747 publishFileEntry(fileEntry);
748 }
749
750 DLFileEntryServiceUtil.unlockFileEntry(
751 fileEntry.getGroupId(), fileEntry.getFolderId(),
752 fileEntry.getName(), token);
753 }
754 else {
755 DLFolder folder = (DLFolder)resource.getModel();
756
757 DLFolderServiceUtil.unlockFolder(
758 folder.getGroupId(), folder.getParentFolderId(),
759 folder.getName(), token);
760 }
761
762 return true;
763 }
764 catch (Exception e) {
765 if (e instanceof InvalidLockException) {
766 if (_log.isWarnEnabled()) {
767 _log.warn(e.getMessage());
768 }
769 }
770 else {
771 if (_log.isWarnEnabled()) {
772 _log.warn("Unable to unlock file entry", e);
773 }
774 }
775 }
776
777 return false;
778 }
779
780 protected boolean deleteResource(
781 long groupId, long parentFolderId, String name, String lockUuid)
782 throws Exception {
783
784 try {
785 DLFolder folder = DLFolderServiceUtil.getFolder(
786 groupId, parentFolderId, name);
787
788 DLFolderServiceUtil.deleteFolder(folder.getFolderId());
789
790 return true;
791 }
792 catch (NoSuchFolderException nsfe) {
793 try {
794 DLFileEntry fileEntry =
795 DLFileEntryServiceUtil.getFileEntryByTitle(
796 groupId, parentFolderId, name);
797
798 if (isLocked(fileEntry, lockUuid)) {
799 throw new LockException();
800 }
801
802 DLFileEntryServiceUtil.deleteFileEntryByTitle(
803 groupId, parentFolderId, name);
804
805 return true;
806 }
807 catch (NoSuchFileEntryException nsfee) {
808 }
809 }
810
811 return false;
812 }
813
814 protected List<Resource> getFileEntries(
815 WebDAVRequest webDavRequest, long parentFolderId)
816 throws Exception {
817
818 List<Resource> resources = new ArrayList<Resource>();
819
820 List<DLFileEntry> fileEntries = DLFileEntryServiceUtil.getFileEntries(
821 webDavRequest.getGroupId(), parentFolderId);
822
823 for (DLFileEntry fileEntry : fileEntries) {
824 Resource resource = toResource(webDavRequest, fileEntry, true);
825
826 resources.add(resource);
827 }
828
829 return resources;
830 }
831
832 protected long getFolderId(long companyId, String[] pathArray)
833 throws Exception {
834
835 return getFolderId(companyId, pathArray, false);
836 }
837
838 protected long getFolderId(
839 long companyId, String[] pathArray, boolean parent)
840 throws Exception {
841
842 long folderId = DLFolderConstants.DEFAULT_PARENT_FOLDER_ID;
843
844 if (pathArray.length <= 1) {
845 return folderId;
846 }
847 else {
848 long groupId = WebDAVUtil.getGroupId(companyId, pathArray);
849
850 int x = pathArray.length;
851
852 if (parent) {
853 x--;
854 }
855
856 for (int i = 2; i < x; i++) {
857 String name = pathArray[i];
858
859 DLFolder folder = DLFolderServiceUtil.getFolder(
860 groupId, folderId, name);
861
862 if (groupId == folder.getGroupId()) {
863 folderId = folder.getFolderId();
864 }
865 }
866 }
867
868 return folderId;
869 }
870
871 protected List<Resource> getFolders(
872 WebDAVRequest webDavRequest, long parentFolderId)
873 throws Exception {
874
875 List<Resource> resources = new ArrayList<Resource>();
876
877 long groupId = webDavRequest.getGroupId();
878
879 List<DLFolder> folders = DLFolderServiceUtil.getFolders(
880 groupId, parentFolderId);
881
882 for (DLFolder folder : folders) {
883 Resource resource = toResource(webDavRequest, folder, true);
884
885 resources.add(resource);
886 }
887
888 return resources;
889 }
890
891 protected long getParentFolderId(long companyId, String[] pathArray)
892 throws Exception {
893
894 return getFolderId(companyId, pathArray, true);
895 }
896
897 protected boolean isLocked(DLFileEntry fileEntry, String lockUuid)
898 throws Exception {
899
900 long groupId = fileEntry.getGroupId();
901 long parentFolderId = fileEntry.getFolderId();
902 String fileName = fileEntry.getName();
903
904 if (Validator.isNull(lockUuid)) {
905
906
908 return DLFileEntryServiceUtil.hasFileEntryLock(
909 groupId, parentFolderId, fileName);
910 }
911 else {
912
913
915 try {
916 boolean verified = DLFileEntryServiceUtil.verifyFileEntryLock(
917 groupId, parentFolderId, fileName, lockUuid);
918
919 return !verified;
920 }
921 catch (NoSuchLockException nsle) {
922 return false;
923 }
924 }
925 }
926
927 protected void publishFileEntry(DLFileEntry fileEntry) throws Exception {
928 DLFileVersion latestFileVersion =
929 DLFileVersionLocalServiceUtil.getLatestFileVersion(
930 fileEntry.getGroupId(), fileEntry.getFolderId(),
931 fileEntry.getName());
932
933 if (latestFileVersion.getStatus() ==
934 WorkflowConstants.STATUS_APPROVED) {
935
936 return;
937 }
938
939 ServiceContext serviceContext = new ServiceContext();
940
941 serviceContext.setAddCommunityPermissions(
942 isAddCommunityPermissions(fileEntry.getGroupId()));
943 serviceContext.setAddGuestPermissions(true);
944
945 DLFileEntryLocalServiceUtil.updateFileEntry(
946 latestFileVersion.getUserId(), latestFileVersion.getGroupId(),
947 latestFileVersion.getFolderId(), latestFileVersion.getFolderId(),
948 latestFileVersion.getName(), fileEntry.getTitle(),
949 fileEntry.getTitle(), fileEntry.getDescription(),
950 latestFileVersion.getDescription(), true,
951 fileEntry.getExtraSettings(), null, 0, serviceContext);
952 }
953
954 protected Resource toResource(
955 WebDAVRequest webDavRequest, DLFileEntry fileEntry,
956 boolean appendPath) {
957
958 String parentPath = getRootPath() + webDavRequest.getPath();
959 String name = StringPool.BLANK;
960
961 if (appendPath) {
962 name = fileEntry.getTitle();
963 }
964
965 return new DLFileEntryResourceImpl(
966 webDavRequest, fileEntry, parentPath, name);
967 }
968
969 protected Resource toResource(
970 WebDAVRequest webDavRequest, DLFolder folder, boolean appendPath) {
971
972 String parentPath = getRootPath() + webDavRequest.getPath();
973 String name = StringPool.BLANK;
974
975 if (appendPath) {
976 name = folder.getName();
977 }
978
979 Resource resource = new BaseResourceImpl(
980 parentPath, name, folder.getName(), folder.getCreateDate(),
981 folder.getModifiedDate());
982
983 resource.setModel(folder);
984 resource.setClassName(DLFolder.class.getName());
985 resource.setPrimaryKey(folder.getPrimaryKey());
986
987 return resource;
988 }
989
990 private static Log _log = LogFactoryUtil.getLog(DLWebDAVStorageImpl.class);
991
992 }