001
014
015 package com.liferay.portlet.documentlibrary.service.impl;
016
017 import com.liferay.document.library.kernel.exception.DuplicateFileEntryException;
018 import com.liferay.document.library.kernel.exception.DuplicateFolderNameException;
019 import com.liferay.document.library.kernel.exception.FileExtensionException;
020 import com.liferay.document.library.kernel.exception.FileNameException;
021 import com.liferay.document.library.kernel.exception.ImageSizeException;
022 import com.liferay.document.library.kernel.exception.InvalidFileEntryTypeException;
023 import com.liferay.document.library.kernel.exception.InvalidFileVersionException;
024 import com.liferay.document.library.kernel.exception.NoSuchFileEntryException;
025 import com.liferay.document.library.kernel.model.DLFileEntry;
026 import com.liferay.document.library.kernel.model.DLFileEntryConstants;
027 import com.liferay.document.library.kernel.model.DLFileEntryMetadata;
028 import com.liferay.document.library.kernel.model.DLFileEntryType;
029 import com.liferay.document.library.kernel.model.DLFileVersion;
030 import com.liferay.document.library.kernel.model.DLFolder;
031 import com.liferay.document.library.kernel.model.DLFolderConstants;
032 import com.liferay.document.library.kernel.store.DLStoreUtil;
033 import com.liferay.document.library.kernel.util.DL;
034 import com.liferay.document.library.kernel.util.DLFileVersionPolicy;
035 import com.liferay.document.library.kernel.util.DLUtil;
036 import com.liferay.document.library.kernel.util.DLValidatorUtil;
037 import com.liferay.document.library.kernel.util.comparator.RepositoryModelModifiedDateComparator;
038 import com.liferay.dynamic.data.mapping.kernel.DDMFormValues;
039 import com.liferay.dynamic.data.mapping.kernel.DDMStructure;
040 import com.liferay.dynamic.data.mapping.kernel.DDMStructureManagerUtil;
041 import com.liferay.dynamic.data.mapping.kernel.StorageEngineManagerUtil;
042 import com.liferay.expando.kernel.model.ExpandoBridge;
043 import com.liferay.expando.kernel.model.ExpandoColumnConstants;
044 import com.liferay.expando.kernel.model.ExpandoRow;
045 import com.liferay.expando.kernel.model.ExpandoTable;
046 import com.liferay.expando.kernel.util.ExpandoBridgeUtil;
047 import com.liferay.exportimport.kernel.lar.ExportImportThreadLocal;
048 import com.liferay.portal.kernel.bean.BeanReference;
049 import com.liferay.portal.kernel.comment.CommentManagerUtil;
050 import com.liferay.portal.kernel.dao.orm.ActionableDynamicQuery;
051 import com.liferay.portal.kernel.dao.orm.DynamicQuery;
052 import com.liferay.portal.kernel.dao.orm.IndexableActionableDynamicQuery;
053 import com.liferay.portal.kernel.dao.orm.Property;
054 import com.liferay.portal.kernel.dao.orm.PropertyFactoryUtil;
055 import com.liferay.portal.kernel.dao.orm.QueryDefinition;
056 import com.liferay.portal.kernel.dao.orm.QueryUtil;
057 import com.liferay.portal.kernel.dao.orm.RestrictionsFactoryUtil;
058 import com.liferay.portal.kernel.exception.PortalException;
059 import com.liferay.portal.kernel.exception.SystemException;
060 import com.liferay.portal.kernel.image.ImageBag;
061 import com.liferay.portal.kernel.image.ImageToolUtil;
062 import com.liferay.portal.kernel.increment.BufferedIncrement;
063 import com.liferay.portal.kernel.increment.NumberIncrement;
064 import com.liferay.portal.kernel.interval.IntervalActionProcessor;
065 import com.liferay.portal.kernel.language.LanguageUtil;
066 import com.liferay.portal.kernel.lock.ExpiredLockException;
067 import com.liferay.portal.kernel.lock.InvalidLockException;
068 import com.liferay.portal.kernel.lock.Lock;
069 import com.liferay.portal.kernel.lock.LockManagerUtil;
070 import com.liferay.portal.kernel.lock.NoSuchLockException;
071 import com.liferay.portal.kernel.log.Log;
072 import com.liferay.portal.kernel.log.LogFactoryUtil;
073 import com.liferay.portal.kernel.model.Group;
074 import com.liferay.portal.kernel.model.Image;
075 import com.liferay.portal.kernel.model.ModelHintsUtil;
076 import com.liferay.portal.kernel.model.Repository;
077 import com.liferay.portal.kernel.model.ResourceConstants;
078 import com.liferay.portal.kernel.model.SystemEventConstants;
079 import com.liferay.portal.kernel.model.User;
080 import com.liferay.portal.kernel.repository.event.RepositoryEventTrigger;
081 import com.liferay.portal.kernel.repository.event.RepositoryEventType;
082 import com.liferay.portal.kernel.repository.model.FileEntry;
083 import com.liferay.portal.kernel.search.Document;
084 import com.liferay.portal.kernel.search.Field;
085 import com.liferay.portal.kernel.search.Hits;
086 import com.liferay.portal.kernel.search.Indexable;
087 import com.liferay.portal.kernel.search.IndexableType;
088 import com.liferay.portal.kernel.search.Indexer;
089 import com.liferay.portal.kernel.search.IndexerRegistryUtil;
090 import com.liferay.portal.kernel.search.SearchContext;
091 import com.liferay.portal.kernel.search.SearchException;
092 import com.liferay.portal.kernel.search.Sort;
093 import com.liferay.portal.kernel.security.auth.PrincipalThreadLocal;
094 import com.liferay.portal.kernel.service.ServiceContext;
095 import com.liferay.portal.kernel.systemevent.SystemEvent;
096 import com.liferay.portal.kernel.util.ArrayUtil;
097 import com.liferay.portal.kernel.util.Constants;
098 import com.liferay.portal.kernel.util.DateRange;
099 import com.liferay.portal.kernel.util.FileUtil;
100 import com.liferay.portal.kernel.util.GetterUtil;
101 import com.liferay.portal.kernel.util.OrderByComparator;
102 import com.liferay.portal.kernel.util.ParamUtil;
103 import com.liferay.portal.kernel.util.PortalUtil;
104 import com.liferay.portal.kernel.util.PropsKeys;
105 import com.liferay.portal.kernel.util.StringBundler;
106 import com.liferay.portal.kernel.util.StringPool;
107 import com.liferay.portal.kernel.util.StringUtil;
108 import com.liferay.portal.kernel.util.UnicodeProperties;
109 import com.liferay.portal.kernel.util.Validator;
110 import com.liferay.portal.kernel.workflow.WorkflowConstants;
111 import com.liferay.portal.repository.liferayrepository.model.LiferayFileEntry;
112 import com.liferay.portal.repository.liferayrepository.model.LiferayFileVersion;
113 import com.liferay.portal.util.PrefsPropsUtil;
114 import com.liferay.portal.util.PropsValues;
115 import com.liferay.portal.util.RepositoryUtil;
116 import com.liferay.portlet.documentlibrary.model.impl.DLFileEntryImpl;
117 import com.liferay.portlet.documentlibrary.service.base.DLFileEntryLocalServiceBaseImpl;
118 import com.liferay.portlet.documentlibrary.util.DLAppUtil;
119
120 import java.awt.image.RenderedImage;
121
122 import java.io.File;
123 import java.io.IOException;
124 import java.io.InputStream;
125 import java.io.Serializable;
126
127 import java.util.ArrayList;
128 import java.util.Collections;
129 import java.util.Date;
130 import java.util.HashMap;
131 import java.util.List;
132 import java.util.Map;
133
134
152 public class DLFileEntryLocalServiceImpl
153 extends DLFileEntryLocalServiceBaseImpl {
154
155 @Override
156 public DLFileEntry addFileEntry(
157 long userId, long groupId, long repositoryId, long folderId,
158 String sourceFileName, String mimeType, String title,
159 String description, String changeLog, long fileEntryTypeId,
160 Map<String, DDMFormValues> ddmFormValuesMap, File file,
161 InputStream is, long size, ServiceContext serviceContext)
162 throws PortalException {
163
164 if (Validator.isNull(title)) {
165 throw new FileNameException("Title is null");
166 }
167
168
169
170 User user = userPersistence.findByPrimaryKey(userId);
171 folderId = dlFolderLocalService.getFolderId(
172 user.getCompanyId(), folderId);
173 String name = String.valueOf(
174 counterLocalService.increment(DLFileEntry.class.getName()));
175 String extension = DLAppUtil.getExtension(title, sourceFileName);
176
177 String fileName = DLUtil.getSanitizedFileName(title, extension);
178
179 if (fileEntryTypeId == -1) {
180 fileEntryTypeId =
181 dlFileEntryTypeLocalService.getDefaultFileEntryTypeId(folderId);
182 }
183
184 validateFileEntryTypeId(
185 PortalUtil.getCurrentAndAncestorSiteGroupIds(groupId), folderId,
186 fileEntryTypeId);
187
188 validateFile(
189 groupId, folderId, 0, sourceFileName, fileName, extension, title);
190
191 long fileEntryId = counterLocalService.increment();
192
193 DLFileEntry dlFileEntry = dlFileEntryPersistence.create(fileEntryId);
194
195 dlFileEntry.setUuid(serviceContext.getUuid());
196 dlFileEntry.setGroupId(groupId);
197 dlFileEntry.setCompanyId(user.getCompanyId());
198 dlFileEntry.setUserId(user.getUserId());
199 dlFileEntry.setUserName(user.getFullName());
200
201 DLFolder repositoryDLFolder = null;
202
203 if (repositoryId != groupId) {
204 Repository repository = repositoryLocalService.getRepository(
205 repositoryId);
206
207 repositoryDLFolder = dlFolderPersistence.findByPrimaryKey(
208 repository.getDlFolderId());
209 }
210
211 long classNameId = 0;
212 long classPK = 0;
213
214 if ((repositoryDLFolder != null) && repositoryDLFolder.isHidden()) {
215 classNameId = classNameLocalService.getClassNameId(
216 (String)serviceContext.getAttribute("className"));
217 classPK = ParamUtil.getLong(serviceContext, "classPK");
218 }
219
220 dlFileEntry.setClassNameId(classNameId);
221 dlFileEntry.setClassPK(classPK);
222 dlFileEntry.setRepositoryId(repositoryId);
223 dlFileEntry.setFolderId(folderId);
224 dlFileEntry.setTreePath(dlFileEntry.buildTreePath());
225 dlFileEntry.setName(name);
226 dlFileEntry.setFileName(fileName);
227 dlFileEntry.setExtension(extension);
228 dlFileEntry.setMimeType(mimeType);
229 dlFileEntry.setTitle(title);
230 dlFileEntry.setDescription(description);
231 dlFileEntry.setFileEntryTypeId(fileEntryTypeId);
232 dlFileEntry.setVersion(DLFileEntryConstants.VERSION_DEFAULT);
233 dlFileEntry.setSize(size);
234 dlFileEntry.setReadCount(DLFileEntryConstants.DEFAULT_READ_COUNT);
235
236 dlFileEntryPersistence.update(dlFileEntry);
237
238
239
240 addFileEntryResources(dlFileEntry, serviceContext);
241
242
243
244 addFileVersion(
245 user, dlFileEntry, fileName, extension, mimeType, title,
246 description, changeLog, StringPool.BLANK, fileEntryTypeId,
247 ddmFormValuesMap, DLFileEntryConstants.VERSION_DEFAULT, size,
248 WorkflowConstants.STATUS_DRAFT, serviceContext);
249
250
251
252 if (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
253 dlFolderLocalService.updateLastPostDate(
254 dlFileEntry.getFolderId(), dlFileEntry.getModifiedDate());
255 }
256
257
258
259 if (file != null) {
260 DLStoreUtil.addFile(
261 user.getCompanyId(), dlFileEntry.getDataRepositoryId(), name,
262 false, file);
263 }
264 else {
265 DLStoreUtil.addFile(
266 user.getCompanyId(), dlFileEntry.getDataRepositoryId(), name,
267 false, is);
268 }
269
270 return dlFileEntry;
271 }
272
273 @Override
274 public DLFileVersion cancelCheckOut(long userId, long fileEntryId)
275 throws PortalException {
276
277 if (!isFileEntryCheckedOut(fileEntryId)) {
278 return null;
279 }
280
281 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
282 fileEntryId);
283
284 DLFileVersion dlFileVersion =
285 dlFileVersionLocalService.getLatestFileVersion(fileEntryId, false);
286
287 removeFileVersion(dlFileEntry, dlFileVersion);
288
289 return dlFileVersion;
290 }
291
292 @Override
293 public void checkInFileEntry(
294 long userId, long fileEntryId, boolean majorVersion,
295 String changeLog, ServiceContext serviceContext)
296 throws PortalException {
297
298 if (!isFileEntryCheckedOut(fileEntryId)) {
299 return;
300 }
301
302 User user = userPersistence.findByPrimaryKey(userId);
303
304 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
305 fileEntryId);
306
307 boolean webDAVCheckInMode = GetterUtil.getBoolean(
308 serviceContext.getAttribute(DL.WEBDAV_CHECK_IN_MODE));
309
310 boolean manualCheckInRequired = dlFileEntry.getManualCheckInRequired();
311
312 if (!webDAVCheckInMode && manualCheckInRequired) {
313 dlFileEntry.setManualCheckInRequired(false);
314
315 dlFileEntryPersistence.update(dlFileEntry);
316 }
317
318 DLFileVersion lastDLFileVersion =
319 dlFileVersionLocalService.getFileVersion(
320 dlFileEntry.getFileEntryId(), dlFileEntry.getVersion());
321
322 DLFileVersion latestDLFileVersion =
323 dlFileVersionLocalService.getLatestFileVersion(fileEntryId, false);
324
325 if (dlFileVersionPolicy.isKeepFileVersionLabel(
326 lastDLFileVersion, latestDLFileVersion, majorVersion,
327 serviceContext)) {
328
329 if (lastDLFileVersion.getSize() != latestDLFileVersion.getSize()) {
330
331
332
333 dlFileEntry.setExtension(latestDLFileVersion.getExtension());
334 dlFileEntry.setMimeType(latestDLFileVersion.getMimeType());
335 dlFileEntry.setSize(latestDLFileVersion.getSize());
336
337 dlFileEntryPersistence.update(dlFileEntry);
338
339
340
341 lastDLFileVersion.setExtension(
342 latestDLFileVersion.getExtension());
343 lastDLFileVersion.setMimeType(
344 latestDLFileVersion.getMimeType());
345 lastDLFileVersion.setSize(latestDLFileVersion.getSize());
346
347 dlFileVersionPersistence.update(lastDLFileVersion);
348
349
350
351 DLStoreUtil.deleteFile(
352 user.getCompanyId(), dlFileEntry.getDataRepositoryId(),
353 dlFileEntry.getName(), lastDLFileVersion.getVersion());
354
355 DLStoreUtil.copyFileVersion(
356 user.getCompanyId(), dlFileEntry.getDataRepositoryId(),
357 dlFileEntry.getName(),
358 DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION,
359 lastDLFileVersion.getVersion());
360 }
361
362
363
364 removeFileVersion(dlFileEntry, latestDLFileVersion);
365 }
366 else {
367
368
369
370 String version = getNextVersion(
371 dlFileEntry, majorVersion, serviceContext.getWorkflowAction());
372
373 latestDLFileVersion.setVersion(version);
374 latestDLFileVersion.setChangeLog(changeLog);
375
376 dlFileVersionPersistence.update(latestDLFileVersion);
377
378
379
380 if (dlFileEntry.getFolderId() !=
381 DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
382
383 dlFolderLocalService.updateLastPostDate(
384 dlFileEntry.getFolderId(),
385 latestDLFileVersion.getModifiedDate());
386 }
387
388
389
390 DLStoreUtil.updateFileVersion(
391 user.getCompanyId(), dlFileEntry.getDataRepositoryId(),
392 dlFileEntry.getName(),
393 DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION, version);
394 }
395
396 unlockFileEntry(fileEntryId);
397 }
398
399 @Override
400 public void checkInFileEntry(
401 long userId, long fileEntryId, String lockUuid,
402 ServiceContext serviceContext)
403 throws PortalException {
404
405 if (Validator.isNotNull(lockUuid)) {
406 try {
407 Lock lock = LockManagerUtil.getLock(
408 DLFileEntry.class.getName(), fileEntryId);
409
410 if (!Validator.equals(lock.getUuid(), lockUuid)) {
411 throw new InvalidLockException("UUIDs do not match");
412 }
413 }
414 catch (PortalException pe) {
415 if ((pe instanceof ExpiredLockException) ||
416 (pe instanceof NoSuchLockException)) {
417 }
418 else {
419 throw pe;
420 }
421 }
422 }
423
424 checkInFileEntry(
425 userId, fileEntryId, false, StringPool.BLANK, serviceContext);
426 }
427
428 @Override
429 public DLFileEntry checkOutFileEntry(
430 long userId, long fileEntryId, ServiceContext serviceContext)
431 throws PortalException {
432
433 return checkOutFileEntry(
434 userId, fileEntryId, StringPool.BLANK,
435 DLFileEntryImpl.LOCK_EXPIRATION_TIME, serviceContext);
436 }
437
438 @Override
439 public DLFileEntry checkOutFileEntry(
440 long userId, long fileEntryId, String owner, long expirationTime,
441 ServiceContext serviceContext)
442 throws PortalException {
443
444 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
445 fileEntryId);
446
447 boolean hasLock = hasFileEntryLock(userId, fileEntryId);
448
449 if (!hasLock) {
450 if ((expirationTime <= 0) ||
451 (expirationTime > DLFileEntryImpl.LOCK_EXPIRATION_TIME)) {
452
453 expirationTime = DLFileEntryImpl.LOCK_EXPIRATION_TIME;
454 }
455
456 LockManagerUtil.lock(
457 userId, DLFileEntry.class.getName(), fileEntryId, owner, false,
458 expirationTime);
459 }
460
461 User user = userPersistence.findByPrimaryKey(userId);
462
463 serviceContext.setCompanyId(user.getCompanyId());
464
465 DLFileVersion dlFileVersion =
466 dlFileVersionLocalService.getLatestFileVersion(fileEntryId, false);
467
468 long dlFileVersionId = dlFileVersion.getFileVersionId();
469
470 serviceContext.setUserId(userId);
471
472 boolean manualCheckinRequired = GetterUtil.getBoolean(
473 serviceContext.getAttribute(DL.MANUAL_CHECK_IN_REQUIRED));
474
475 dlFileEntry.setManualCheckInRequired(manualCheckinRequired);
476
477 dlFileEntryPersistence.update(dlFileEntry);
478
479 String version = dlFileVersion.getVersion();
480
481 if (!version.equals(
482 DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION)) {
483
484 long existingDLFileVersionId = ParamUtil.getLong(
485 serviceContext, "existingDLFileVersionId");
486
487 if (existingDLFileVersionId > 0) {
488 DLFileVersion existingDLFileVersion =
489 dlFileVersionPersistence.findByPrimaryKey(
490 existingDLFileVersionId);
491
492 dlFileVersion = updateFileVersion(
493 user, existingDLFileVersion, null,
494 existingDLFileVersion.getFileName(),
495 existingDLFileVersion.getExtension(),
496 existingDLFileVersion.getMimeType(),
497 existingDLFileVersion.getTitle(),
498 existingDLFileVersion.getDescription(),
499 existingDLFileVersion.getChangeLog(),
500 existingDLFileVersion.getExtraSettings(),
501 existingDLFileVersion.getFileEntryTypeId(), null,
502 DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION,
503 existingDLFileVersion.getSize(),
504 WorkflowConstants.STATUS_DRAFT,
505 serviceContext.getModifiedDate(null), serviceContext);
506 }
507 else {
508 long oldDLFileVersionId = dlFileVersion.getFileVersionId();
509
510 dlFileVersion = addFileVersion(
511 user, dlFileEntry, dlFileVersion.getFileName(),
512 dlFileVersion.getExtension(), dlFileVersion.getMimeType(),
513 dlFileVersion.getTitle(), dlFileVersion.getDescription(),
514 dlFileVersion.getChangeLog(),
515 dlFileVersion.getExtraSettings(),
516 dlFileVersion.getFileEntryTypeId(), null,
517 DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION,
518 dlFileVersion.getSize(), WorkflowConstants.STATUS_DRAFT,
519 serviceContext);
520
521 copyExpandoRowModifiedDate(
522 dlFileEntry.getCompanyId(), oldDLFileVersionId,
523 dlFileVersion.getFileVersionId());
524 }
525
526 if (DLStoreUtil.hasFile(
527 dlFileEntry.getCompanyId(),
528 dlFileEntry.getDataRepositoryId(), dlFileEntry.getName(),
529 DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION)) {
530
531 DLStoreUtil.deleteFile(
532 dlFileEntry.getCompanyId(),
533 dlFileEntry.getDataRepositoryId(), dlFileEntry.getName(),
534 DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION);
535 }
536
537 DLStoreUtil.copyFileVersion(
538 user.getCompanyId(), dlFileEntry.getDataRepositoryId(),
539 dlFileEntry.getName(), version,
540 DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION);
541
542 serviceContext.setAttribute("validateDDMFormValues", Boolean.FALSE);
543
544 copyFileEntryMetadata(
545 dlFileEntry.getCompanyId(), dlFileVersion.getFileEntryTypeId(),
546 fileEntryId, dlFileVersionId, dlFileVersion.getFileVersionId(),
547 serviceContext);
548
549 serviceContext.setAttribute("validateDDMFormValues", Boolean.TRUE);
550 }
551
552 return dlFileEntry;
553 }
554
555 @Override
556 public void convertExtraSettings(final String[] keys)
557 throws PortalException {
558
559 int total = dlFileEntryFinder.countByExtraSettings();
560
561 final IntervalActionProcessor<Void> intervalActionProcessor =
562 new IntervalActionProcessor<>(total);
563
564 intervalActionProcessor.setPerformIntervalActionMethod(
565 new IntervalActionProcessor.PerformIntervalActionMethod<Void>() {
566
567 @Override
568 public Void performIntervalAction(int start, int end)
569 throws PortalException {
570
571 List<DLFileEntry> dlFileEntries =
572 dlFileEntryFinder.findByExtraSettings(start, end);
573
574 for (DLFileEntry dlFileEntry : dlFileEntries) {
575 convertExtraSettings(dlFileEntry, keys);
576 }
577
578 intervalActionProcessor.incrementStart(
579 dlFileEntries.size());
580
581 return null;
582 }
583
584 });
585
586 intervalActionProcessor.performIntervalActions();
587 }
588
589 @Override
590 public DLFileEntry copyFileEntry(
591 long userId, long groupId, long repositoryId, long fileEntryId,
592 long destFolderId, ServiceContext serviceContext)
593 throws PortalException {
594
595 DLFileEntry dlFileEntry = getFileEntry(fileEntryId);
596
597 String sourceFileName = "A";
598
599 String extension = dlFileEntry.getExtension();
600
601 if (Validator.isNotNull(extension)) {
602 sourceFileName = sourceFileName.concat(StringPool.PERIOD).concat(
603 extension);
604 }
605
606 InputStream inputStream = DLStoreUtil.getFileAsStream(
607 dlFileEntry.getCompanyId(), dlFileEntry.getDataRepositoryId(),
608 dlFileEntry.getName());
609
610 DLFileEntry newDlFileEntry = addFileEntry(
611 userId, groupId, repositoryId, destFolderId, sourceFileName,
612 dlFileEntry.getMimeType(), dlFileEntry.getTitle(),
613 dlFileEntry.getDescription(), null,
614 dlFileEntry.getFileEntryTypeId(), null, null, inputStream,
615 dlFileEntry.getSize(), serviceContext);
616
617 DLFileVersion dlFileVersion = dlFileEntry.getFileVersion();
618
619 DLFileVersion newDlFileVersion = newDlFileEntry.getFileVersion();
620
621 ExpandoBridgeUtil.copyExpandoBridgeAttributes(
622 dlFileVersion.getExpandoBridge(),
623 newDlFileVersion.getExpandoBridge());
624
625 copyFileEntryMetadata(
626 dlFileVersion.getCompanyId(), dlFileVersion.getFileEntryTypeId(),
627 fileEntryId, dlFileVersion.getFileVersionId(),
628 newDlFileVersion.getFileVersionId(), serviceContext);
629
630 return newDlFileEntry;
631 }
632
633 @Override
634 public void copyFileEntryMetadata(
635 long companyId, long fileEntryTypeId, long fileEntryId,
636 long fromFileVersionId, long toFileVersionId,
637 ServiceContext serviceContext)
638 throws PortalException {
639
640 Map<String, DDMFormValues> ddmFormValuesMap = new HashMap<>();
641
642 List<DDMStructure> ddmStructures = null;
643
644 if (fileEntryTypeId > 0) {
645 DLFileEntryType dlFileEntryType =
646 dlFileEntryTypeLocalService.getFileEntryType(fileEntryTypeId);
647
648 ddmStructures = dlFileEntryType.getDDMStructures();
649 }
650 else {
651 long classNameId = classNameLocalService.getClassNameId(
652 DLFileEntryMetadata.class);
653
654 ddmStructures = DDMStructureManagerUtil.getClassStructures(
655 companyId, classNameId);
656 }
657
658 copyFileEntryMetadata(
659 companyId, fileEntryId, fromFileVersionId, toFileVersionId,
660 serviceContext, ddmFormValuesMap, ddmStructures);
661 }
662
663 @Override
664 public void deleteFileEntries(long groupId, long folderId)
665 throws PortalException {
666
667 deleteFileEntries(groupId, folderId, true);
668 }
669
670 @Override
671 public void deleteFileEntries(
672 long groupId, final long folderId,
673 final boolean includeTrashedEntries)
674 throws PortalException {
675
676 final RepositoryEventTrigger repositoryEventTrigger =
677 getFolderRepositoryEventTrigger(groupId, folderId);
678
679 ActionableDynamicQuery actionableDynamicQuery =
680 dlFileEntryLocalService.getActionableDynamicQuery();
681
682 actionableDynamicQuery.setAddCriteriaMethod(
683 new ActionableDynamicQuery.AddCriteriaMethod() {
684
685 @Override
686 public void addCriteria(DynamicQuery dynamicQuery) {
687 Property folderIdproperty = PropertyFactoryUtil.forName(
688 "folderId");
689
690 dynamicQuery.add(folderIdproperty.eq(folderId));
691 }
692
693 });
694 actionableDynamicQuery.setGroupId(groupId);
695 actionableDynamicQuery.setPerformActionMethod(
696 new ActionableDynamicQuery.PerformActionMethod<DLFileEntry>() {
697
698 @Override
699 public void performAction(DLFileEntry dlFileEntry)
700 throws PortalException {
701
702 if (includeTrashedEntries ||
703 !dlFileEntry.isInTrashExplicitly()) {
704
705 repositoryEventTrigger.trigger(
706 RepositoryEventType.Delete.class, FileEntry.class,
707 new LiferayFileEntry(dlFileEntry));
708
709 dlFileEntryLocalService.deleteFileEntry(dlFileEntry);
710 }
711 }
712
713 });
714
715 actionableDynamicQuery.performActions();
716 }
717
718 @Indexable(type = IndexableType.DELETE)
719 @Override
720 @SystemEvent(
721 action = SystemEventConstants.ACTION_SKIP,
722 type = SystemEventConstants.TYPE_DELETE
723 )
724 public DLFileEntry deleteFileEntry(DLFileEntry dlFileEntry)
725 throws PortalException {
726
727
728
729 dlFileEntryPersistence.remove(dlFileEntry);
730
731
732
733 resourceLocalService.deleteResource(
734 dlFileEntry.getCompanyId(), DLFileEntry.class.getName(),
735 ResourceConstants.SCOPE_INDIVIDUAL, dlFileEntry.getFileEntryId());
736
737
738
739 webDAVPropsLocalService.deleteWebDAVProps(
740 DLFileEntry.class.getName(), dlFileEntry.getFileEntryId());
741
742
743
744 dlFileEntryMetadataLocalService.deleteFileEntryMetadata(
745 dlFileEntry.getFileEntryId());
746
747
748
749 List<DLFileVersion> dlFileVersions =
750 dlFileVersionPersistence.findByFileEntryId(
751 dlFileEntry.getFileEntryId());
752
753 for (DLFileVersion dlFileVersion : dlFileVersions) {
754 dlFileVersionPersistence.remove(dlFileVersion);
755
756 expandoRowLocalService.deleteRows(dlFileVersion.getFileVersionId());
757
758 workflowInstanceLinkLocalService.deleteWorkflowInstanceLinks(
759 dlFileEntry.getCompanyId(), dlFileEntry.getGroupId(),
760 DLFileEntry.class.getName(), dlFileVersion.getFileVersionId());
761 }
762
763
764
765 expandoRowLocalService.deleteRows(dlFileEntry.getFileEntryId());
766
767
768
769 ratingsStatsLocalService.deleteStats(
770 DLFileEntry.class.getName(), dlFileEntry.getFileEntryId());
771
772
773
774 unlockFileEntry(dlFileEntry.getFileEntryId());
775
776
777
778 try {
779 DLStoreUtil.deleteFile(
780 dlFileEntry.getCompanyId(), dlFileEntry.getDataRepositoryId(),
781 dlFileEntry.getName());
782 }
783 catch (Exception e) {
784 if (_log.isWarnEnabled()) {
785 _log.warn(e, e);
786 }
787 }
788
789 return dlFileEntry;
790 }
791
792 @Indexable(type = IndexableType.DELETE)
793 @Override
794 public DLFileEntry deleteFileEntry(long fileEntryId)
795 throws PortalException {
796
797 DLFileEntry dlFileEntry = getFileEntry(fileEntryId);
798
799 return dlFileEntryLocalService.deleteFileEntry(dlFileEntry);
800 }
801
802 @Indexable(type = IndexableType.DELETE)
803 @Override
804 public DLFileEntry deleteFileEntry(long userId, long fileEntryId)
805 throws PortalException {
806
807 if (!hasFileEntryLock(userId, fileEntryId)) {
808 lockFileEntry(userId, fileEntryId);
809 }
810
811 try {
812 return dlFileEntryLocalService.deleteFileEntry(fileEntryId);
813 }
814 finally {
815 unlockFileEntry(fileEntryId);
816 }
817 }
818
819 @Indexable(type = IndexableType.REINDEX)
820 @Override
821 public DLFileEntry deleteFileVersion(
822 long userId, long fileEntryId, String version)
823 throws PortalException {
824
825 if (Validator.isNull(version)) {
826 throw new InvalidFileVersionException("Version is null");
827 }
828
829 if (version.equals(DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION)) {
830 throw new InvalidFileVersionException(
831 "Unable to delete a private working copy file version");
832 }
833
834 if (!hasFileEntryLock(userId, fileEntryId)) {
835 lockFileEntry(userId, fileEntryId);
836 }
837
838 boolean latestVersion = false;
839
840 DLFileEntry dlFileEntry = null;
841
842 try {
843 DLFileVersion dlFileVersion = dlFileVersionPersistence.findByF_V(
844 fileEntryId, version);
845
846 if (!dlFileVersion.isApproved()) {
847 throw new InvalidFileVersionException(
848 "Cannot delete an unapproved file version");
849 }
850 else {
851 int count = dlFileVersionPersistence.countByF_S(
852 fileEntryId, WorkflowConstants.STATUS_APPROVED);
853
854 if (count <= 1) {
855 throw new InvalidFileVersionException(
856 "Cannot delete the only approved file version");
857 }
858 }
859
860 dlFileVersionPersistence.remove(dlFileVersion);
861
862 expandoRowLocalService.deleteRows(dlFileVersion.getFileVersionId());
863
864 dlFileEntryMetadataLocalService.deleteFileVersionFileEntryMetadata(
865 dlFileVersion.getFileVersionId());
866
867 workflowInstanceLinkLocalService.deleteWorkflowInstanceLinks(
868 dlFileVersion.getCompanyId(), dlFileVersion.getGroupId(),
869 DLFileEntryConstants.getClassName(),
870 dlFileVersion.getFileVersionId());
871
872 dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(fileEntryId);
873
874 latestVersion = version.equals(dlFileEntry.getVersion());
875
876 if (latestVersion) {
877 DLFileVersion dlLatestFileVersion =
878 dlFileVersionLocalService.fetchLatestFileVersion(
879 dlFileEntry.getFileEntryId(), true);
880
881 if (dlLatestFileVersion != null) {
882 long fileEntryTypeId = getValidFileEntryTypeId(
883 dlLatestFileVersion.getFileEntryTypeId(), dlFileEntry);
884
885 dlLatestFileVersion.setModifiedDate(new Date());
886 dlLatestFileVersion.setFileEntryTypeId(fileEntryTypeId);
887 dlLatestFileVersion.setStatusDate(new Date());
888
889 dlFileVersionPersistence.update(dlLatestFileVersion);
890
891 dlFileEntry.setModifiedDate(new Date());
892 dlFileEntry.setFileName(dlLatestFileVersion.getFileName());
893 dlFileEntry.setExtension(
894 dlLatestFileVersion.getExtension());
895 dlFileEntry.setMimeType(dlLatestFileVersion.getMimeType());
896 dlFileEntry.setTitle(dlLatestFileVersion.getTitle());
897 dlFileEntry.setDescription(
898 dlLatestFileVersion.getDescription());
899 dlFileEntry.setExtraSettings(
900 dlLatestFileVersion.getExtraSettings());
901 dlFileEntry.setFileEntryTypeId(fileEntryTypeId);
902 dlFileEntry.setVersion(dlLatestFileVersion.getVersion());
903 dlFileEntry.setSize(dlLatestFileVersion.getSize());
904
905 dlFileEntry = dlFileEntryPersistence.update(dlFileEntry);
906 }
907 }
908
909 DLStoreUtil.deleteFile(
910 dlFileEntry.getCompanyId(), dlFileEntry.getDataRepositoryId(),
911 dlFileEntry.getName(), version);
912 }
913 finally {
914 unlockFileEntry(fileEntryId);
915 }
916
917 if (latestVersion) {
918 return dlFileEntry;
919 }
920
921 return null;
922 }
923
924 @Override
925 public void deleteRepositoryFileEntries(long repositoryId, long folderId)
926 throws PortalException {
927
928 deleteRepositoryFileEntries(repositoryId, folderId, true);
929 }
930
931 @Override
932 public void deleteRepositoryFileEntries(
933 final long repositoryId, final long folderId,
934 final boolean includeTrashedEntries)
935 throws PortalException {
936
937 final RepositoryEventTrigger repositoryEventTrigger =
938 RepositoryUtil.getRepositoryEventTrigger(repositoryId);
939
940 int total = dlFileEntryPersistence.countByR_F(repositoryId, folderId);
941
942 final IntervalActionProcessor<Void> intervalActionProcessor =
943 new IntervalActionProcessor<>(total);
944
945 intervalActionProcessor.setPerformIntervalActionMethod(
946 new IntervalActionProcessor.PerformIntervalActionMethod<Void>() {
947
948 @Override
949 public Void performIntervalAction(int start, int end)
950 throws PortalException {
951
952 List<DLFileEntry> dlFileEntries =
953 dlFileEntryPersistence.findByR_F(
954 repositoryId, folderId, start, end);
955
956 for (DLFileEntry dlFileEntry : dlFileEntries) {
957 if (includeTrashedEntries ||
958 !dlFileEntry.isInTrashExplicitly()) {
959
960 repositoryEventTrigger.trigger(
961 RepositoryEventType.Delete.class,
962 FileEntry.class,
963 new LiferayFileEntry(dlFileEntry));
964
965 dlFileEntryLocalService.deleteFileEntry(
966 dlFileEntry);
967 }
968 else {
969 intervalActionProcessor.incrementStart();
970 }
971 }
972
973 return null;
974 }
975
976 });
977
978 intervalActionProcessor.performIntervalActions();
979 }
980
981 @Override
982 public DLFileEntry fetchFileEntry(
983 long groupId, long folderId, String title) {
984
985 return dlFileEntryPersistence.fetchByG_F_T(groupId, folderId, title);
986 }
987
988 @Override
989 public DLFileEntry fetchFileEntryByAnyImageId(long imageId) {
990 return dlFileEntryFinder.fetchByAnyImageId(imageId);
991 }
992
993 @Override
994 public DLFileEntry fetchFileEntryByFileName(
995 long groupId, long folderId, String fileName) {
996
997 return dlFileEntryPersistence.fetchByG_F_FN(
998 groupId, folderId, fileName);
999 }
1000
1001 @Override
1002 public DLFileEntry fetchFileEntryByName(
1003 long groupId, long folderId, String name) {
1004
1005 return dlFileEntryPersistence.fetchByG_F_N(groupId, folderId, name);
1006 }
1007
1008 @Override
1009 public List<DLFileEntry> getDDMStructureFileEntries(
1010 long groupId, long[] ddmStructureIds) {
1011
1012 return dlFileEntryFinder.findByDDMStructureIds(
1013 groupId, ddmStructureIds, QueryUtil.ALL_POS, QueryUtil.ALL_POS);
1014 }
1015
1016 @Override
1017 public List<DLFileEntry> getDDMStructureFileEntries(
1018 long[] ddmStructureIds) {
1019
1020 return dlFileEntryFinder.findByDDMStructureIds(
1021 ddmStructureIds, QueryUtil.ALL_POS, QueryUtil.ALL_POS);
1022 }
1023
1024 @Override
1025 public List<DLFileEntry> getExtraSettingsFileEntries(int start, int end) {
1026 return dlFileEntryFinder.findByExtraSettings(start, end);
1027 }
1028
1029 @Override
1030 public int getExtraSettingsFileEntriesCount() {
1031 return dlFileEntryFinder.countByExtraSettings();
1032 }
1033
1034
1038 @Deprecated
1039 @Override
1040 public File getFile(
1041 long userId, long fileEntryId, String version,
1042 boolean incrementCounter)
1043 throws PortalException {
1044
1045 return getFile(fileEntryId, version, incrementCounter, 1);
1046 }
1047
1048
1052 @Deprecated
1053 @Override
1054 public File getFile(
1055 long userId, long fileEntryId, String version,
1056 boolean incrementCounter, int increment)
1057 throws PortalException {
1058
1059 return getFile(fileEntryId, version, incrementCounter, increment);
1060 }
1061
1062 @Override
1063 public File getFile(
1064 long fileEntryId, String version, boolean incrementCounter)
1065 throws PortalException {
1066
1067 return getFile(fileEntryId, version, incrementCounter, 1);
1068 }
1069
1070 @Override
1071 public File getFile(
1072 long fileEntryId, String version, boolean incrementCounter,
1073 int increment)
1074 throws PortalException {
1075
1076 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
1077 fileEntryId);
1078
1079 if (incrementCounter) {
1080 dlFileEntryLocalService.incrementViewCounter(
1081 dlFileEntry, increment);
1082 }
1083
1084 return DLStoreUtil.getFile(
1085 dlFileEntry.getCompanyId(), dlFileEntry.getDataRepositoryId(),
1086 dlFileEntry.getName(), version);
1087 }
1088
1089
1093 @Deprecated
1094 @Override
1095 public InputStream getFileAsStream(
1096 long userId, long fileEntryId, String version)
1097 throws PortalException {
1098
1099 return getFileAsStream(fileEntryId, version, true, 1);
1100 }
1101
1102
1106 @Deprecated
1107 @Override
1108 public InputStream getFileAsStream(
1109 long userId, long fileEntryId, String version,
1110 boolean incrementCounter)
1111 throws PortalException {
1112
1113 return getFileAsStream(fileEntryId, version, incrementCounter, 1);
1114 }
1115
1116
1120 @Deprecated
1121 @Override
1122 public InputStream getFileAsStream(
1123 long userId, long fileEntryId, String version,
1124 boolean incrementCounter, int increment)
1125 throws PortalException {
1126
1127 return getFileAsStream(
1128 fileEntryId, version, incrementCounter, increment);
1129 }
1130
1131 @Override
1132 public InputStream getFileAsStream(long fileEntryId, String version)
1133 throws PortalException {
1134
1135 return getFileAsStream(fileEntryId, version, true, 1);
1136 }
1137
1138 @Override
1139 public InputStream getFileAsStream(
1140 long fileEntryId, String version, boolean incrementCounter)
1141 throws PortalException {
1142
1143 return getFileAsStream(fileEntryId, version, incrementCounter, 1);
1144 }
1145
1146 @Override
1147 public InputStream getFileAsStream(
1148 long fileEntryId, String version, boolean incrementCounter,
1149 int increment)
1150 throws PortalException {
1151
1152 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
1153 fileEntryId);
1154
1155 if (incrementCounter) {
1156 dlFileEntryLocalService.incrementViewCounter(
1157 dlFileEntry, increment);
1158 }
1159
1160 return DLStoreUtil.getFileAsStream(
1161 dlFileEntry.getCompanyId(), dlFileEntry.getDataRepositoryId(),
1162 dlFileEntry.getName(), version);
1163 }
1164
1165 @Override
1166 public List<DLFileEntry> getFileEntries(int start, int end) {
1167 return dlFileEntryPersistence.findAll(start, end);
1168 }
1169
1170 @Override
1171 public List<DLFileEntry> getFileEntries(long groupId, long folderId) {
1172 return dlFileEntryPersistence.findByG_F(groupId, folderId);
1173 }
1174
1175 @Override
1176 public List<DLFileEntry> getFileEntries(
1177 long groupId, long folderId, int status, int start, int end,
1178 OrderByComparator<DLFileEntry> obc) {
1179
1180 List<Long> folderIds = new ArrayList<>();
1181
1182 folderIds.add(folderId);
1183
1184 QueryDefinition<DLFileEntry> queryDefinition = new QueryDefinition<>(
1185 status, false, start, end, obc);
1186
1187 return dlFileEntryFinder.findByG_F(groupId, folderIds, queryDefinition);
1188 }
1189
1190 @Override
1191 public List<DLFileEntry> getFileEntries(
1192 long groupId, long folderId, int start, int end,
1193 OrderByComparator<DLFileEntry> obc) {
1194
1195 return dlFileEntryPersistence.findByG_F(
1196 groupId, folderId, start, end, obc);
1197 }
1198
1199 @Override
1200 public List<DLFileEntry> getFileEntries(
1201 long groupId, long userId, List<Long> repositoryIds,
1202 List<Long> folderIds, String[] mimeTypes,
1203 QueryDefinition<DLFileEntry> queryDefinition)
1204 throws Exception {
1205
1206 return dlFileEntryFinder.findByG_U_R_F_M(
1207 groupId, userId, repositoryIds, folderIds, mimeTypes,
1208 queryDefinition);
1209 }
1210
1211 @Override
1212 public List<DLFileEntry> getFileEntries(
1213 long groupId, long userId, List<Long> folderIds, String[] mimeTypes,
1214 QueryDefinition<DLFileEntry> queryDefinition)
1215 throws Exception {
1216
1217 return dlFileEntryFinder.findByG_U_F_M(
1218 groupId, userId, folderIds, mimeTypes, queryDefinition);
1219 }
1220
1221 @Override
1222 public List<DLFileEntry> getFileEntries(long folderId, String name) {
1223 return dlFileEntryPersistence.findByF_N(folderId, name);
1224 }
1225
1226 @Override
1227 public int getFileEntriesCount() {
1228 return dlFileEntryPersistence.countAll();
1229 }
1230
1231
1234 @Deprecated
1235 @Override
1236 public int getFileEntriesCount(
1237 long groupId, DateRange dateRange, long repositoryId,
1238 QueryDefinition<DLFileEntry> queryDefinition) {
1239
1240 return 0;
1241 }
1242
1243 @Override
1244 public int getFileEntriesCount(long groupId, long folderId) {
1245 return dlFileEntryPersistence.countByG_F(groupId, folderId);
1246 }
1247
1248 @Override
1249 public int getFileEntriesCount(long groupId, long folderId, int status) {
1250 List<Long> folderIds = new ArrayList<>();
1251
1252 folderIds.add(folderId);
1253
1254 return dlFileEntryFinder.countByG_F(
1255 groupId, folderIds, new QueryDefinition<DLFileEntry>(status));
1256 }
1257
1258 @Override
1259 public int getFileEntriesCount(
1260 long groupId, long userId, List<Long> repositoryIds,
1261 List<Long> folderIds, String[] mimeTypes,
1262 QueryDefinition<DLFileEntry> queryDefinition)
1263 throws Exception {
1264
1265 return dlFileEntryFinder.countByG_U_R_F_M(
1266 groupId, userId, repositoryIds, folderIds, mimeTypes,
1267 queryDefinition);
1268 }
1269
1270 @Override
1271 public int getFileEntriesCount(
1272 long groupId, long userId, List<Long> folderIds, String[] mimeTypes,
1273 QueryDefinition<DLFileEntry> queryDefinition)
1274 throws Exception {
1275
1276 return dlFileEntryFinder.countByG_U_F_M(
1277 groupId, userId, folderIds, mimeTypes, queryDefinition);
1278 }
1279
1280 @Override
1281 public DLFileEntry getFileEntry(long fileEntryId) throws PortalException {
1282 return dlFileEntryPersistence.findByPrimaryKey(fileEntryId);
1283 }
1284
1285 @Override
1286 public DLFileEntry getFileEntry(long groupId, long folderId, String title)
1287 throws PortalException {
1288
1289 DLFileEntry dlFileEntry = dlFileEntryPersistence.fetchByG_F_T(
1290 groupId, folderId, title);
1291
1292 if (dlFileEntry != null) {
1293 return dlFileEntry;
1294 }
1295
1296 List<DLFileVersion> dlFileVersions =
1297 dlFileVersionPersistence.findByG_F_T_V(
1298 groupId, folderId, title,
1299 DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION);
1300
1301 long userId = PrincipalThreadLocal.getUserId();
1302
1303 for (DLFileVersion dlFileVersion : dlFileVersions) {
1304 if (hasFileEntryLock(userId, dlFileVersion.getFileEntryId())) {
1305 return dlFileVersion.getFileEntry();
1306 }
1307 }
1308
1309 StringBundler sb = new StringBundler(8);
1310
1311 sb.append("No DLFileEntry exists with the key {");
1312 sb.append("groupId=");
1313 sb.append(groupId);
1314 sb.append(", folderId=");
1315 sb.append(folderId);
1316 sb.append(", title=");
1317 sb.append(title);
1318 sb.append(StringPool.CLOSE_CURLY_BRACE);
1319
1320 throw new NoSuchFileEntryException(sb.toString());
1321 }
1322
1323 @Override
1324 public DLFileEntry getFileEntryByName(
1325 long groupId, long folderId, String name)
1326 throws PortalException {
1327
1328 return dlFileEntryPersistence.findByG_F_N(groupId, folderId, name);
1329 }
1330
1331 @Override
1332 public DLFileEntry getFileEntryByUuidAndGroupId(String uuid, long groupId)
1333 throws PortalException {
1334
1335 return dlFileEntryPersistence.findByUUID_G(uuid, groupId);
1336 }
1337
1338 @Override
1339 public List<DLFileEntry> getGroupFileEntries(
1340 long groupId, int start, int end) {
1341
1342 return getGroupFileEntries(
1343 groupId, start, end,
1344 new RepositoryModelModifiedDateComparator<DLFileEntry>());
1345 }
1346
1347 @Override
1348 public List<DLFileEntry> getGroupFileEntries(
1349 long groupId, int start, int end, OrderByComparator<DLFileEntry> obc) {
1350
1351 return dlFileEntryPersistence.findByGroupId(groupId, start, end, obc);
1352 }
1353
1354 @Override
1355 public List<DLFileEntry> getGroupFileEntries(
1356 long groupId, long userId, int start, int end) {
1357
1358 return getGroupFileEntries(
1359 groupId, userId, start, end,
1360 new RepositoryModelModifiedDateComparator<DLFileEntry>());
1361 }
1362
1363 @Override
1364 public List<DLFileEntry> getGroupFileEntries(
1365 long groupId, long userId, int start, int end,
1366 OrderByComparator<DLFileEntry> obc) {
1367
1368 if (userId <= 0) {
1369 return dlFileEntryPersistence.findByGroupId(
1370 groupId, start, end, obc);
1371 }
1372 else {
1373 return dlFileEntryPersistence.findByG_U(
1374 groupId, userId, start, end, obc);
1375 }
1376 }
1377
1378 @Override
1379 public List<DLFileEntry> getGroupFileEntries(
1380 long groupId, long userId, long rootFolderId, int start, int end,
1381 OrderByComparator<DLFileEntry> obc) {
1382
1383 return getGroupFileEntries(
1384 groupId, userId, 0, rootFolderId, start, end, obc);
1385 }
1386
1387 @Override
1388 public List<DLFileEntry> getGroupFileEntries(
1389 long groupId, long userId, long repositoryId, long rootFolderId,
1390 int start, int end, OrderByComparator<DLFileEntry> obc) {
1391
1392 List<Long> folderIds = null;
1393
1394 if (repositoryId != 0) {
1395 folderIds = dlFolderLocalService.getRepositoryFolderIds(
1396 repositoryId, rootFolderId);
1397 }
1398 else {
1399 folderIds = dlFolderLocalService.getGroupFolderIds(
1400 groupId, rootFolderId);
1401 }
1402
1403 if (folderIds.isEmpty()) {
1404 return Collections.emptyList();
1405 }
1406
1407 QueryDefinition<DLFileEntry> queryDefinition = new QueryDefinition<>(
1408 WorkflowConstants.STATUS_ANY, start, end, obc);
1409
1410 if (repositoryId == 0) {
1411 if (userId <= 0) {
1412 return dlFileEntryFinder.findByG_F(
1413 groupId, folderIds, queryDefinition);
1414 }
1415 else {
1416 return dlFileEntryFinder.findByG_U_F(
1417 groupId, userId, folderIds, queryDefinition);
1418 }
1419 }
1420 else {
1421 List<Long> repositoryIds = new ArrayList<>();
1422
1423 repositoryIds.add(repositoryId);
1424
1425 if (userId <= 0) {
1426 return dlFileEntryFinder.findByG_R_F(
1427 groupId, repositoryIds, folderIds, queryDefinition);
1428 }
1429 else {
1430 return dlFileEntryFinder.findByG_U_R_F(
1431 groupId, userId, repositoryIds, folderIds, queryDefinition);
1432 }
1433 }
1434 }
1435
1436 @Override
1437 public int getGroupFileEntriesCount(long groupId) {
1438 return dlFileEntryPersistence.countByGroupId(groupId);
1439 }
1440
1441 @Override
1442 public int getGroupFileEntriesCount(long groupId, long userId) {
1443 if (userId <= 0) {
1444 return dlFileEntryPersistence.countByGroupId(groupId);
1445 }
1446 else {
1447 return dlFileEntryPersistence.countByG_U(groupId, userId);
1448 }
1449 }
1450
1451 @Override
1452 public List<DLFileEntry> getMisversionedFileEntries() {
1453 return dlFileEntryFinder.findByMisversioned();
1454 }
1455
1456 @Override
1457 public List<DLFileEntry> getNoAssetFileEntries() {
1458 return dlFileEntryFinder.findByNoAssets();
1459 }
1460
1461 @Override
1462 public List<DLFileEntry> getOrphanedFileEntries() {
1463 return dlFileEntryFinder.findByOrphanedFileEntries();
1464 }
1465
1466 @Override
1467 public List<DLFileEntry> getRepositoryFileEntries(
1468 long repositoryId, int start, int end) {
1469
1470 return dlFileEntryPersistence.findByRepositoryId(
1471 repositoryId, start, end);
1472 }
1473
1474 @Override
1475 public int getRepositoryFileEntriesCount(long repositoryId) {
1476 return dlFileEntryPersistence.countByRepositoryId(repositoryId);
1477 }
1478
1479 @Override
1480 public String getUniqueTitle(
1481 long groupId, long folderId, long fileEntryId, String title,
1482 String extension)
1483 throws PortalException {
1484
1485 String uniqueTitle = title;
1486
1487 for (int i = 1;; i++) {
1488 String uniqueFileName = DLUtil.getSanitizedFileName(
1489 uniqueTitle, extension);
1490
1491 try {
1492 validateFile(
1493 groupId, folderId, fileEntryId, uniqueFileName,
1494 uniqueTitle);
1495
1496 return uniqueTitle;
1497 }
1498 catch (PortalException pe) {
1499 if (!(pe instanceof DuplicateFolderNameException) &&
1500 !(pe instanceof DuplicateFileEntryException)) {
1501
1502 throw pe;
1503 }
1504 }
1505
1506 uniqueTitle = FileUtil.appendParentheticalSuffix(
1507 title, String.valueOf(i));
1508 }
1509 }
1510
1511 @Override
1512 public boolean hasExtraSettings() {
1513 if (dlFileEntryFinder.countByExtraSettings() > 0) {
1514 return true;
1515 }
1516 else {
1517 return false;
1518 }
1519 }
1520
1521 @Override
1522 public boolean hasFileEntryLock(long userId, long fileEntryId)
1523 throws PortalException {
1524
1525 DLFileEntry dlFileEntry = getFileEntry(fileEntryId);
1526
1527 long folderId = dlFileEntry.getFolderId();
1528
1529 boolean hasLock = LockManagerUtil.hasLock(
1530 userId, DLFileEntry.class.getName(), fileEntryId);
1531
1532 if (!hasLock &&
1533 (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID)) {
1534
1535 hasLock = dlFolderLocalService.hasInheritableLock(folderId);
1536 }
1537
1538 return hasLock;
1539 }
1540
1541 @BufferedIncrement(
1542 configuration = "DLFileEntry", incrementClass = NumberIncrement.class
1543 )
1544 @Override
1545 public void incrementViewCounter(DLFileEntry dlFileEntry, int increment) {
1546 if (ExportImportThreadLocal.isImportInProcess()) {
1547 return;
1548 }
1549
1550 dlFileEntry.setModifiedDate(dlFileEntry.getModifiedDate());
1551 dlFileEntry.setReadCount(dlFileEntry.getReadCount() + increment);
1552
1553 dlFileEntryPersistence.update(dlFileEntry);
1554 }
1555
1556 @Override
1557 public boolean isFileEntryCheckedOut(long fileEntryId)
1558 throws PortalException {
1559
1560 DLFileVersion dlFileVersion =
1561 dlFileVersionLocalService.getLatestFileVersion(fileEntryId, false);
1562
1563 String version = dlFileVersion.getVersion();
1564
1565 if (version.equals(DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION)) {
1566 return true;
1567 }
1568 else {
1569 return false;
1570 }
1571 }
1572
1573 @Override
1574 public boolean isKeepFileVersionLabel(
1575 long fileEntryId, boolean majorVersion,
1576 ServiceContext serviceContext)
1577 throws PortalException {
1578
1579 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
1580 fileEntryId);
1581
1582 DLFileVersion lastDLFileVersion =
1583 dlFileVersionLocalService.getFileVersion(
1584 dlFileEntry.getFileEntryId(), dlFileEntry.getVersion());
1585
1586 DLFileVersion latestDLFileVersion =
1587 dlFileVersionLocalService.getLatestFileVersion(fileEntryId, false);
1588
1589 return dlFileVersionPolicy.isKeepFileVersionLabel(
1590 lastDLFileVersion, latestDLFileVersion, majorVersion,
1591 serviceContext);
1592 }
1593
1594
1598 @Deprecated
1599 @Override
1600 public boolean isKeepFileVersionLabel(
1601 long fileEntryId, ServiceContext serviceContext)
1602 throws PortalException {
1603
1604 return isKeepFileVersionLabel(fileEntryId, false, serviceContext);
1605 }
1606
1607 @Override
1608 public Lock lockFileEntry(long userId, long fileEntryId)
1609 throws PortalException {
1610
1611 if (hasFileEntryLock(userId, fileEntryId)) {
1612 return LockManagerUtil.getLock(
1613 DLFileEntry.class.getName(), fileEntryId);
1614 }
1615
1616 return LockManagerUtil.lock(
1617 userId, DLFileEntry.class.getName(), fileEntryId, null, false,
1618 DLFileEntryImpl.LOCK_EXPIRATION_TIME);
1619 }
1620
1621 @Indexable(type = IndexableType.REINDEX)
1622 @Override
1623 public DLFileEntry moveFileEntry(
1624 long userId, long fileEntryId, long newFolderId,
1625 ServiceContext serviceContext)
1626 throws PortalException {
1627
1628 if (!hasFileEntryLock(userId, fileEntryId)) {
1629 lockFileEntry(userId, fileEntryId);
1630 }
1631
1632 try {
1633 DLFileEntry dlFileEntry = moveFileEntryImpl(
1634 userId, fileEntryId, newFolderId, serviceContext);
1635
1636 return dlFileEntryTypeLocalService.updateFileEntryFileEntryType(
1637 dlFileEntry, serviceContext);
1638 }
1639 finally {
1640 if (!isFileEntryCheckedOut(fileEntryId)) {
1641 unlockFileEntry(fileEntryId);
1642 }
1643 }
1644 }
1645
1646 @Override
1647 public void rebuildTree(long companyId) throws PortalException {
1648 dlFolderLocalService.rebuildTree(companyId);
1649 }
1650
1651 @Override
1652 public void revertFileEntry(
1653 long userId, long fileEntryId, String version,
1654 ServiceContext serviceContext)
1655 throws PortalException {
1656
1657 if (Validator.isNull(version)) {
1658 throw new InvalidFileVersionException("Version is null");
1659 }
1660
1661 if (version.equals(DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION)) {
1662 throw new InvalidFileVersionException(
1663 "Unable to revert a private working copy file version");
1664 }
1665
1666 DLFileVersion dlFileVersion = dlFileVersionLocalService.getFileVersion(
1667 fileEntryId, version);
1668
1669 if (!dlFileVersion.isApproved()) {
1670 throw new InvalidFileVersionException(
1671 "Unable to revert from an unapproved file version");
1672 }
1673
1674 DLFileVersion latestDLFileVersion =
1675 dlFileVersionLocalService.getLatestFileVersion(fileEntryId, false);
1676
1677 if (version.equals(latestDLFileVersion.getVersion())) {
1678 throw new InvalidFileVersionException(
1679 "Unable to revert from the latest file version");
1680 }
1681
1682 String sourceFileName = dlFileVersion.getTitle();
1683 String extension = dlFileVersion.getExtension();
1684 String mimeType = dlFileVersion.getMimeType();
1685 String title = dlFileVersion.getTitle();
1686 String description = dlFileVersion.getDescription();
1687 String changeLog = LanguageUtil.format(
1688 serviceContext.getLocale(), "reverted-to-x", version, false);
1689 boolean majorVersion = true;
1690 String extraSettings = dlFileVersion.getExtraSettings();
1691 Map<String, DDMFormValues> ddmFormValuesMap = null;
1692 InputStream is = getFileAsStream(fileEntryId, version, false);
1693 long size = dlFileVersion.getSize();
1694
1695 serviceContext.setCommand(Constants.REVERT);
1696
1697 DLFileEntry dlFileEntry = dlFileEntryLocalService.getFileEntry(
1698 fileEntryId);
1699
1700 long fileEntryTypeId = getValidFileEntryTypeId(
1701 dlFileVersion.getFileEntryTypeId(), dlFileEntry);
1702
1703 updateFileEntry(
1704 userId, fileEntryId, sourceFileName, extension, mimeType, title,
1705 description, changeLog, majorVersion, extraSettings,
1706 fileEntryTypeId, ddmFormValuesMap, null, is, size, serviceContext);
1707
1708 DLFileVersion newDlFileVersion =
1709 dlFileVersionLocalService.getLatestFileVersion(fileEntryId, false);
1710
1711 copyFileEntryMetadata(
1712 dlFileVersion.getCompanyId(), dlFileVersion.getFileEntryTypeId(),
1713 fileEntryId, dlFileVersion.getFileVersionId(),
1714 newDlFileVersion.getFileVersionId(), serviceContext);
1715 }
1716
1717 @Override
1718 public Hits search(
1719 long groupId, long userId, long creatorUserId, int status,
1720 int start, int end)
1721 throws PortalException {
1722
1723 return search(
1724 groupId, userId, creatorUserId,
1725 DLFolderConstants.DEFAULT_PARENT_FOLDER_ID, null, status, start,
1726 end);
1727 }
1728
1729 @Override
1730 public Hits search(
1731 long groupId, long userId, long creatorUserId, long folderId,
1732 String[] mimeTypes, int status, int start, int end)
1733 throws PortalException {
1734
1735 Indexer<DLFileEntry> indexer = IndexerRegistryUtil.getIndexer(
1736 DLFileEntryConstants.getClassName());
1737
1738 SearchContext searchContext = new SearchContext();
1739
1740 searchContext.setAttribute(Field.STATUS, status);
1741
1742 if (creatorUserId > 0) {
1743 searchContext.setAttribute(
1744 Field.USER_ID, String.valueOf(creatorUserId));
1745 }
1746
1747 if (ArrayUtil.isNotEmpty(mimeTypes)) {
1748 searchContext.setAttribute("mimeTypes", mimeTypes);
1749 }
1750
1751 searchContext.setAttribute("paginationType", "none");
1752
1753 Group group = groupLocalService.getGroup(groupId);
1754
1755 searchContext.setCompanyId(group.getCompanyId());
1756
1757 searchContext.setEnd(end);
1758 searchContext.setFolderIds(new long[] {folderId});
1759 searchContext.setGroupIds(new long[] {groupId});
1760 searchContext.setSorts(new Sort(Field.MODIFIED_DATE, true));
1761 searchContext.setStart(start);
1762 searchContext.setUserId(userId);
1763
1764 return indexer.search(searchContext);
1765 }
1766
1767 @Override
1768 public void setTreePaths(
1769 final long folderId, final String treePath, final boolean reindex)
1770 throws PortalException {
1771
1772 if (treePath == null) {
1773 throw new IllegalArgumentException("Tree path is null");
1774 }
1775
1776 final IndexableActionableDynamicQuery indexableActionableDynamicQuery =
1777 getIndexableActionableDynamicQuery();
1778
1779 indexableActionableDynamicQuery.setAddCriteriaMethod(
1780 new ActionableDynamicQuery.AddCriteriaMethod() {
1781
1782 @Override
1783 public void addCriteria(DynamicQuery dynamicQuery) {
1784 Property folderIdProperty = PropertyFactoryUtil.forName(
1785 "folderId");
1786
1787 dynamicQuery.add(folderIdProperty.eq(folderId));
1788
1789 Property treePathProperty = PropertyFactoryUtil.forName(
1790 "treePath");
1791
1792 dynamicQuery.add(
1793 RestrictionsFactoryUtil.or(
1794 treePathProperty.isNull(),
1795 treePathProperty.ne(treePath)));
1796 }
1797
1798 });
1799
1800 final Indexer<DLFileEntry> indexer = IndexerRegistryUtil.getIndexer(
1801 DLFileEntry.class.getName());
1802
1803 indexableActionableDynamicQuery.setPerformActionMethod(
1804 new ActionableDynamicQuery.PerformActionMethod<DLFileEntry>() {
1805
1806 @Override
1807 public void performAction(DLFileEntry dlFileEntry)
1808 throws PortalException {
1809
1810 dlFileEntry.setTreePath(treePath);
1811
1812 updateDLFileEntry(dlFileEntry);
1813
1814 if (!reindex) {
1815 return;
1816 }
1817
1818 Document document = indexer.getDocument(dlFileEntry);
1819
1820 indexableActionableDynamicQuery.addDocuments(document);
1821 }
1822
1823 });
1824
1825 indexableActionableDynamicQuery.performActions();
1826 }
1827
1828 @Override
1829 public void unlockFileEntry(long fileEntryId) {
1830 LockManagerUtil.unlock(DLFileEntry.class.getName(), fileEntryId);
1831 }
1832
1833 @Override
1834 public DLFileEntry updateFileEntry(
1835 long userId, long fileEntryId, String sourceFileName,
1836 String mimeType, String title, String description, String changeLog,
1837 boolean majorVersion, long fileEntryTypeId,
1838 Map<String, DDMFormValues> ddmFormValuesMap, File file,
1839 InputStream is, long size, ServiceContext serviceContext)
1840 throws PortalException {
1841
1842 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
1843 fileEntryId);
1844
1845 String extension = DLAppUtil.getExtension(title, sourceFileName);
1846
1847 String extraSettings = StringPool.BLANK;
1848
1849 if (fileEntryTypeId == -1) {
1850 fileEntryTypeId = dlFileEntry.getFileEntryTypeId();
1851 }
1852
1853 validateFileEntryTypeId(
1854 PortalUtil.getCurrentAndAncestorSiteGroupIds(
1855 dlFileEntry.getGroupId()),
1856 dlFileEntry.getFolderId(), fileEntryTypeId);
1857
1858 return updateFileEntry(
1859 userId, fileEntryId, sourceFileName, extension, mimeType, title,
1860 description, changeLog, majorVersion, extraSettings,
1861 fileEntryTypeId, ddmFormValuesMap, file, is, size, serviceContext);
1862 }
1863
1864 @Override
1865 public DLFileEntry updateFileEntryType(
1866 long userId, long fileEntryId, long fileEntryTypeId,
1867 ServiceContext serviceContext)
1868 throws PortalException {
1869
1870 User user = userPersistence.findByPrimaryKey(userId);
1871
1872 DLFileEntry dlFileEntry = dlFileEntryLocalService.getFileEntry(
1873 fileEntryId);
1874
1875 dlFileEntry.setFileEntryTypeId(fileEntryTypeId);
1876
1877 dlFileEntryLocalService.updateDLFileEntry(dlFileEntry);
1878
1879 DLFileVersion dlFileVersion =
1880 dlFileVersionLocalService.getLatestFileVersion(
1881 fileEntryId, !dlFileEntry.isCheckedOut());
1882
1883 dlFileVersion.setUserId(user.getUserId());
1884 dlFileVersion.setUserName(user.getFullName());
1885 dlFileVersion.setFileEntryTypeId(fileEntryTypeId);
1886
1887 dlFileVersionLocalService.updateDLFileVersion(dlFileVersion);
1888
1889 return dlFileEntry;
1890 }
1891
1892 @Override
1893 public void updateSmallImage(long smallImageId, long largeImageId)
1894 throws PortalException {
1895
1896 try {
1897 RenderedImage renderedImage = null;
1898
1899 Image largeImage = imageLocalService.getImage(largeImageId);
1900
1901 byte[] bytes = largeImage.getTextObj();
1902 String contentType = largeImage.getType();
1903
1904 if (bytes != null) {
1905 ImageBag imageBag = ImageToolUtil.read(bytes);
1906
1907 renderedImage = imageBag.getRenderedImage();
1908
1909
1910 }
1911
1912 if (renderedImage != null) {
1913 int height = PrefsPropsUtil.getInteger(
1914 PropsKeys.DL_FILE_ENTRY_THUMBNAIL_MAX_HEIGHT);
1915 int width = PrefsPropsUtil.getInteger(
1916 PropsKeys.DL_FILE_ENTRY_THUMBNAIL_MAX_WIDTH);
1917
1918 RenderedImage thumbnailRenderedImage = ImageToolUtil.scale(
1919 renderedImage, height, width);
1920
1921 imageLocalService.updateImage(
1922 smallImageId,
1923 ImageToolUtil.getBytes(
1924 thumbnailRenderedImage, contentType));
1925 }
1926 }
1927 catch (IOException ioe) {
1928 throw new ImageSizeException(ioe);
1929 }
1930 }
1931
1932 @Override
1933 public DLFileEntry updateStatus(
1934 long userId, long fileVersionId, int status,
1935 ServiceContext serviceContext,
1936 Map<String, Serializable> workflowContext)
1937 throws PortalException {
1938
1939
1940
1941 User user = userPersistence.findByPrimaryKey(userId);
1942
1943 DLFileVersion dlFileVersion = dlFileVersionPersistence.findByPrimaryKey(
1944 fileVersionId);
1945
1946 int oldStatus = dlFileVersion.getStatus();
1947
1948 dlFileVersion.setStatus(status);
1949 dlFileVersion.setStatusByUserId(user.getUserId());
1950 dlFileVersion.setStatusByUserName(user.getFullName());
1951 dlFileVersion.setStatusDate(new Date());
1952
1953 dlFileVersionPersistence.update(dlFileVersion);
1954
1955
1956
1957 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
1958 dlFileVersion.getFileEntryId());
1959
1960 if (status == WorkflowConstants.STATUS_APPROVED) {
1961 if (DLUtil.compareVersions(
1962 dlFileEntry.getVersion(),
1963 dlFileVersion.getVersion()) <= 0) {
1964
1965 dlFileEntry.setFileName(dlFileVersion.getFileName());
1966 dlFileEntry.setExtension(dlFileVersion.getExtension());
1967 dlFileEntry.setMimeType(dlFileVersion.getMimeType());
1968 dlFileEntry.setTitle(dlFileVersion.getTitle());
1969 dlFileEntry.setDescription(dlFileVersion.getDescription());
1970 dlFileEntry.setExtraSettings(dlFileVersion.getExtraSettings());
1971 dlFileEntry.setFileEntryTypeId(
1972 dlFileVersion.getFileEntryTypeId());
1973 dlFileEntry.setVersion(dlFileVersion.getVersion());
1974 dlFileEntry.setModifiedDate(dlFileVersion.getCreateDate());
1975 dlFileEntry.setSize(dlFileVersion.getSize());
1976
1977 dlFileEntryPersistence.update(dlFileEntry);
1978 }
1979 }
1980 else {
1981
1982
1983
1984 if ((status != WorkflowConstants.STATUS_IN_TRASH) &&
1985 Validator.equals(
1986 dlFileEntry.getVersion(), dlFileVersion.getVersion())) {
1987
1988 String newVersion = DLFileEntryConstants.VERSION_DEFAULT;
1989
1990 List<DLFileVersion> approvedFileVersions =
1991 dlFileVersionPersistence.findByF_S(
1992 dlFileEntry.getFileEntryId(),
1993 WorkflowConstants.STATUS_APPROVED);
1994
1995 if (!approvedFileVersions.isEmpty()) {
1996 newVersion = approvedFileVersions.get(0).getVersion();
1997 }
1998
1999 dlFileEntry.setVersion(newVersion);
2000
2001 dlFileEntryPersistence.update(dlFileEntry);
2002 }
2003
2004
2005
2006 if (Validator.equals(
2007 dlFileVersion.getVersion(),
2008 DLFileEntryConstants.VERSION_DEFAULT)) {
2009
2010 Indexer<DLFileEntry> indexer =
2011 IndexerRegistryUtil.nullSafeGetIndexer(DLFileEntry.class);
2012
2013 indexer.delete(dlFileEntry);
2014 }
2015 }
2016
2017
2018
2019 dlAppHelperLocalService.updateStatus(
2020 userId, new LiferayFileEntry(dlFileEntry),
2021 new LiferayFileVersion(dlFileVersion), oldStatus, status,
2022 serviceContext, workflowContext);
2023
2024 if (PropsValues.DL_FILE_ENTRY_COMMENTS_ENABLED) {
2025 if (status == WorkflowConstants.STATUS_IN_TRASH) {
2026 CommentManagerUtil.moveDiscussionToTrash(
2027 DLFileEntry.class.getName(), dlFileEntry.getFileEntryId());
2028 }
2029 else if (oldStatus == WorkflowConstants.STATUS_IN_TRASH) {
2030 CommentManagerUtil.restoreDiscussionFromTrash(
2031 DLFileEntry.class.getName(), dlFileEntry.getFileEntryId());
2032 }
2033 }
2034
2035
2036
2037 if (((status == WorkflowConstants.STATUS_APPROVED) ||
2038 (status == WorkflowConstants.STATUS_IN_TRASH) ||
2039 (oldStatus == WorkflowConstants.STATUS_IN_TRASH)) &&
2040 ((serviceContext == null) || serviceContext.isIndexingEnabled())) {
2041
2042 reindex(dlFileEntry);
2043 }
2044
2045 return dlFileEntry;
2046 }
2047
2048 @Override
2049 public void validateFile(
2050 long groupId, long folderId, long fileEntryId, String fileName,
2051 String title)
2052 throws PortalException {
2053
2054 DLFolder dlFolder = dlFolderPersistence.fetchByG_P_N(
2055 groupId, folderId, title);
2056
2057 if (dlFolder != null) {
2058 throw new DuplicateFolderNameException(title);
2059 }
2060
2061 DLFileEntry dlFileEntry = dlFileEntryPersistence.fetchByG_F_T(
2062 groupId, folderId, title);
2063
2064 if ((dlFileEntry != null) &&
2065 (dlFileEntry.getFileEntryId() != fileEntryId)) {
2066
2067 throw new DuplicateFileEntryException(title);
2068 }
2069
2070 dlFileEntry = dlFileEntryPersistence.fetchByG_F_FN(
2071 groupId, folderId, fileName);
2072
2073 if ((dlFileEntry != null) &&
2074 (dlFileEntry.getFileEntryId() != fileEntryId)) {
2075
2076 throw new DuplicateFileEntryException(title);
2077 }
2078 }
2079
2080 @Override
2081 public boolean verifyFileEntryCheckOut(long fileEntryId, String lockUuid)
2082 throws PortalException {
2083
2084 if (verifyFileEntryLock(fileEntryId, lockUuid) &&
2085 isFileEntryCheckedOut(fileEntryId)) {
2086
2087 return true;
2088 }
2089 else {
2090 return false;
2091 }
2092 }
2093
2094 @Override
2095 public boolean verifyFileEntryLock(long fileEntryId, String lockUuid)
2096 throws PortalException {
2097
2098 boolean lockVerified = false;
2099
2100 try {
2101 Lock lock = LockManagerUtil.getLock(
2102 DLFileEntry.class.getName(), fileEntryId);
2103
2104 if (Validator.equals(lock.getUuid(), lockUuid)) {
2105 lockVerified = true;
2106 }
2107 }
2108 catch (PortalException pe) {
2109 if ((pe instanceof ExpiredLockException) ||
2110 (pe instanceof NoSuchLockException)) {
2111
2112 DLFileEntry dlFileEntry = dlFileEntryLocalService.getFileEntry(
2113 fileEntryId);
2114
2115 lockVerified = dlFolderLocalService.verifyInheritableLock(
2116 dlFileEntry.getFolderId(), lockUuid);
2117 }
2118 else {
2119 throw pe;
2120 }
2121 }
2122
2123 return lockVerified;
2124 }
2125
2126 protected void addFileEntryResources(
2127 DLFileEntry dlFileEntry, ServiceContext serviceContext)
2128 throws PortalException {
2129
2130 if (serviceContext.isAddGroupPermissions() ||
2131 serviceContext.isAddGuestPermissions()) {
2132
2133 resourceLocalService.addResources(
2134 dlFileEntry.getCompanyId(), dlFileEntry.getGroupId(),
2135 dlFileEntry.getUserId(), DLFileEntry.class.getName(),
2136 dlFileEntry.getFileEntryId(), false,
2137 serviceContext.isAddGroupPermissions(),
2138 serviceContext.isAddGuestPermissions());
2139 }
2140 else {
2141 if (serviceContext.isDeriveDefaultPermissions()) {
2142 serviceContext.deriveDefaultPermissions(
2143 dlFileEntry.getRepositoryId(),
2144 DLFileEntryConstants.getClassName());
2145 }
2146
2147 resourceLocalService.addModelResources(
2148 dlFileEntry.getCompanyId(), dlFileEntry.getGroupId(),
2149 dlFileEntry.getUserId(), DLFileEntry.class.getName(),
2150 dlFileEntry.getFileEntryId(),
2151 serviceContext.getModelPermissions());
2152 }
2153 }
2154
2155 protected DLFileVersion addFileVersion(
2156 User user, DLFileEntry dlFileEntry, String fileName,
2157 String extension, String mimeType, String title, String description,
2158 String changeLog, String extraSettings, long fileEntryTypeId,
2159 Map<String, DDMFormValues> ddmFormValuesMap, String version,
2160 long size, int status, ServiceContext serviceContext)
2161 throws PortalException {
2162
2163 long fileVersionId = counterLocalService.increment();
2164
2165 DLFileVersion dlFileVersion = dlFileVersionPersistence.create(
2166 fileVersionId);
2167
2168 String uuid = ParamUtil.getString(
2169 serviceContext, "fileVersionUuid", serviceContext.getUuid());
2170
2171 dlFileVersion.setUuid(uuid);
2172
2173 dlFileVersion.setGroupId(dlFileEntry.getGroupId());
2174 dlFileVersion.setCompanyId(dlFileEntry.getCompanyId());
2175 dlFileVersion.setUserId(user.getUserId());
2176 dlFileVersion.setUserName(user.getFullName());
2177 dlFileVersion.setRepositoryId(dlFileEntry.getRepositoryId());
2178 dlFileVersion.setFolderId(dlFileEntry.getFolderId());
2179 dlFileVersion.setFileEntryId(dlFileEntry.getFileEntryId());
2180 dlFileVersion.setTreePath(dlFileVersion.buildTreePath());
2181 dlFileVersion.setFileName(fileName);
2182 dlFileVersion.setExtension(extension);
2183 dlFileVersion.setMimeType(mimeType);
2184 dlFileVersion.setTitle(title);
2185 dlFileVersion.setDescription(description);
2186 dlFileVersion.setChangeLog(changeLog);
2187 dlFileVersion.setExtraSettings(extraSettings);
2188 dlFileVersion.setFileEntryTypeId(fileEntryTypeId);
2189 dlFileVersion.setVersion(version);
2190 dlFileVersion.setSize(size);
2191 dlFileVersion.setStatus(status);
2192 dlFileVersion.setStatusByUserId(user.getUserId());
2193 dlFileVersion.setStatusByUserName(user.getFullName());
2194 dlFileVersion.setStatusDate(dlFileEntry.getModifiedDate());
2195
2196 ExpandoBridge oldExpandoBridge = dlFileVersion.getExpandoBridge();
2197
2198 DLFileVersion latestFileVersion =
2199 dlFileVersionLocalService.fetchLatestFileVersion(
2200 dlFileEntry.getFileEntryId(), false);
2201
2202 if (latestFileVersion != null) {
2203 oldExpandoBridge = latestFileVersion.getExpandoBridge();
2204 }
2205
2206 ExpandoBridgeUtil.setExpandoBridgeAttributes(
2207 oldExpandoBridge, dlFileVersion.getExpandoBridge(), serviceContext);
2208
2209 dlFileVersionPersistence.update(dlFileVersion);
2210
2211 if ((fileEntryTypeId > 0) && (ddmFormValuesMap != null)) {
2212 dlFileEntryMetadataLocalService.updateFileEntryMetadata(
2213 fileEntryTypeId, dlFileEntry.getFileEntryId(), fileVersionId,
2214 ddmFormValuesMap, serviceContext);
2215 }
2216
2217 return dlFileVersion;
2218 }
2219
2220 protected void convertExtraSettings(
2221 DLFileEntry dlFileEntry, DLFileVersion dlFileVersion, String[] keys)
2222 throws PortalException {
2223
2224 UnicodeProperties extraSettingsProperties =
2225 dlFileVersion.getExtraSettingsProperties();
2226
2227 ExpandoBridge expandoBridge = dlFileVersion.getExpandoBridge();
2228
2229 convertExtraSettings(extraSettingsProperties, expandoBridge, keys);
2230
2231 dlFileVersion.setExtraSettingsProperties(extraSettingsProperties);
2232
2233 dlFileVersionPersistence.update(dlFileVersion);
2234
2235 int status = dlFileVersion.getStatus();
2236
2237 if ((status == WorkflowConstants.STATUS_APPROVED) &&
2238 (DLUtil.compareVersions(
2239 dlFileEntry.getVersion(), dlFileVersion.getVersion()) <= 0)) {
2240
2241 reindex(dlFileEntry);
2242 }
2243 }
2244
2245 protected void convertExtraSettings(DLFileEntry dlFileEntry, String[] keys)
2246 throws PortalException {
2247
2248 UnicodeProperties extraSettingsProperties =
2249 dlFileEntry.getExtraSettingsProperties();
2250
2251 ExpandoBridge expandoBridge = dlFileEntry.getExpandoBridge();
2252
2253 convertExtraSettings(extraSettingsProperties, expandoBridge, keys);
2254
2255 dlFileEntry.setExtraSettingsProperties(extraSettingsProperties);
2256
2257 dlFileEntryPersistence.update(dlFileEntry);
2258
2259 List<DLFileVersion> dlFileVersions =
2260 dlFileVersionLocalService.getFileVersions(
2261 dlFileEntry.getFileEntryId(), WorkflowConstants.STATUS_ANY);
2262
2263 for (DLFileVersion dlFileVersion : dlFileVersions) {
2264 convertExtraSettings(dlFileEntry, dlFileVersion, keys);
2265 }
2266 }
2267
2268 protected void convertExtraSettings(
2269 UnicodeProperties extraSettingsProperties, ExpandoBridge expandoBridge,
2270 String[] keys) {
2271
2272 for (String key : keys) {
2273 String value = extraSettingsProperties.remove(key);
2274
2275 if (Validator.isNull(value)) {
2276 continue;
2277 }
2278
2279 int type = expandoBridge.getAttributeType(key);
2280
2281 Serializable serializable = ExpandoColumnConstants.getSerializable(
2282 type, value);
2283
2284 expandoBridge.setAttribute(key, serializable);
2285 }
2286 }
2287
2288 protected void copyExpandoRowModifiedDate(
2289 long companyId, long sourceFileVersionId,
2290 long destinationFileVersionId) {
2291
2292 ExpandoTable expandoTable = expandoTableLocalService.fetchDefaultTable(
2293 companyId, DLFileEntry.class.getName());
2294
2295 if (expandoTable == null) {
2296 return;
2297 }
2298
2299 ExpandoRow sourceExpandoRow = expandoRowLocalService.fetchRow(
2300 expandoTable.getTableId(), sourceFileVersionId);
2301
2302 if (sourceExpandoRow == null) {
2303 return;
2304 }
2305
2306 ExpandoRow destinationExpandoRow = expandoRowLocalService.fetchRow(
2307 expandoTable.getTableId(), destinationFileVersionId);
2308
2309 if (destinationExpandoRow == null) {
2310 return;
2311 }
2312
2313 destinationExpandoRow.setModifiedDate(
2314 sourceExpandoRow.getModifiedDate());
2315
2316 expandoRowLocalService.updateExpandoRow(destinationExpandoRow);
2317 }
2318
2319 protected void copyFileEntryMetadata(
2320 long companyId, long fileEntryId, long fromFileVersionId,
2321 long toFileVersionId, ServiceContext serviceContext,
2322 Map<String, DDMFormValues> ddmFormValuesMap,
2323 List<DDMStructure> ddmStructures)
2324 throws PortalException {
2325
2326 for (DDMStructure ddmStructure : ddmStructures) {
2327 DLFileEntryMetadata dlFileEntryMetadata =
2328 dlFileEntryMetadataLocalService.fetchFileEntryMetadata(
2329 ddmStructure.getStructureId(), fromFileVersionId);
2330
2331 if (dlFileEntryMetadata == null) {
2332 continue;
2333 }
2334
2335 DDMFormValues ddmFormValues =
2336 StorageEngineManagerUtil.getDDMFormValues(
2337 dlFileEntryMetadata.getDDMStorageId());
2338
2339 ddmFormValuesMap.put(ddmStructure.getStructureKey(), ddmFormValues);
2340 }
2341
2342 if (!ddmFormValuesMap.isEmpty()) {
2343 dlFileEntryMetadataLocalService.updateFileEntryMetadata(
2344 companyId, ddmStructures, fileEntryId, toFileVersionId,
2345 ddmFormValuesMap, serviceContext);
2346 }
2347 }
2348
2349 protected RepositoryEventTrigger getFolderRepositoryEventTrigger(
2350 long groupId, long folderId)
2351 throws PortalException {
2352
2353 if (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
2354 return RepositoryUtil.getFolderRepositoryEventTrigger(folderId);
2355 }
2356
2357 return RepositoryUtil.getRepositoryEventTrigger(groupId);
2358 }
2359
2360 protected String getNextVersion(
2361 DLFileEntry dlFileEntry, boolean majorVersion, int workflowAction) {
2362
2363 String version = dlFileEntry.getVersion();
2364
2365 DLFileVersion dlFileVersion =
2366 dlFileVersionLocalService.fetchLatestFileVersion(
2367 dlFileEntry.getFileEntryId(), true);
2368
2369 if (dlFileVersion != null) {
2370 version = dlFileVersion.getVersion();
2371 }
2372
2373 if (workflowAction == WorkflowConstants.ACTION_SAVE_DRAFT) {
2374 majorVersion = false;
2375 }
2376
2377 int[] versionParts = StringUtil.split(version, StringPool.PERIOD, 0);
2378
2379 if (majorVersion) {
2380 versionParts[0]++;
2381 versionParts[1] = 0;
2382 }
2383 else {
2384 versionParts[1]++;
2385 }
2386
2387 return versionParts[0] + StringPool.PERIOD + versionParts[1];
2388 }
2389
2390 protected long getValidFileEntryTypeId(
2391 long fileEntryTypeId, DLFileEntry dlFileEntry)
2392 throws PortalException {
2393
2394 try {
2395 validateFileEntryTypeId(
2396 PortalUtil.getCurrentAndAncestorSiteGroupIds(
2397 dlFileEntry.getGroupId()),
2398 dlFileEntry.getFolderId(), fileEntryTypeId);
2399
2400 return fileEntryTypeId;
2401 }
2402 catch (InvalidFileEntryTypeException ifete) {
2403 return dlFileEntryTypeLocalService.getDefaultFileEntryTypeId(
2404 dlFileEntry.getFolderId());
2405 }
2406 }
2407
2408 protected DLFileEntry moveFileEntryImpl(
2409 long userId, long fileEntryId, long newFolderId,
2410 ServiceContext serviceContext)
2411 throws PortalException {
2412
2413
2414
2415 User user = userPersistence.findByPrimaryKey(userId);
2416 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
2417 fileEntryId);
2418
2419 long oldDataRepositoryId = dlFileEntry.getDataRepositoryId();
2420
2421 validateFile(
2422 dlFileEntry.getGroupId(), newFolderId, dlFileEntry.getFileEntryId(),
2423 dlFileEntry.getFileName(), dlFileEntry.getTitle());
2424
2425 dlFileEntry.setFolderId(newFolderId);
2426 dlFileEntry.setTreePath(dlFileEntry.buildTreePath());
2427
2428 dlFileEntryPersistence.update(dlFileEntry);
2429
2430
2431
2432 List<DLFileVersion> dlFileVersions =
2433 dlFileVersionPersistence.findByFileEntryId(fileEntryId);
2434
2435 for (DLFileVersion dlFileVersion : dlFileVersions) {
2436 dlFileVersion.setFolderId(newFolderId);
2437 dlFileVersion.setTreePath(dlFileVersion.buildTreePath());
2438
2439 dlFileVersionPersistence.update(dlFileVersion);
2440 }
2441
2442
2443
2444 if (newFolderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
2445 DLFolder dlFolder = dlFolderPersistence.findByPrimaryKey(
2446 newFolderId);
2447
2448 dlFolder.setModifiedDate(serviceContext.getModifiedDate(null));
2449
2450 dlFolderPersistence.update(dlFolder);
2451 }
2452
2453
2454
2455 DLStoreUtil.updateFile(
2456 user.getCompanyId(), oldDataRepositoryId,
2457 dlFileEntry.getDataRepositoryId(), dlFileEntry.getName());
2458
2459 return dlFileEntry;
2460 }
2461
2462 protected void reindex(DLFileEntry dlFileEntry) throws SearchException {
2463 Indexer<DLFileEntry> indexer = IndexerRegistryUtil.nullSafeGetIndexer(
2464 DLFileEntry.class);
2465
2466 indexer.reindex(dlFileEntry);
2467 }
2468
2469 protected void removeFileVersion(
2470 DLFileEntry dlFileEntry, DLFileVersion dlFileVersion)
2471 throws PortalException {
2472
2473 dlFileVersionPersistence.remove(dlFileVersion);
2474
2475 expandoRowLocalService.deleteRows(dlFileVersion.getFileVersionId());
2476
2477 dlFileEntryMetadataLocalService.deleteFileVersionFileEntryMetadata(
2478 dlFileVersion.getFileVersionId());
2479
2480 assetEntryLocalService.deleteEntry(
2481 DLFileEntryConstants.getClassName(), dlFileVersion.getPrimaryKey());
2482
2483 DLStoreUtil.deleteFile(
2484 dlFileEntry.getCompanyId(), dlFileEntry.getDataRepositoryId(),
2485 dlFileEntry.getName(),
2486 DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION);
2487
2488 unlockFileEntry(dlFileEntry.getFileEntryId());
2489 }
2490
2491 protected DLFileEntry updateFileEntry(
2492 long userId, long fileEntryId, String sourceFileName,
2493 String extension, String mimeType, String title, String description,
2494 String changeLog, boolean majorVersion, String extraSettings,
2495 long fileEntryTypeId, Map<String, DDMFormValues> ddmFormValuesMap,
2496 File file, InputStream is, long size, ServiceContext serviceContext)
2497 throws PortalException {
2498
2499 User user = userPersistence.findByPrimaryKey(userId);
2500 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
2501 fileEntryId);
2502
2503 boolean checkedOut = dlFileEntry.isCheckedOut();
2504
2505 DLFileVersion dlFileVersion =
2506 dlFileVersionLocalService.getLatestFileVersion(
2507 fileEntryId, !checkedOut);
2508
2509 boolean autoCheckIn = false;
2510
2511 if (!checkedOut && dlFileVersion.isApproved() &&
2512 !Validator.equals(
2513 dlFileVersion.getUuid(),
2514 serviceContext.getUuidWithoutReset())) {
2515
2516 autoCheckIn = true;
2517 }
2518
2519 if (autoCheckIn) {
2520 dlFileEntry = checkOutFileEntry(
2521 userId, fileEntryId, serviceContext);
2522 }
2523 else if (!checkedOut) {
2524 lockFileEntry(userId, fileEntryId);
2525 }
2526
2527 if (!hasFileEntryLock(userId, fileEntryId)) {
2528 lockFileEntry(userId, fileEntryId);
2529 }
2530
2531 if (checkedOut || autoCheckIn) {
2532 dlFileVersion = dlFileVersionLocalService.getLatestFileVersion(
2533 fileEntryId, false);
2534 }
2535
2536 try {
2537 if (Validator.isNull(extension)) {
2538 extension = dlFileEntry.getExtension();
2539 }
2540
2541 if (Validator.isNull(mimeType)) {
2542 mimeType = dlFileEntry.getMimeType();
2543 }
2544
2545 if (Validator.isNull(title)) {
2546 title = sourceFileName;
2547
2548 if (Validator.isNull(title)) {
2549 title = dlFileEntry.getTitle();
2550 }
2551 }
2552
2553 String fileName = DLUtil.getSanitizedFileName(title, extension);
2554
2555 Date now = new Date();
2556
2557 validateFile(
2558 dlFileEntry.getGroupId(), dlFileEntry.getFolderId(),
2559 dlFileEntry.getFileEntryId(), sourceFileName, fileName,
2560 extension, title);
2561
2562
2563
2564 String version = dlFileVersion.getVersion();
2565
2566 if (size == 0) {
2567 size = dlFileVersion.getSize();
2568 }
2569
2570 updateFileVersion(
2571 user, dlFileVersion, sourceFileName, fileName, extension,
2572 mimeType, title, description, changeLog, extraSettings,
2573 fileEntryTypeId, ddmFormValuesMap, version, size,
2574 dlFileVersion.getStatus(), serviceContext.getModifiedDate(now),
2575 serviceContext);
2576
2577
2578
2579 if (!checkedOut &&
2580 (dlFileEntry.getFolderId() !=
2581 DLFolderConstants.DEFAULT_PARENT_FOLDER_ID)) {
2582
2583 dlFolderLocalService.updateLastPostDate(
2584 dlFileEntry.getFolderId(),
2585 serviceContext.getModifiedDate(now));
2586 }
2587
2588
2589
2590 if ((file != null) || (is != null)) {
2591 DLStoreUtil.deleteFile(
2592 user.getCompanyId(), dlFileEntry.getDataRepositoryId(),
2593 dlFileEntry.getName(), version);
2594
2595 if (file != null) {
2596 DLStoreUtil.updateFile(
2597 user.getCompanyId(), dlFileEntry.getDataRepositoryId(),
2598 dlFileEntry.getName(), dlFileEntry.getExtension(),
2599 false, version, sourceFileName, file);
2600 }
2601 else {
2602 DLStoreUtil.updateFile(
2603 user.getCompanyId(), dlFileEntry.getDataRepositoryId(),
2604 dlFileEntry.getName(), dlFileEntry.getExtension(),
2605 false, version, sourceFileName, is);
2606 }
2607 }
2608
2609 if (autoCheckIn) {
2610 checkInFileEntry(
2611 userId, fileEntryId, majorVersion, changeLog,
2612 serviceContext);
2613 }
2614 }
2615 catch (PortalException pe) {
2616 if (autoCheckIn) {
2617 try {
2618 cancelCheckOut(userId, fileEntryId);
2619 }
2620 catch (Exception e) {
2621 _log.error(e, e);
2622 }
2623 }
2624
2625 throw pe;
2626 }
2627 catch (SystemException se) {
2628 if (autoCheckIn) {
2629 try {
2630 cancelCheckOut(userId, fileEntryId);
2631 }
2632 catch (Exception e) {
2633 _log.error(e, e);
2634 }
2635 }
2636
2637 throw se;
2638 }
2639 finally {
2640 if (!autoCheckIn && !checkedOut) {
2641 unlockFileEntry(fileEntryId);
2642 }
2643 }
2644
2645 return dlFileEntryPersistence.findByPrimaryKey(fileEntryId);
2646 }
2647
2648 protected DLFileVersion updateFileVersion(
2649 User user, DLFileVersion dlFileVersion, String sourceFileName,
2650 String fileName, String extension, String mimeType, String title,
2651 String description, String changeLog, String extraSettings,
2652 long fileEntryTypeId, Map<String, DDMFormValues> ddmFormValuesMap,
2653 String version, long size, int status, Date statusDate,
2654 ServiceContext serviceContext)
2655 throws PortalException {
2656
2657 dlFileVersion.setUserId(user.getUserId());
2658 dlFileVersion.setUserName(user.getFullName());
2659 dlFileVersion.setModifiedDate(statusDate);
2660 dlFileVersion.setFileName(fileName);
2661
2662 if (Validator.isNotNull(sourceFileName)) {
2663 dlFileVersion.setExtension(extension);
2664 dlFileVersion.setMimeType(mimeType);
2665 }
2666
2667 dlFileVersion.setTitle(title);
2668 dlFileVersion.setDescription(description);
2669 dlFileVersion.setChangeLog(changeLog);
2670 dlFileVersion.setExtraSettings(extraSettings);
2671 dlFileVersion.setFileEntryTypeId(fileEntryTypeId);
2672 dlFileVersion.setVersion(version);
2673 dlFileVersion.setSize(size);
2674 dlFileVersion.setStatus(status);
2675 dlFileVersion.setStatusByUserId(user.getUserId());
2676 dlFileVersion.setStatusByUserName(user.getFullName());
2677 dlFileVersion.setStatusDate(statusDate);
2678
2679 ExpandoBridgeUtil.setExpandoBridgeAttributes(
2680 dlFileVersion.getExpandoBridge(), dlFileVersion.getExpandoBridge(),
2681 serviceContext);
2682
2683 dlFileVersion = dlFileVersionPersistence.update(dlFileVersion);
2684
2685 if ((fileEntryTypeId > 0) && (ddmFormValuesMap != null)) {
2686 dlFileEntryMetadataLocalService.updateFileEntryMetadata(
2687 fileEntryTypeId, dlFileVersion.getFileEntryId(),
2688 dlFileVersion.getFileVersionId(), ddmFormValuesMap,
2689 serviceContext);
2690 }
2691
2692 return dlFileVersion;
2693 }
2694
2695 protected void validateFile(
2696 long groupId, long folderId, long fileEntryId,
2697 String sourceFileName, String fileName, String extension,
2698 String title)
2699 throws PortalException {
2700
2701 DLValidatorUtil.validateFileName(title);
2702
2703 validateFileExtension(extension);
2704
2705 validateFile(groupId, folderId, fileEntryId, fileName, title);
2706 }
2707
2708 protected void validateFileEntryTypeId(
2709 long[] groupIds, long folderId, long fileEntryTypeId)
2710 throws PortalException {
2711
2712 List<DLFileEntryType> dlFileEntryTypes =
2713 dlFileEntryTypeLocalService.getFolderFileEntryTypes(
2714 groupIds, folderId, true);
2715
2716 for (DLFileEntryType dlFileEntryType : dlFileEntryTypes) {
2717 if (dlFileEntryType.getFileEntryTypeId() == fileEntryTypeId) {
2718 return;
2719 }
2720 }
2721
2722 throw new InvalidFileEntryTypeException(
2723 "Invalid file entry type " + fileEntryTypeId + " for folder " +
2724 folderId);
2725 }
2726
2727 protected void validateFileExtension(String extension)
2728 throws PortalException {
2729
2730 if (Validator.isNotNull(extension)) {
2731 int maxLength = ModelHintsUtil.getMaxLength(
2732 DLFileEntry.class.getName(), "extension");
2733
2734 if (extension.length() > maxLength) {
2735 throw new FileExtensionException(
2736 extension + " exceeds max length of " + maxLength);
2737 }
2738 }
2739 }
2740
2741 @BeanReference(type = DLFileVersionPolicy.class)
2742 protected DLFileVersionPolicy dlFileVersionPolicy;
2743
2744 private static final Log _log = LogFactoryUtil.getLog(
2745 DLFileEntryLocalServiceImpl.class);
2746
2747 }