001
014
015 package com.liferay.portlet.documentlibrary.service.impl;
016
017 import com.liferay.documentlibrary.DuplicateFileException;
018 import com.liferay.documentlibrary.FileSizeException;
019 import com.liferay.documentlibrary.NoSuchFileException;
020 import com.liferay.documentlibrary.util.JCRHook;
021 import com.liferay.portal.kernel.exception.PortalException;
022 import com.liferay.portal.kernel.exception.SystemException;
023 import com.liferay.portal.kernel.io.unsync.UnsyncBufferedInputStream;
024 import com.liferay.portal.kernel.io.unsync.UnsyncByteArrayInputStream;
025 import com.liferay.portal.kernel.log.Log;
026 import com.liferay.portal.kernel.log.LogFactoryUtil;
027 import com.liferay.portal.kernel.search.Indexer;
028 import com.liferay.portal.kernel.search.IndexerRegistryUtil;
029 import com.liferay.portal.kernel.util.FileUtil;
030 import com.liferay.portal.kernel.util.GetterUtil;
031 import com.liferay.portal.kernel.util.MimeTypesUtil;
032 import com.liferay.portal.kernel.util.OrderByComparator;
033 import com.liferay.portal.kernel.util.StringPool;
034 import com.liferay.portal.kernel.util.StringUtil;
035 import com.liferay.portal.kernel.util.Validator;
036 import com.liferay.portal.kernel.workflow.WorkflowConstants;
037 import com.liferay.portal.kernel.workflow.WorkflowHandlerRegistryUtil;
038 import com.liferay.portal.model.Resource;
039 import com.liferay.portal.model.ResourceConstants;
040 import com.liferay.portal.model.User;
041 import com.liferay.portal.service.ServiceContext;
042 import com.liferay.portal.util.PortalUtil;
043 import com.liferay.portal.util.PortletKeys;
044 import com.liferay.portal.util.PropsValues;
045 import com.liferay.portlet.asset.NoSuchEntryException;
046 import com.liferay.portlet.asset.model.AssetEntry;
047 import com.liferay.portlet.documentlibrary.DuplicateFolderNameException;
048 import com.liferay.portlet.documentlibrary.NoSuchFileEntryException;
049 import com.liferay.portlet.documentlibrary.NoSuchFileVersionException;
050 import com.liferay.portlet.documentlibrary.NoSuchFolderException;
051 import com.liferay.portlet.documentlibrary.model.DLFileEntry;
052 import com.liferay.portlet.documentlibrary.model.DLFileEntryConstants;
053 import com.liferay.portlet.documentlibrary.model.DLFileShortcut;
054 import com.liferay.portlet.documentlibrary.model.DLFileVersion;
055 import com.liferay.portlet.documentlibrary.model.DLFolder;
056 import com.liferay.portlet.documentlibrary.model.DLFolderConstants;
057 import com.liferay.portlet.documentlibrary.model.impl.DLFileEntryImpl;
058 import com.liferay.portlet.documentlibrary.service.base.DLFileEntryLocalServiceBaseImpl;
059 import com.liferay.portlet.documentlibrary.social.DLActivityKeys;
060 import com.liferay.portlet.documentlibrary.util.DLUtil;
061 import com.liferay.portlet.documentlibrary.util.comparator.FileEntryModifiedDateComparator;
062 import com.liferay.portlet.messageboards.model.MBDiscussion;
063 import com.liferay.portlet.ratings.model.RatingsEntry;
064 import com.liferay.portlet.ratings.model.RatingsStats;
065
066 import java.io.File;
067 import java.io.FileInputStream;
068 import java.io.FileNotFoundException;
069 import java.io.InputStream;
070
071 import java.util.Date;
072 import java.util.List;
073
074
086 public class DLFileEntryLocalServiceImpl
087 extends DLFileEntryLocalServiceBaseImpl {
088
089 public DLFileEntry addFileEntry(
090 long userId, long groupId, long folderId, String name, String title,
091 String description, String changeLog, String extraSettings,
092 byte[] bytes, ServiceContext serviceContext)
093 throws PortalException, SystemException {
094
095 if (bytes == null) {
096 throw new FileSizeException();
097 }
098
099 InputStream is = new UnsyncByteArrayInputStream(bytes);
100
101 return addFileEntry(
102 userId, groupId, folderId, name, title, description,
103 changeLog, extraSettings, is, bytes.length, serviceContext);
104 }
105
106 public DLFileEntry addFileEntry(
107 long userId, long groupId, long folderId, String name, String title,
108 String description, String changeLog, String extraSettings,
109 File file, ServiceContext serviceContext)
110 throws PortalException, SystemException {
111
112 if (file == null) {
113 throw new FileSizeException();
114 }
115
116 try {
117 InputStream is = new UnsyncBufferedInputStream(
118 new FileInputStream(file));
119
120 return addFileEntry(
121 userId, groupId, folderId, name, title, description,
122 changeLog, extraSettings, is, file.length(), serviceContext);
123 }
124 catch (FileNotFoundException fnfe) {
125 throw new FileSizeException();
126 }
127 }
128
129 public DLFileEntry addFileEntry(
130 long userId, long groupId, long folderId, String name, String title,
131 String description, String changeLog, String extraSettings,
132 InputStream is, long size, ServiceContext serviceContext)
133 throws PortalException, SystemException {
134
135
136
137 User user = userPersistence.findByPrimaryKey(userId);
138 folderId = getFolderId(user.getCompanyId(), folderId);
139
140 String extension = FileUtil.getExtension(name);
141
142 if (Validator.isNull(title)) {
143 title = name;
144 }
145
146 name = String.valueOf(
147 counterLocalService.increment(DLFileEntry.class.getName()));
148
149 Date now = new Date();
150
151 validate(groupId, folderId, title, is);
152
153 long fileEntryId = counterLocalService.increment();
154
155 DLFileEntry fileEntry = dlFileEntryPersistence.create(fileEntryId);
156
157 fileEntry.setUuid(serviceContext.getUuid());
158 fileEntry.setGroupId(groupId);
159 fileEntry.setCompanyId(user.getCompanyId());
160 fileEntry.setUserId(user.getUserId());
161 fileEntry.setUserName(user.getFullName());
162 fileEntry.setVersionUserId(user.getUserId());
163 fileEntry.setVersionUserName(user.getFullName());
164 fileEntry.setCreateDate(serviceContext.getCreateDate(now));
165 fileEntry.setModifiedDate(serviceContext.getModifiedDate(now));
166 fileEntry.setFolderId(folderId);
167 fileEntry.setName(name);
168 fileEntry.setExtension(extension);
169 fileEntry.setTitle(title);
170 fileEntry.setDescription(description);
171 fileEntry.setExtraSettings(extraSettings);
172 fileEntry.setVersion(DLFileEntryConstants.DEFAULT_VERSION);
173 fileEntry.setSize(size);
174 fileEntry.setReadCount(DLFileEntryConstants.DEFAULT_READ_COUNT);
175
176 dlFileEntryPersistence.update(fileEntry, false);
177
178
179
180 if (serviceContext.getAddCommunityPermissions() ||
181 serviceContext.getAddGuestPermissions()) {
182
183 addFileEntryResources(
184 fileEntry, serviceContext.getAddCommunityPermissions(),
185 serviceContext.getAddGuestPermissions());
186 }
187 else {
188 addFileEntryResources(
189 fileEntry, serviceContext.getCommunityPermissions(),
190 serviceContext.getGuestPermissions());
191 }
192
193
194
195 DLFileVersion fileVersion = addFileVersion(
196 user, fileEntry, serviceContext.getModifiedDate(now),
197 extension, title, description, null, extraSettings,
198 DLFileEntryConstants.DEFAULT_VERSION, size,
199 WorkflowConstants.STATUS_DRAFT, serviceContext);
200
201
202
203 if (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
204 DLFolder folder = dlFolderPersistence.findByPrimaryKey(folderId);
205
206 folder.setLastPostDate(fileEntry.getModifiedDate());
207
208 dlFolderPersistence.update(folder, false);
209 }
210
211
212
213 updateAsset(
214 userId, fileEntry, fileVersion,
215 serviceContext.getAssetCategoryIds(),
216 serviceContext.getAssetTagNames());
217
218
219
220 if (PropsValues.DL_FILE_ENTRY_COMMENTS_ENABLED) {
221 mbMessageLocalService.addDiscussionMessage(
222 userId, fileEntry.getUserName(), groupId,
223 DLFileEntry.class.getName(), fileEntryId,
224 WorkflowConstants.ACTION_PUBLISH);
225 }
226
227
228
229 dlLocalService.addFile(
230 user.getCompanyId(), PortletKeys.DOCUMENT_LIBRARY,
231 fileEntry.getGroupId(), fileEntry.getRepositoryId(), name, false,
232 fileEntryId, fileEntry.getLuceneProperties(),
233 fileEntry.getModifiedDate(), serviceContext, is);
234
235
236
237 WorkflowHandlerRegistryUtil.startWorkflowInstance(
238 user.getCompanyId(), groupId, userId, DLFileEntry.class.getName(),
239 fileEntryId, fileEntry, serviceContext);
240
241 return fileEntry;
242 }
243
244 public void addFileEntryResources(
245 DLFileEntry fileEntry, boolean addCommunityPermissions,
246 boolean addGuestPermissions)
247 throws PortalException, SystemException {
248
249 resourceLocalService.addResources(
250 fileEntry.getCompanyId(), fileEntry.getGroupId(),
251 fileEntry.getUserId(), DLFileEntry.class.getName(),
252 fileEntry.getFileEntryId(), false, addCommunityPermissions,
253 addGuestPermissions);
254 }
255
256 public void addFileEntryResources(
257 DLFileEntry fileEntry, String[] communityPermissions,
258 String[] guestPermissions)
259 throws PortalException, SystemException {
260
261 resourceLocalService.addModelResources(
262 fileEntry.getCompanyId(), fileEntry.getGroupId(),
263 fileEntry.getUserId(), DLFileEntry.class.getName(),
264 fileEntry.getFileEntryId(), communityPermissions, guestPermissions);
265 }
266
267 public void addFileEntryResources(
268 long fileEntryId, boolean addCommunityPermissions,
269 boolean addGuestPermissions)
270 throws PortalException, SystemException {
271
272 DLFileEntry fileEntry = dlFileEntryPersistence.findByPrimaryKey(
273 fileEntryId);
274
275 addFileEntryResources(
276 fileEntry, addCommunityPermissions, addGuestPermissions);
277 }
278
279 public void addFileEntryResources(
280 long fileEntryId, String[] communityPermissions,
281 String[] guestPermissions)
282 throws PortalException, SystemException {
283
284 DLFileEntry fileEntry = dlFileEntryPersistence.findByPrimaryKey(
285 fileEntryId);
286
287 addFileEntryResources(
288 fileEntry, communityPermissions, guestPermissions);
289 }
290
291 public DLFileEntry addOrOverwriteFileEntry(
292 long userId, long groupId, long folderId, String name,
293 String sourceName, String title, String description,
294 String changeLog, String extraSettings, File file,
295 ServiceContext serviceContext)
296 throws PortalException, SystemException {
297
298 try {
299 dlFileEntryPersistence.findByG_F_T(groupId, folderId, title);
300
301 return updateFileEntry(
302 userId, groupId, folderId, name, sourceName, title, description,
303 changeLog, false, extraSettings, file, serviceContext);
304 }
305 catch (NoSuchFileEntryException nsfee) {
306 return addFileEntry(
307 userId, groupId, folderId, name, title, description, changeLog,
308 extraSettings, file, serviceContext);
309 }
310 }
311
312 public void deleteFileEntries(long groupId, long folderId)
313 throws PortalException, SystemException {
314
315 List<DLFileEntry> fileEntries = dlFileEntryPersistence.findByG_F(
316 groupId, folderId);
317
318 for (DLFileEntry fileEntry : fileEntries) {
319 deleteFileEntry(fileEntry);
320 }
321 }
322
323 public void deleteFileEntry(DLFileEntry fileEntry)
324 throws PortalException, SystemException {
325
326
327
328 dlFileEntryPersistence.remove(fileEntry);
329
330
331
332 resourceLocalService.deleteResource(
333 fileEntry.getCompanyId(), DLFileEntry.class.getName(),
334 ResourceConstants.SCOPE_INDIVIDUAL, fileEntry.getFileEntryId());
335
336
337
338 webDAVPropsLocalService.deleteWebDAVProps(
339 DLFileEntry.class.getName(), fileEntry.getFileEntryId());
340
341
342
343 workflowInstanceLinkLocalService.deleteWorkflowInstanceLinks(
344 fileEntry.getCompanyId(), fileEntry.getGroupId(),
345 DLFileEntry.class.getName(), fileEntry.getFileEntryId());
346
347
348
349 dlFileRankLocalService.deleteFileRanks(
350 fileEntry.getFolderId(), fileEntry.getName());
351
352
353
354 dlFileShortcutLocalService.deleteFileShortcuts(
355 fileEntry.getGroupId(), fileEntry.getFolderId(),
356 fileEntry.getName());
357
358
359
360 List<DLFileVersion> fileVersions = dlFileVersionPersistence.findByG_F_N(
361 fileEntry.getGroupId(), fileEntry.getFolderId(),
362 fileEntry.getName());
363
364 for (DLFileVersion fileVersion : fileVersions) {
365 dlFileVersionPersistence.remove(fileVersion);
366 }
367
368
369
370 assetEntryLocalService.deleteEntry(
371 DLFileEntry.class.getName(), fileEntry.getFileEntryId());
372
373
374
375 expandoValueLocalService.deleteValues(
376 DLFileEntry.class.getName(), fileEntry.getFileEntryId());
377
378
379
380 mbMessageLocalService.deleteDiscussionMessages(
381 DLFileEntry.class.getName(), fileEntry.getFileEntryId());
382
383
384
385 ratingsStatsLocalService.deleteStats(
386 DLFileEntry.class.getName(), fileEntry.getFileEntryId());
387
388
389
390 socialActivityLocalService.deleteActivities(
391 DLFileEntry.class.getName(), fileEntry.getFileEntryId());
392
393
394
395 try {
396 dlService.deleteFile(
397 fileEntry.getCompanyId(), PortletKeys.DOCUMENT_LIBRARY,
398 fileEntry.getRepositoryId(), fileEntry.getName());
399 }
400 catch (Exception e) {
401 if (_log.isWarnEnabled()) {
402 _log.warn(e, e);
403 }
404 }
405 }
406
407 public void deleteFileEntry(long groupId, long folderId, String name)
408 throws PortalException, SystemException {
409
410 deleteFileEntry(groupId, folderId, name, null);
411 }
412
413 public void deleteFileEntry(
414 long groupId, long folderId, String name, String version)
415 throws PortalException, SystemException {
416
417 DLFileEntry fileEntry = dlFileEntryPersistence.findByG_F_N(
418 groupId, folderId, name);
419
420 if (Validator.isNotNull(version)) {
421 try {
422 dlService.deleteFile(
423 fileEntry.getCompanyId(), PortletKeys.DOCUMENT_LIBRARY,
424 fileEntry.getRepositoryId(), fileEntry.getName(), version);
425 }
426 catch (Exception e) {
427 if (_log.isWarnEnabled()) {
428 _log.warn(e, e);
429 }
430 }
431
432 long fileVersionsCount = dlFileVersionPersistence.countByG_F_N(
433 groupId, folderId, name);
434
435 dlFileVersionPersistence.removeByG_F_N_V(
436 groupId, folderId, name, version);
437
438 if (fileVersionsCount == 1) {
439 dlFileEntryPersistence.remove(fileEntry);
440 }
441 else {
442 if (version.equals(fileEntry.getVersion())) {
443 try {
444 DLFileVersion fileVersion =
445 dlFileVersionLocalService.getLatestFileVersion(
446 groupId, folderId, name);
447
448 fileEntry.setVersion(fileVersion.getVersion());
449 fileEntry.setSize(fileVersion.getSize());
450 }
451 catch (NoSuchFileVersionException nsfve) {
452 }
453 }
454
455 dlFileEntryPersistence.update(fileEntry, false);
456 }
457 }
458 else {
459 deleteFileEntry(fileEntry);
460 }
461 }
462
463 public List<DLFileEntry> getCompanyFileEntries(
464 long companyId, int start, int end)
465 throws SystemException {
466
467 return dlFileEntryPersistence.findByCompanyId(companyId, start, end);
468 }
469
470 public List<DLFileEntry> getCompanyFileEntries(
471 long companyId, int start, int end, OrderByComparator obc)
472 throws SystemException {
473
474 return dlFileEntryPersistence.findByCompanyId(
475 companyId, start, end, obc);
476 }
477
478 public int getCompanyFileEntriesCount(long companyId)
479 throws SystemException {
480
481 return dlFileEntryPersistence.countByCompanyId(companyId);
482 }
483
484 public InputStream getFileAsStream(
485 long companyId, long userId, long groupId, long folderId,
486 String name)
487 throws PortalException, SystemException {
488
489 return getFileAsStream(
490 companyId, userId, groupId, folderId, name, StringPool.BLANK);
491 }
492
493 public InputStream getFileAsStream(
494 long companyId, long userId, long groupId, long folderId,
495 String name, String version)
496 throws PortalException, SystemException {
497
498 DLFileEntry fileEntry = dlFileEntryPersistence.findByG_F_N(
499 groupId, folderId, name);
500
501 if (userId > 0) {
502 dlFileRankLocalService.updateFileRank(
503 groupId, companyId, userId, folderId, name,
504 new ServiceContext());
505 }
506
507 if (PropsValues.DL_FILE_ENTRY_READ_COUNT_ENABLED) {
508 fileEntry.setReadCount(fileEntry.getReadCount() + 1);
509
510 dlFileEntryPersistence.update(fileEntry, false);
511
512 assetEntryLocalService.incrementViewCounter(
513 userId, DLFileEntry.class.getName(),
514 fileEntry.getFileEntryId());
515
516 List<DLFileShortcut> fileShortcuts =
517 dlFileShortcutPersistence.findByG_TF_TN(
518 groupId, folderId, name);
519
520 for (DLFileShortcut fileShortcut : fileShortcuts) {
521 assetEntryLocalService.incrementViewCounter(
522 userId, DLFileShortcut.class.getName(),
523 fileShortcut.getFileShortcutId());
524 }
525 }
526
527 if (Validator.isNotNull(version)) {
528 return dlLocalService.getFileAsStream(
529 companyId, fileEntry.getRepositoryId(), name, version);
530 }
531 else {
532 return dlLocalService.getFileAsStream(
533 companyId, fileEntry.getRepositoryId(), name,
534 fileEntry.getVersion());
535 }
536 }
537
538 public List<DLFileEntry> getFileEntries(long groupId, long folderId)
539 throws SystemException {
540
541 return dlFileEntryPersistence.findByG_F(groupId, folderId);
542 }
543
544 public List<DLFileEntry> getFileEntries(
545 long groupId, long folderId, int start, int end)
546 throws SystemException {
547
548 return dlFileEntryPersistence.findByG_F(groupId, folderId, start, end);
549 }
550
551 public List<DLFileEntry> getFileEntries(
552 long groupId, long folderId, int start, int end,
553 OrderByComparator obc)
554 throws SystemException {
555
556 return dlFileEntryPersistence.findByG_F(
557 groupId, folderId, start, end, obc);
558 }
559
560 public int getFileEntriesCount(long groupId, long folderId)
561 throws SystemException {
562
563 return dlFileEntryPersistence.countByG_F(groupId, folderId);
564 }
565
566 public DLFileEntry getFileEntry(long fileEntryId)
567 throws PortalException, SystemException {
568
569 return dlFileEntryPersistence.findByPrimaryKey(fileEntryId);
570 }
571
572 public DLFileEntry getFileEntry(long groupId, long folderId, String name)
573 throws PortalException, SystemException {
574
575 return dlFileEntryPersistence.findByG_F_N(groupId, folderId, name);
576 }
577
578 public DLFileEntry getFileEntryByTitle(
579 long groupId, long folderId, String title)
580 throws PortalException, SystemException {
581
582 return dlFileEntryPersistence.findByG_F_T(groupId, folderId, title);
583 }
584
585 public DLFileEntry getFileEntryByUuidAndGroupId(String uuid, long groupId)
586 throws PortalException, SystemException {
587
588 return dlFileEntryPersistence.findByUUID_G(uuid, groupId);
589 }
590
591 public int getFoldersFileEntriesCount(
592 long groupId, List<Long> folderIds, int status)
593 throws SystemException {
594
595 if (folderIds.size() <= PropsValues.SQL_DATA_MAX_PARAMETERS) {
596 return dlFileEntryFinder.countByG_F_S(groupId, folderIds, status);
597 }
598 else {
599 int start = 0;
600 int end = PropsValues.SQL_DATA_MAX_PARAMETERS;
601
602 int filesCount = dlFileEntryFinder.countByG_F_S(
603 groupId, folderIds.subList(start, end), status);
604
605 folderIds.subList(start, end).clear();
606
607 filesCount += getFoldersFileEntriesCount(
608 groupId, folderIds, status);
609
610 return filesCount;
611 }
612 }
613
614 public List<DLFileEntry> getGroupFileEntries(
615 long groupId, int start, int end)
616 throws SystemException {
617
618 return getGroupFileEntries(
619 groupId, start, end, new FileEntryModifiedDateComparator());
620 }
621
622 public List<DLFileEntry> getGroupFileEntries(
623 long groupId, int start, int end, OrderByComparator obc)
624 throws SystemException {
625
626 return dlFileEntryPersistence.findByGroupId(groupId, start, end, obc);
627 }
628
629 public List<DLFileEntry> getGroupFileEntries(
630 long groupId, long userId, int start, int end)
631 throws SystemException {
632
633 return getGroupFileEntries(
634 groupId, userId, start, end, new FileEntryModifiedDateComparator());
635 }
636
637 public List<DLFileEntry> getGroupFileEntries(
638 long groupId, long userId, int start, int end,
639 OrderByComparator obc)
640 throws SystemException {
641
642 if (userId <= 0) {
643 return dlFileEntryPersistence.findByGroupId(
644 groupId, start, end, obc);
645 }
646 else {
647 return dlFileEntryPersistence.findByG_U(
648 groupId, userId, start, end, obc);
649 }
650 }
651
652 public int getGroupFileEntriesCount(long groupId) throws SystemException {
653 return dlFileEntryPersistence.countByGroupId(groupId);
654 }
655
656 public int getGroupFileEntriesCount(long groupId, long userId)
657 throws SystemException {
658
659 if (userId <= 0) {
660 return dlFileEntryPersistence.countByGroupId(groupId);
661 }
662 else {
663 return dlFileEntryPersistence.countByG_U(groupId, userId);
664 }
665 }
666
667 public List<DLFileEntry> getNoAssetFileEntries() throws SystemException {
668 return dlFileEntryFinder.findByNoAssets();
669 }
670
671 public DLFileEntry moveFileEntry(
672 long userId, long groupId, long folderId, long newFolderId,
673 String name, ServiceContext serviceContext)
674 throws PortalException, SystemException {
675
676 User user = userPersistence.findByPrimaryKey(userId);
677
678 Date now = new Date();
679
680 DLFileEntry fileEntry = dlFileEntryPersistence.findByG_F_N(
681 groupId, folderId, name);
682
683 long oldFileEntryId = fileEntry.getFileEntryId();
684
685 if (dlLocalService.hasFile(
686 user.getCompanyId(),
687 DLFileEntryImpl.getRepositoryId(groupId, newFolderId), name,
688 StringPool.BLANK)) {
689
690 throw new DuplicateFileException(name);
691 }
692
693 long newFileEntryId = counterLocalService.increment();
694
695 DLFileEntry newFileEntry = dlFileEntryPersistence.create(
696 newFileEntryId);
697
698 newFileEntry.setGroupId(fileEntry.getGroupId());
699 newFileEntry.setCompanyId(fileEntry.getCompanyId());
700 newFileEntry.setUserId(fileEntry.getUserId());
701 newFileEntry.setUserName(fileEntry.getUserName());
702 newFileEntry.setVersionUserId(fileEntry.getVersionUserId());
703 newFileEntry.setVersionUserName(fileEntry.getVersionUserName());
704 newFileEntry.setCreateDate(fileEntry.getCreateDate());
705 newFileEntry.setModifiedDate(fileEntry.getModifiedDate());
706 newFileEntry.setFolderId(newFolderId);
707 newFileEntry.setName(name);
708 newFileEntry.setExtension(fileEntry.getExtension());
709 newFileEntry.setTitle(fileEntry.getTitle());
710 newFileEntry.setDescription(fileEntry.getDescription());
711 newFileEntry.setExtraSettings(fileEntry.getExtraSettings());
712 newFileEntry.setVersion(fileEntry.getVersion());
713 newFileEntry.setSize(fileEntry.getSize());
714 newFileEntry.setReadCount(fileEntry.getReadCount());
715
716 dlFileEntryPersistence.update(newFileEntry, false);
717
718 dlFileEntryPersistence.remove(fileEntry);
719
720 workflowInstanceLinkLocalService.updateClassPK(
721 fileEntry.getCompanyId(), fileEntry.getGroupId(),
722 DLFileEntry.class.getName(), oldFileEntryId, newFileEntryId);
723
724 List<DLFileVersion> fileVersions = dlFileVersionPersistence.findByG_F_N(
725 groupId, folderId, name);
726
727 for (DLFileVersion fileVersion : fileVersions) {
728 long newFileVersionId = counterLocalService.increment();
729
730 DLFileVersion newFileVersion = dlFileVersionPersistence.create(
731 newFileVersionId);
732
733 newFileVersion.setGroupId(fileVersion.getGroupId());
734 newFileVersion.setCompanyId(fileVersion.getCompanyId());
735 newFileVersion.setUserId(fileVersion.getUserId());
736 newFileVersion.setUserName(fileVersion.getUserName());
737 newFileVersion.setCreateDate(fileVersion.getCreateDate());
738 newFileVersion.setFolderId(newFolderId);
739 newFileVersion.setName(name);
740 newFileVersion.setExtension(fileVersion.getExtension());
741 newFileVersion.setTitle(fileVersion.getTitle());
742 newFileVersion.setDescription(fileVersion.getDescription());
743 newFileVersion.setChangeLog(fileVersion.getChangeLog());
744 newFileVersion.setExtraSettings(fileVersion.getExtraSettings());
745 newFileVersion.setVersion(fileVersion.getVersion());
746 newFileVersion.setSize(fileVersion.getSize());
747 newFileVersion.setStatus(fileVersion.getStatus());
748 newFileVersion.setStatusByUserId(userId);
749 newFileVersion.setStatusByUserName(user.getFullName());
750 newFileVersion.setStatusDate(serviceContext.getModifiedDate(now));
751
752 dlFileVersionPersistence.update(newFileVersion, false);
753
754 dlFileVersionPersistence.remove(fileVersion);
755 }
756
757 dlFileShortcutLocalService.updateFileShortcuts(
758 groupId, folderId, name, newFolderId, name);
759
760
761
762 Resource resource = resourceLocalService.getResource(
763 fileEntry.getCompanyId(), DLFileEntry.class.getName(),
764 ResourceConstants.SCOPE_INDIVIDUAL,
765 String.valueOf(fileEntry.getFileEntryId()));
766
767 resource.setPrimKey(String.valueOf(newFileEntryId));
768
769 resourcePersistence.update(resource, false);
770
771
772
773 assetEntryLocalService.deleteEntry(
774 DLFileEntry.class.getName(), fileEntry.getFileEntryId());
775
776 List<DLFileShortcut> fileShortcuts =
777 dlFileShortcutPersistence.findByG_TF_TN(
778 groupId, folderId, name);
779
780 for (DLFileShortcut fileShortcut : fileShortcuts) {
781 assetEntryLocalService.deleteEntry(
782 DLFileShortcut.class.getName(),
783 fileShortcut.getFileShortcutId());
784 }
785
786
787
788 expandoValueLocalService.deleteValues(
789 DLFileEntry.class.getName(), fileEntry.getFileEntryId());
790
791
792
793 RatingsStats stats = ratingsStatsLocalService.getStats(
794 DLFileEntry.class.getName(), oldFileEntryId);
795
796 stats.setClassPK(newFileEntryId);
797
798 ratingsStatsPersistence.update(stats, false);
799
800 long classNameId = PortalUtil.getClassNameId(
801 DLFileEntry.class.getName());
802
803 List<RatingsEntry> entries = ratingsEntryPersistence.findByC_C(
804 classNameId, oldFileEntryId);
805
806 for (RatingsEntry entry : entries) {
807 entry.setClassPK(newFileEntryId);
808
809 ratingsEntryPersistence.update(entry, false);
810 }
811
812
813
814 MBDiscussion discussion = mbDiscussionPersistence.fetchByC_C(
815 classNameId, oldFileEntryId);
816
817 if (discussion != null) {
818 discussion.setClassPK(newFileEntryId);
819
820 mbDiscussionPersistence.update(discussion, false);
821 }
822
823
824
825 socialActivityLocalService.deleteActivities(
826 DLFileEntry.class.getName(), fileEntry.getFileEntryId());
827
828
829
830 dlService.updateFile(
831 user.getCompanyId(), PortletKeys.DOCUMENT_LIBRARY,
832 newFileEntry.getGroupId(), fileEntry.getRepositoryId(),
833 newFileEntry.getRepositoryId(), name, newFileEntryId);
834
835 return newFileEntry;
836 }
837
838 public void updateAsset(
839 long userId, DLFileEntry fileEntry, DLFileVersion fileVersion,
840 long[] assetCategoryIds, String[] assetTagNames)
841 throws PortalException, SystemException {
842
843 String mimeType = MimeTypesUtil.getContentType(fileEntry.getTitle());
844
845 boolean addDraftAssetEntry = false;
846
847 if ((fileVersion != null) && !fileVersion.isApproved() &&
848 (fileVersion.getVersion() !=
849 DLFileEntryConstants.DEFAULT_VERSION)) {
850
851 int approvedArticlesCount =
852 dlFileVersionPersistence.countByG_F_N_S(
853 fileEntry.getGroupId(), fileEntry.getFolderId(),
854 fileEntry.getName(), WorkflowConstants.STATUS_APPROVED);
855
856 if (approvedArticlesCount > 0) {
857 addDraftAssetEntry = true;
858 }
859 }
860
861 if (addDraftAssetEntry) {
862 assetEntryLocalService.updateEntry(
863 userId, fileEntry.getGroupId(), DLFileEntry.class.getName(),
864 fileVersion.getFileVersionId(), fileEntry.getUuid(),
865 assetCategoryIds, assetTagNames, false, null, null, null, null,
866 mimeType, fileEntry.getTitle(), fileEntry.getDescription(),
867 null, null, 0, 0, null, false);
868 }
869 else {
870 boolean visible = true;
871
872 if ((fileVersion != null) && !fileVersion.isApproved()) {
873 visible = false;
874 }
875
876 assetEntryLocalService.updateEntry(
877 userId, fileEntry.getGroupId(), DLFileEntry.class.getName(),
878 fileEntry.getFileEntryId(), fileEntry.getUuid(),
879 assetCategoryIds, assetTagNames, visible, null, null, null,
880 null, mimeType, fileEntry.getTitle(),
881 fileEntry.getDescription(), null, null, 0, 0, null, false);
882
883 List<DLFileShortcut> fileShortcuts =
884 dlFileShortcutPersistence.findByG_TF_TN(
885 fileEntry.getGroupId(), fileEntry.getFolderId(),
886 fileEntry.getName());
887
888 for (DLFileShortcut fileShortcut : fileShortcuts) {
889 assetEntryLocalService.updateEntry(
890 userId, fileShortcut.getGroupId(),
891 DLFileShortcut.class.getName(),
892 fileShortcut.getFileShortcutId(), fileShortcut.getUuid(),
893 assetCategoryIds, assetTagNames, true, null, null, null,
894 null, mimeType, fileEntry.getTitle(),
895 fileEntry.getDescription(), null, null, 0, 0, null, false);
896 }
897 }
898 }
899
900 public DLFileEntry updateFileEntry(
901 long userId, long groupId, long folderId, String name,
902 String sourceFileName, String title, String description,
903 String changeLog, boolean majorVersion, String extraSettings,
904 byte[] bytes, ServiceContext serviceContext)
905 throws PortalException, SystemException {
906
907 InputStream is = null;
908 long size = 0;
909
910 if (bytes != null) {
911 is = new UnsyncByteArrayInputStream(bytes);
912 size = bytes.length;
913 }
914
915 return updateFileEntry(
916 userId, groupId, folderId, name, sourceFileName, title, description,
917 changeLog, majorVersion, extraSettings, is, size, serviceContext);
918 }
919
920 public DLFileEntry updateFileEntry(
921 long userId, long groupId, long folderId, String name,
922 String sourceFileName, String title, String description,
923 String changeLog, boolean majorVersion, String extraSettings,
924 File file, ServiceContext serviceContext)
925 throws PortalException, SystemException {
926
927 try {
928 InputStream is = null;
929 long size = 0;
930
931 if ((file != null) && file.exists()) {
932 is = new UnsyncBufferedInputStream(new FileInputStream(file));
933 size = file.length();
934 }
935
936 return updateFileEntry(
937 userId, groupId, folderId, name, sourceFileName, title,
938 description, changeLog, majorVersion, extraSettings, is, size,
939 serviceContext);
940 }
941 catch (FileNotFoundException fnfe) {
942 throw new NoSuchFileException();
943 }
944 }
945
946 public DLFileEntry updateFileEntry(
947 long userId, long groupId, long folderId, String name,
948 String sourceFileName, String title, String description,
949 String changeLog, boolean majorVersion, String extraSettings,
950 InputStream is, long size, ServiceContext serviceContext)
951 throws PortalException, SystemException {
952
953
954
955 User user = userPersistence.findByPrimaryKey(userId);
956
957 if (Validator.isNull(title)) {
958 title = sourceFileName;
959
960 if (Validator.isNull(title)) {
961 title = name;
962 }
963 }
964
965 Date now = new Date();
966
967 DLFileEntry fileEntry = dlFileEntryPersistence.findByG_F_N(
968 groupId, folderId, name);
969
970 validate(
971 groupId, folderId, name, fileEntry.getExtension(), title,
972 sourceFileName, is);
973
974
975
976 String version = getNextVersion(
977 fileEntry, majorVersion, serviceContext.getWorkflowAction());
978
979 DLFileVersion fileVersion = null;
980
981 String extension = null;
982
983 if (Validator.isNotNull(sourceFileName)) {
984 extension = FileUtil.getExtension(sourceFileName);
985 }
986 else {
987 extension = fileEntry.getExtension();
988 }
989
990 try {
991 DLFileVersion latestFileVersion =
992 dlFileVersionLocalService.getLatestFileVersion(
993 groupId, folderId, name);
994
995 if (size == 0) {
996 size = latestFileVersion.getSize();
997 }
998
999 if (latestFileVersion.getStatus() !=
1000 WorkflowConstants.STATUS_APPROVED) {
1001
1002 serviceContext.setWorkflowAction(
1003 WorkflowConstants.ACTION_SAVE_DRAFT);
1004
1005 version = latestFileVersion.getVersion();
1006
1007 updateFileVersion(
1008 user, latestFileVersion, sourceFileName, extension, title,
1009 description, changeLog, extraSettings, version, size,
1010 latestFileVersion.getStatus(),
1011 serviceContext.getModifiedDate(now), serviceContext);
1012 }
1013 else {
1014 fileVersion = addFileVersion(
1015 user, fileEntry, serviceContext.getModifiedDate(now),
1016 extension, title, description, changeLog, extraSettings,
1017 version, size, WorkflowConstants.STATUS_DRAFT,
1018 serviceContext);
1019 }
1020
1021 if (fileVersion == null) {
1022 fileVersion = latestFileVersion;
1023 }
1024 }
1025 catch (NoSuchFileVersionException nsfve) {
1026 fileVersion = addFileVersion(
1027 user, fileEntry, serviceContext.getModifiedDate(now),
1028 extension, title, description, changeLog, extraSettings,
1029 version, size, WorkflowConstants.STATUS_DRAFT, serviceContext);
1030 }
1031
1032 if ((is == null) && !version.equals(fileEntry.getVersion())) {
1033 int fetchFailures = 0;
1034
1035 while (is == null) {
1036 try {
1037 is = dlLocalService.getFileAsStream(
1038 user.getCompanyId(), fileEntry.getRepositoryId(), name);
1039 }
1040 catch (NoSuchFileException nsfe) {
1041 fetchFailures++;
1042
1043 if (PropsValues.DL_HOOK_IMPL.equals(
1044 JCRHook.class.getName()) &&
1045 (fetchFailures <
1046 PropsValues.DL_HOOK_JCR_FETCH_MAX_FAILURES)) {
1047
1048 try {
1049 Thread.sleep(PropsValues.DL_HOOK_JCR_FETCH_DELAY);
1050 }
1051 catch (InterruptedException ie) {
1052 }
1053 }
1054 else {
1055 throw nsfe;
1056 }
1057 }
1058 }
1059 }
1060
1061
1062
1063 updateAsset(
1064 userId, fileEntry, fileVersion,
1065 serviceContext.getAssetCategoryIds(),
1066 serviceContext.getAssetTagNames());
1067
1068
1069
1070 if (fileEntry.getFolderId() !=
1071 DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
1072
1073 DLFolder folder = dlFolderPersistence.findByPrimaryKey(
1074 fileEntry.getFolderId());
1075
1076 folder.setLastPostDate(fileEntry.getModifiedDate());
1077
1078 dlFolderPersistence.update(folder, false);
1079 }
1080
1081
1082
1083 if (is != null) {
1084 try {
1085 dlService.deleteFile(
1086 user.getCompanyId(), PortletKeys.DOCUMENT_LIBRARY,
1087 fileEntry.getRepositoryId(), fileEntry.getName(), version);
1088 }
1089 catch (NoSuchFileException nsfe) {
1090 }
1091
1092 dlLocalService.updateFile(
1093 user.getCompanyId(), PortletKeys.DOCUMENT_LIBRARY,
1094 fileEntry.getGroupId(), fileEntry.getRepositoryId(), name,
1095 fileEntry.getExtension(), false, version, sourceFileName,
1096 fileEntry.getFileEntryId(), fileEntry.getLuceneProperties(),
1097 fileEntry.getModifiedDate(), serviceContext, is);
1098 }
1099
1100
1101
1102 WorkflowHandlerRegistryUtil.startWorkflowInstance(
1103 user.getCompanyId(), groupId, userId, DLFileEntry.class.getName(),
1104 fileEntry.getFileEntryId(), fileEntry, serviceContext);
1105
1106 return fileEntry;
1107 }
1108
1109 public DLFileEntry updateStatus(
1110 long userId, long fileEntryId, int status,
1111 ServiceContext serviceContext)
1112 throws PortalException, SystemException {
1113
1114
1115
1116 User user = userPersistence.findByPrimaryKey(userId);
1117
1118 DLFileEntry fileEntry = dlFileEntryPersistence.findByPrimaryKey(
1119 fileEntryId);
1120
1121
1122
1123 DLFileVersion latestFileVersion =
1124 dlFileVersionLocalService.getLatestFileVersion(
1125 fileEntry.getGroupId(), fileEntry.getFolderId(),
1126 fileEntry.getName());
1127
1128 latestFileVersion.setStatus(status);
1129 latestFileVersion.setStatusByUserId(user.getUserId());
1130 latestFileVersion.setStatusByUserName(user.getFullName());
1131 latestFileVersion.setStatusDate(new Date());
1132
1133 dlFileVersionPersistence.update(latestFileVersion, false);
1134
1135 if (status == WorkflowConstants.STATUS_APPROVED) {
1136
1137
1138
1139 if (DLUtil.compareVersions(
1140 fileEntry.getVersion(),
1141 latestFileVersion.getVersion()) < 0) {
1142
1143 fileEntry.setTitle(latestFileVersion.getTitle());
1144 fileEntry.setDescription(latestFileVersion.getDescription());
1145 fileEntry.setExtraSettings(
1146 latestFileVersion.getExtraSettings());
1147 fileEntry.setVersion(latestFileVersion.getVersion());
1148 fileEntry.setVersionUserId(latestFileVersion.getUserId());
1149 fileEntry.setVersionUserName(latestFileVersion.getUserName());
1150 fileEntry.setModifiedDate(latestFileVersion.getCreateDate());
1151 fileEntry.setSize(latestFileVersion.getSize());
1152
1153 dlFileEntryPersistence.update(fileEntry, false);
1154 }
1155
1156
1157
1158 if (fileEntry.getVersion().equals(latestFileVersion.getVersion())) {
1159 if ((latestFileVersion.getVersion() !=
1160 DLFileEntryConstants.DEFAULT_VERSION)) {
1161
1162 AssetEntry draftAssetEntry = null;
1163
1164 try {
1165 draftAssetEntry = assetEntryLocalService.getEntry(
1166 DLFileEntry.class.getName(),
1167 latestFileVersion.getPrimaryKey());
1168
1169 long[] assetCategoryIds =
1170 draftAssetEntry.getCategoryIds();
1171 String[] assetTagNames = draftAssetEntry.getTagNames();
1172
1173 assetEntryLocalService.updateEntry(
1174 userId, fileEntry.getGroupId(),
1175 DLFileEntry.class.getName(),
1176 fileEntry.getFileEntryId(), fileEntry.getUuid(),
1177 assetCategoryIds, assetTagNames, true, null, null,
1178 null, null, draftAssetEntry.getMimeType(),
1179 fileEntry.getTitle(), fileEntry.getDescription(),
1180 null, null, 0, 0, null, false);
1181
1182 assetEntryLocalService.deleteEntry(
1183 draftAssetEntry.getEntryId());
1184 }
1185 catch (NoSuchEntryException nsee) {
1186 }
1187 }
1188
1189 assetEntryLocalService.updateVisible(
1190 DLFileEntry.class.getName(), fileEntry.getFileEntryId(),
1191 true);
1192 }
1193
1194
1195
1196 socialActivityLocalService.addUniqueActivity(
1197 latestFileVersion.getUserId(), latestFileVersion.getGroupId(),
1198 latestFileVersion.getCreateDate(), DLFileEntry.class.getName(),
1199 fileEntryId, DLActivityKeys.ADD_FILE_ENTRY,
1200 StringPool.BLANK, 0);
1201
1202
1203
1204 Indexer indexer = IndexerRegistryUtil.getIndexer(DLFileEntry.class);
1205
1206 indexer.reindex(fileEntry);
1207 }
1208 else {
1209
1210
1211
1212 if (fileEntry.getVersion().equals(latestFileVersion.getVersion())) {
1213 String newVersion = DLFileEntryConstants.DEFAULT_VERSION;
1214
1215 List<DLFileVersion> approvedFileVersions =
1216 dlFileVersionPersistence.findByG_F_N_S(
1217 fileEntry.getGroupId(), fileEntry.getFolderId(),
1218 fileEntry.getName(), WorkflowConstants.STATUS_APPROVED);
1219
1220 if (!approvedFileVersions.isEmpty()) {
1221 newVersion = approvedFileVersions.get(0).getVersion();
1222 }
1223
1224 fileEntry.setVersion(newVersion);
1225
1226 dlFileEntryPersistence.update(fileEntry, false);
1227 }
1228
1229
1230
1231 if (Validator.isNull(fileEntry.getVersion())) {
1232 assetEntryLocalService.updateVisible(
1233 DLFileEntry.class.getName(), fileEntry.getFileEntryId(),
1234 false);
1235 }
1236
1237
1238
1239 if (latestFileVersion.getVersion().equals(
1240 DLFileEntryConstants.DEFAULT_VERSION)) {
1241
1242 Indexer indexer = IndexerRegistryUtil.getIndexer(
1243 DLFileEntry.class);
1244
1245 indexer.delete(fileEntry);
1246 }
1247 }
1248
1249 return fileEntry;
1250 }
1251
1252 protected DLFileVersion addFileVersion(
1253 User user, DLFileEntry fileEntry, Date modifiedDate,
1254 String extension, String title, String description,
1255 String changeLog, String extraSettings, String version, long size,
1256 int status, ServiceContext serviceContext)
1257 throws SystemException {
1258
1259 long fileVersionId = counterLocalService.increment();
1260
1261 DLFileVersion fileVersion = dlFileVersionPersistence.create(
1262 fileVersionId);
1263
1264 long versionUserId = fileEntry.getVersionUserId();
1265
1266 if (versionUserId <= 0) {
1267 versionUserId = fileEntry.getUserId();
1268 }
1269
1270 String versionUserName = GetterUtil.getString(
1271 fileEntry.getVersionUserName(), fileEntry.getUserName());
1272
1273 fileVersion.setGroupId(fileEntry.getGroupId());
1274 fileVersion.setCompanyId(fileEntry.getCompanyId());
1275 fileVersion.setUserId(versionUserId);
1276 fileVersion.setUserName(versionUserName);
1277 fileVersion.setCreateDate(modifiedDate);
1278 fileVersion.setFolderId(fileEntry.getFolderId());
1279 fileVersion.setName(fileEntry.getName());
1280 fileVersion.setExtension(extension);
1281 fileVersion.setTitle(title);
1282 fileVersion.setDescription(description);
1283 fileVersion.setChangeLog(changeLog);
1284 fileVersion.setExtraSettings(extraSettings);
1285 fileVersion.setVersion(version);
1286 fileVersion.setSize(size);
1287 fileVersion.setStatus(status);
1288 fileVersion.setStatusByUserId(user.getUserId());
1289 fileVersion.setStatusByUserName(user.getFullName());
1290 fileVersion.setStatusDate(fileEntry.getModifiedDate());
1291 fileVersion.setExpandoBridgeAttributes(serviceContext);
1292
1293 dlFileVersionPersistence.update(fileVersion, false);
1294
1295 return fileVersion;
1296 }
1297
1298 protected long getFolderId(long companyId, long folderId)
1299 throws SystemException {
1300
1301 if (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
1302
1303
1304
1305 DLFolder folder = dlFolderPersistence.fetchByPrimaryKey(folderId);
1306
1307 if ((folder == null) || (companyId != folder.getCompanyId())) {
1308 folderId = DLFolderConstants.DEFAULT_PARENT_FOLDER_ID;
1309 }
1310 }
1311
1312 return folderId;
1313 }
1314
1315 protected String getNextVersion(
1316 DLFileEntry fileEntry, boolean majorVersion, int workflowAction) {
1317
1318 if (Validator.isNull(fileEntry.getVersion())) {
1319 return DLFileEntryConstants.DEFAULT_VERSION;
1320 }
1321
1322 if (workflowAction == WorkflowConstants.ACTION_SAVE_DRAFT) {
1323 majorVersion = false;
1324 }
1325
1326 int[] versionParts = StringUtil.split(
1327 fileEntry.getVersion(), StringPool.PERIOD, 0);
1328
1329 if (majorVersion) {
1330 versionParts[0]++;
1331 versionParts[1] = 0;
1332 }
1333 else {
1334 versionParts[1]++;
1335 }
1336
1337 return versionParts[0] + StringPool.PERIOD + versionParts[1];
1338 }
1339
1340 protected void updateFileVersion(
1341 User user, DLFileVersion fileVersion, String sourceFileName,
1342 String extension, String title, String description,
1343 String changeLog, String extraSettings, String version, long size,
1344 int status, Date statusDate, ServiceContext serviceContext)
1345 throws SystemException {
1346
1347 if (Validator.isNotNull(sourceFileName)) {
1348 fileVersion.setExtension(extension);
1349 }
1350
1351 fileVersion.setTitle(title);
1352 fileVersion.setDescription(description);
1353 fileVersion.setChangeLog(changeLog);
1354 fileVersion.setExtraSettings(extraSettings);
1355 fileVersion.setVersion(version);
1356 fileVersion.setSize(size);
1357 fileVersion.setStatus(status);
1358 fileVersion.setStatusByUserId(user.getUserId());
1359 fileVersion.setStatusByUserName(user.getFullName());
1360 fileVersion.setStatusDate(statusDate);
1361 fileVersion.setExpandoBridgeAttributes(serviceContext);
1362
1363 dlFileVersionPersistence.update(fileVersion, false);
1364 }
1365
1366 protected void validate(
1367 long groupId, long folderId, String title, InputStream is)
1368 throws PortalException, SystemException {
1369
1370 dlLocalService.validate(title, true, is);
1371
1372 validate(groupId, folderId, null, title);
1373 }
1374
1375 protected void validate(
1376 long groupId, long folderId, String name, String title)
1377 throws PortalException, SystemException {
1378
1379 try {
1380 dlFolderLocalService.getFolder(groupId, folderId, title);
1381
1382 throw new DuplicateFolderNameException();
1383 }
1384 catch (NoSuchFolderException nsfe) {
1385 }
1386
1387 try {
1388 DLFileEntry fileEntry =
1389 dlFileEntryPersistence.findByG_F_T(groupId, folderId, title);
1390
1391 if (!fileEntry.getName().equals(name)) {
1392 throw new DuplicateFileException(title);
1393 }
1394 }
1395 catch (NoSuchFileEntryException nsfee) {
1396 }
1397 }
1398
1399 protected void validate(
1400 long groupId, long folderId, String name, String extension,
1401 String title, String sourceFileName, InputStream is)
1402 throws PortalException, SystemException {
1403
1404 if (Validator.isNotNull(sourceFileName)) {
1405 dlLocalService.validate(
1406 sourceFileName, extension, sourceFileName, true, is);
1407 }
1408
1409 validate(groupId, folderId, name, title);
1410 }
1411
1412 private static Log _log = LogFactoryUtil.getLog(
1413 DLFileEntryLocalServiceImpl.class);
1414
1415 }