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