1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * This library is free software; you can redistribute it and/or modify it under
5    * the terms of the GNU Lesser General Public License as published by the Free
6    * Software Foundation; either version 2.1 of the License, or (at your option)
7    * any later version.
8    *
9    * This library is distributed in the hope that it will be useful, but WITHOUT
10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11   * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
12   * details.
13   */
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  /**
64   * <a href="DLWebDAVStorageImpl.java.html"><b><i>View Source</i></b></a>
65   *
66   * @author Brian Wing Shun Chan
67   * @author Alexander Chow
68   */
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             // DuplicateLock is 423 not 501
408 
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             // LPS-5415
563 
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             // Client does not claim to know of a lock
907 
908             return DLFileEntryServiceUtil.hasFileEntryLock(
909                 groupId, parentFolderId, fileName);
910         }
911         else {
912 
913             // Client claims to know of a lock. Verify the lock UUID.
914 
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 }