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