001
014
015 package com.liferay.portlet.documentlibrary.service.impl;
016
017 import com.liferay.dynamic.data.mapping.kernel.DDMFormValues;
018 import com.liferay.dynamic.data.mapping.kernel.DDMStructure;
019 import com.liferay.dynamic.data.mapping.kernel.DDMStructureManagerUtil;
020 import com.liferay.dynamic.data.mapping.kernel.StorageEngineManagerUtil;
021 import com.liferay.portal.kernel.comment.CommentManagerUtil;
022 import com.liferay.portal.kernel.dao.orm.ActionableDynamicQuery;
023 import com.liferay.portal.kernel.dao.orm.DynamicQuery;
024 import com.liferay.portal.kernel.dao.orm.IndexableActionableDynamicQuery;
025 import com.liferay.portal.kernel.dao.orm.Property;
026 import com.liferay.portal.kernel.dao.orm.PropertyFactoryUtil;
027 import com.liferay.portal.kernel.dao.orm.QueryDefinition;
028 import com.liferay.portal.kernel.dao.orm.QueryUtil;
029 import com.liferay.portal.kernel.dao.orm.RestrictionsFactoryUtil;
030 import com.liferay.portal.kernel.exception.PortalException;
031 import com.liferay.portal.kernel.exception.SystemException;
032 import com.liferay.portal.kernel.image.ImageBag;
033 import com.liferay.portal.kernel.image.ImageToolUtil;
034 import com.liferay.portal.kernel.increment.BufferedIncrement;
035 import com.liferay.portal.kernel.increment.NumberIncrement;
036 import com.liferay.portal.kernel.interval.IntervalActionProcessor;
037 import com.liferay.portal.kernel.language.LanguageUtil;
038 import com.liferay.portal.kernel.lock.ExpiredLockException;
039 import com.liferay.portal.kernel.lock.InvalidLockException;
040 import com.liferay.portal.kernel.lock.Lock;
041 import com.liferay.portal.kernel.lock.LockManagerUtil;
042 import com.liferay.portal.kernel.lock.NoSuchLockException;
043 import com.liferay.portal.kernel.log.Log;
044 import com.liferay.portal.kernel.log.LogFactoryUtil;
045 import com.liferay.portal.kernel.repository.event.RepositoryEventTrigger;
046 import com.liferay.portal.kernel.repository.event.RepositoryEventType;
047 import com.liferay.portal.kernel.repository.model.FileEntry;
048 import com.liferay.portal.kernel.search.Document;
049 import com.liferay.portal.kernel.search.Field;
050 import com.liferay.portal.kernel.search.Hits;
051 import com.liferay.portal.kernel.search.Indexable;
052 import com.liferay.portal.kernel.search.IndexableType;
053 import com.liferay.portal.kernel.search.Indexer;
054 import com.liferay.portal.kernel.search.IndexerRegistryUtil;
055 import com.liferay.portal.kernel.search.SearchContext;
056 import com.liferay.portal.kernel.search.SearchException;
057 import com.liferay.portal.kernel.search.Sort;
058 import com.liferay.portal.kernel.security.auth.PrincipalThreadLocal;
059 import com.liferay.portal.kernel.systemevent.SystemEvent;
060 import com.liferay.portal.kernel.util.ArrayUtil;
061 import com.liferay.portal.kernel.util.Constants;
062 import com.liferay.portal.kernel.util.DateRange;
063 import com.liferay.portal.kernel.util.DigesterUtil;
064 import com.liferay.portal.kernel.util.FileUtil;
065 import com.liferay.portal.kernel.util.GetterUtil;
066 import com.liferay.portal.kernel.util.OrderByComparator;
067 import com.liferay.portal.kernel.util.ParamUtil;
068 import com.liferay.portal.kernel.util.PropsKeys;
069 import com.liferay.portal.kernel.util.StreamUtil;
070 import com.liferay.portal.kernel.util.StringBundler;
071 import com.liferay.portal.kernel.util.StringPool;
072 import com.liferay.portal.kernel.util.StringUtil;
073 import com.liferay.portal.kernel.util.UnicodeProperties;
074 import com.liferay.portal.kernel.util.Validator;
075 import com.liferay.portal.kernel.workflow.WorkflowConstants;
076 import com.liferay.portal.model.Group;
077 import com.liferay.portal.model.Image;
078 import com.liferay.portal.model.ModelHintsUtil;
079 import com.liferay.portal.model.Repository;
080 import com.liferay.portal.model.ResourceConstants;
081 import com.liferay.portal.model.SystemEventConstants;
082 import com.liferay.portal.model.User;
083 import com.liferay.portal.repository.liferayrepository.model.LiferayFileEntry;
084 import com.liferay.portal.repository.liferayrepository.model.LiferayFileVersion;
085 import com.liferay.portal.service.ServiceContext;
086 import com.liferay.portal.util.PortalUtil;
087 import com.liferay.portal.util.PrefsPropsUtil;
088 import com.liferay.portal.util.PropsValues;
089 import com.liferay.portal.util.RepositoryUtil;
090 import com.liferay.portlet.documentlibrary.exception.DuplicateFileEntryException;
091 import com.liferay.portlet.documentlibrary.exception.DuplicateFolderNameException;
092 import com.liferay.portlet.documentlibrary.exception.FileExtensionException;
093 import com.liferay.portlet.documentlibrary.exception.FileNameException;
094 import com.liferay.portlet.documentlibrary.exception.ImageSizeException;
095 import com.liferay.portlet.documentlibrary.exception.InvalidFileEntryTypeException;
096 import com.liferay.portlet.documentlibrary.exception.InvalidFileVersionException;
097 import com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException;
098 import com.liferay.portlet.documentlibrary.model.DLFileEntry;
099 import com.liferay.portlet.documentlibrary.model.DLFileEntryConstants;
100 import com.liferay.portlet.documentlibrary.model.DLFileEntryMetadata;
101 import com.liferay.portlet.documentlibrary.model.DLFileEntryType;
102 import com.liferay.portlet.documentlibrary.model.DLFileVersion;
103 import com.liferay.portlet.documentlibrary.model.DLFolder;
104 import com.liferay.portlet.documentlibrary.model.DLFolderConstants;
105 import com.liferay.portlet.documentlibrary.model.impl.DLFileEntryImpl;
106 import com.liferay.portlet.documentlibrary.service.base.DLFileEntryLocalServiceBaseImpl;
107 import com.liferay.portlet.documentlibrary.store.DLStoreUtil;
108 import com.liferay.portlet.documentlibrary.util.DL;
109 import com.liferay.portlet.documentlibrary.util.DLAppUtil;
110 import com.liferay.portlet.documentlibrary.util.DLUtil;
111 import com.liferay.portlet.documentlibrary.util.DLValidatorUtil;
112 import com.liferay.portlet.documentlibrary.util.comparator.RepositoryModelModifiedDateComparator;
113 import com.liferay.portlet.expando.model.ExpandoBridge;
114 import com.liferay.portlet.expando.model.ExpandoColumnConstants;
115 import com.liferay.portlet.expando.model.ExpandoRow;
116 import com.liferay.portlet.expando.model.ExpandoTable;
117 import com.liferay.portlet.expando.util.ExpandoBridgeUtil;
118 import com.liferay.portlet.exportimport.lar.ExportImportThreadLocal;
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 dlLatestFileVersion.setModifiedDate(new Date());
880 dlLatestFileVersion.setStatusDate(new Date());
881
882 dlFileVersionPersistence.update(dlLatestFileVersion);
883
884 dlFileEntry.setModifiedDate(new Date());
885 dlFileEntry.setFileName(dlLatestFileVersion.getFileName());
886 dlFileEntry.setExtension(
887 dlLatestFileVersion.getExtension());
888 dlFileEntry.setMimeType(dlLatestFileVersion.getMimeType());
889 dlFileEntry.setTitle(dlLatestFileVersion.getTitle());
890 dlFileEntry.setDescription(
891 dlLatestFileVersion.getDescription());
892 dlFileEntry.setExtraSettings(
893 dlLatestFileVersion.getExtraSettings());
894 dlFileEntry.setFileEntryTypeId(
895 dlLatestFileVersion.getFileEntryTypeId());
896 dlFileEntry.setVersion(dlLatestFileVersion.getVersion());
897 dlFileEntry.setSize(dlLatestFileVersion.getSize());
898
899 dlFileEntry = dlFileEntryPersistence.update(dlFileEntry);
900 }
901 }
902
903 DLStoreUtil.deleteFile(
904 dlFileEntry.getCompanyId(), dlFileEntry.getDataRepositoryId(),
905 dlFileEntry.getName(), version);
906 }
907 finally {
908 unlockFileEntry(fileEntryId);
909 }
910
911 if (latestVersion) {
912 return dlFileEntry;
913 }
914
915 return null;
916 }
917
918 @Override
919 public void deleteRepositoryFileEntries(long repositoryId, long folderId)
920 throws PortalException {
921
922 deleteRepositoryFileEntries(repositoryId, folderId, true);
923 }
924
925 @Override
926 public void deleteRepositoryFileEntries(
927 final long repositoryId, final long folderId,
928 final boolean includeTrashedEntries)
929 throws PortalException {
930
931 final RepositoryEventTrigger repositoryEventTrigger =
932 RepositoryUtil.getRepositoryEventTrigger(repositoryId);
933
934 int total = dlFileEntryPersistence.countByR_F(repositoryId, folderId);
935
936 final IntervalActionProcessor<Void> intervalActionProcessor =
937 new IntervalActionProcessor<>(total);
938
939 intervalActionProcessor.setPerformIntervalActionMethod(
940 new IntervalActionProcessor.PerformIntervalActionMethod<Void>() {
941
942 @Override
943 public Void performIntervalAction(int start, int end)
944 throws PortalException {
945
946 List<DLFileEntry> dlFileEntries =
947 dlFileEntryPersistence.findByR_F(
948 repositoryId, folderId, start, end);
949
950 for (DLFileEntry dlFileEntry : dlFileEntries) {
951 if (includeTrashedEntries ||
952 !dlFileEntry.isInTrashExplicitly()) {
953
954 repositoryEventTrigger.trigger(
955 RepositoryEventType.Delete.class,
956 FileEntry.class,
957 new LiferayFileEntry(dlFileEntry));
958
959 dlFileEntryLocalService.deleteFileEntry(
960 dlFileEntry);
961 }
962 else {
963 intervalActionProcessor.incrementStart();
964 }
965 }
966
967 return null;
968 }
969
970 });
971
972 intervalActionProcessor.performIntervalActions();
973 }
974
975 @Override
976 public DLFileEntry fetchFileEntry(
977 long groupId, long folderId, String title) {
978
979 return dlFileEntryPersistence.fetchByG_F_T(groupId, folderId, title);
980 }
981
982 @Override
983 public DLFileEntry fetchFileEntryByAnyImageId(long imageId) {
984 return dlFileEntryFinder.fetchByAnyImageId(imageId);
985 }
986
987 @Override
988 public DLFileEntry fetchFileEntryByFileName(
989 long groupId, long folderId, String fileName) {
990
991 return dlFileEntryPersistence.fetchByG_F_FN(
992 groupId, folderId, fileName);
993 }
994
995 @Override
996 public DLFileEntry fetchFileEntryByName(
997 long groupId, long folderId, String name) {
998
999 return dlFileEntryPersistence.fetchByG_F_N(groupId, folderId, name);
1000 }
1001
1002 @Override
1003 public List<DLFileEntry> getDDMStructureFileEntries(
1004 long groupId, long[] ddmStructureIds) {
1005
1006 return dlFileEntryFinder.findByDDMStructureIds(
1007 groupId, ddmStructureIds, QueryUtil.ALL_POS, QueryUtil.ALL_POS);
1008 }
1009
1010 @Override
1011 public List<DLFileEntry> getDDMStructureFileEntries(
1012 long[] ddmStructureIds) {
1013
1014 return dlFileEntryFinder.findByDDMStructureIds(
1015 ddmStructureIds, QueryUtil.ALL_POS, QueryUtil.ALL_POS);
1016 }
1017
1018 @Override
1019 public List<DLFileEntry> getExtraSettingsFileEntries(int start, int end) {
1020 return dlFileEntryFinder.findByExtraSettings(start, end);
1021 }
1022
1023 @Override
1024 public int getExtraSettingsFileEntriesCount() {
1025 return dlFileEntryFinder.countByExtraSettings();
1026 }
1027
1028
1032 @Deprecated
1033 @Override
1034 public File getFile(
1035 long userId, long fileEntryId, String version,
1036 boolean incrementCounter)
1037 throws PortalException {
1038
1039 return getFile(fileEntryId, version, incrementCounter, 1);
1040 }
1041
1042
1046 @Deprecated
1047 @Override
1048 public File getFile(
1049 long userId, long fileEntryId, String version,
1050 boolean incrementCounter, int increment)
1051 throws PortalException {
1052
1053 return getFile(fileEntryId, version, incrementCounter, increment);
1054 }
1055
1056 @Override
1057 public File getFile(
1058 long fileEntryId, String version, boolean incrementCounter)
1059 throws PortalException {
1060
1061 return getFile(fileEntryId, version, incrementCounter, 1);
1062 }
1063
1064 @Override
1065 public File getFile(
1066 long fileEntryId, String version, boolean incrementCounter,
1067 int increment)
1068 throws PortalException {
1069
1070 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
1071 fileEntryId);
1072
1073 if (incrementCounter) {
1074 dlFileEntryLocalService.incrementViewCounter(
1075 dlFileEntry, increment);
1076 }
1077
1078 return DLStoreUtil.getFile(
1079 dlFileEntry.getCompanyId(), dlFileEntry.getDataRepositoryId(),
1080 dlFileEntry.getName(), version);
1081 }
1082
1083
1087 @Deprecated
1088 @Override
1089 public InputStream getFileAsStream(
1090 long userId, long fileEntryId, String version)
1091 throws PortalException {
1092
1093 return getFileAsStream(fileEntryId, version, true, 1);
1094 }
1095
1096
1100 @Deprecated
1101 @Override
1102 public InputStream getFileAsStream(
1103 long userId, long fileEntryId, String version,
1104 boolean incrementCounter)
1105 throws PortalException {
1106
1107 return getFileAsStream(fileEntryId, version, incrementCounter, 1);
1108 }
1109
1110
1114 @Deprecated
1115 @Override
1116 public InputStream getFileAsStream(
1117 long userId, long fileEntryId, String version,
1118 boolean incrementCounter, int increment)
1119 throws PortalException {
1120
1121 return getFileAsStream(
1122 fileEntryId, version, incrementCounter, increment);
1123 }
1124
1125 @Override
1126 public InputStream getFileAsStream(long fileEntryId, String version)
1127 throws PortalException {
1128
1129 return getFileAsStream(fileEntryId, version, true, 1);
1130 }
1131
1132 @Override
1133 public InputStream getFileAsStream(
1134 long fileEntryId, String version, boolean incrementCounter)
1135 throws PortalException {
1136
1137 return getFileAsStream(fileEntryId, version, incrementCounter, 1);
1138 }
1139
1140 @Override
1141 public InputStream getFileAsStream(
1142 long fileEntryId, String version, boolean incrementCounter,
1143 int increment)
1144 throws PortalException {
1145
1146 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
1147 fileEntryId);
1148
1149 if (incrementCounter) {
1150 dlFileEntryLocalService.incrementViewCounter(
1151 dlFileEntry, increment);
1152 }
1153
1154 return DLStoreUtil.getFileAsStream(
1155 dlFileEntry.getCompanyId(), dlFileEntry.getDataRepositoryId(),
1156 dlFileEntry.getName(), version);
1157 }
1158
1159 @Override
1160 public List<DLFileEntry> getFileEntries(int start, int end) {
1161 return dlFileEntryPersistence.findAll(start, end);
1162 }
1163
1164 @Override
1165 public List<DLFileEntry> getFileEntries(long groupId, long folderId) {
1166 return dlFileEntryPersistence.findByG_F(groupId, folderId);
1167 }
1168
1169 @Override
1170 public List<DLFileEntry> getFileEntries(
1171 long groupId, long folderId, int status, int start, int end,
1172 OrderByComparator<DLFileEntry> obc) {
1173
1174 List<Long> folderIds = new ArrayList<>();
1175
1176 folderIds.add(folderId);
1177
1178 QueryDefinition<DLFileEntry> queryDefinition = new QueryDefinition<>(
1179 status, false, start, end, obc);
1180
1181 return dlFileEntryFinder.findByG_F(groupId, folderIds, queryDefinition);
1182 }
1183
1184 @Override
1185 public List<DLFileEntry> getFileEntries(
1186 long groupId, long folderId, int start, int end,
1187 OrderByComparator<DLFileEntry> obc) {
1188
1189 return dlFileEntryPersistence.findByG_F(
1190 groupId, folderId, start, end, obc);
1191 }
1192
1193 @Override
1194 public List<DLFileEntry> getFileEntries(
1195 long groupId, long userId, List<Long> repositoryIds,
1196 List<Long> folderIds, String[] mimeTypes,
1197 QueryDefinition<DLFileEntry> queryDefinition)
1198 throws Exception {
1199
1200 return dlFileEntryFinder.findByG_U_R_F_M(
1201 groupId, userId, repositoryIds, folderIds, mimeTypes,
1202 queryDefinition);
1203 }
1204
1205 @Override
1206 public List<DLFileEntry> getFileEntries(
1207 long groupId, long userId, List<Long> folderIds, String[] mimeTypes,
1208 QueryDefinition<DLFileEntry> queryDefinition)
1209 throws Exception {
1210
1211 return dlFileEntryFinder.findByG_U_F_M(
1212 groupId, userId, folderIds, mimeTypes, queryDefinition);
1213 }
1214
1215 @Override
1216 public List<DLFileEntry> getFileEntries(long folderId, String name) {
1217 return dlFileEntryPersistence.findByF_N(folderId, name);
1218 }
1219
1220 @Override
1221 public int getFileEntriesCount() {
1222 return dlFileEntryPersistence.countAll();
1223 }
1224
1225
1228 @Deprecated
1229 @Override
1230 public int getFileEntriesCount(
1231 long groupId, DateRange dateRange, long repositoryId,
1232 QueryDefinition<DLFileEntry> queryDefinition) {
1233
1234 return 0;
1235 }
1236
1237 @Override
1238 public int getFileEntriesCount(long groupId, long folderId) {
1239 return dlFileEntryPersistence.countByG_F(groupId, folderId);
1240 }
1241
1242 @Override
1243 public int getFileEntriesCount(long groupId, long folderId, int status) {
1244 List<Long> folderIds = new ArrayList<>();
1245
1246 folderIds.add(folderId);
1247
1248 return dlFileEntryFinder.countByG_F(
1249 groupId, folderIds, new QueryDefinition<DLFileEntry>(status));
1250 }
1251
1252 @Override
1253 public int getFileEntriesCount(
1254 long groupId, long userId, List<Long> repositoryIds,
1255 List<Long> folderIds, String[] mimeTypes,
1256 QueryDefinition<DLFileEntry> queryDefinition)
1257 throws Exception {
1258
1259 return dlFileEntryFinder.countByG_U_R_F_M(
1260 groupId, userId, repositoryIds, folderIds, mimeTypes,
1261 queryDefinition);
1262 }
1263
1264 @Override
1265 public int getFileEntriesCount(
1266 long groupId, long userId, List<Long> folderIds, String[] mimeTypes,
1267 QueryDefinition<DLFileEntry> queryDefinition)
1268 throws Exception {
1269
1270 return dlFileEntryFinder.countByG_U_F_M(
1271 groupId, userId, folderIds, mimeTypes, queryDefinition);
1272 }
1273
1274 @Override
1275 public DLFileEntry getFileEntry(long fileEntryId) throws PortalException {
1276 return dlFileEntryPersistence.findByPrimaryKey(fileEntryId);
1277 }
1278
1279 @Override
1280 public DLFileEntry getFileEntry(long groupId, long folderId, String title)
1281 throws PortalException {
1282
1283 DLFileEntry dlFileEntry = dlFileEntryPersistence.fetchByG_F_T(
1284 groupId, folderId, title);
1285
1286 if (dlFileEntry != null) {
1287 return dlFileEntry;
1288 }
1289
1290 List<DLFileVersion> dlFileVersions =
1291 dlFileVersionPersistence.findByG_F_T_V(
1292 groupId, folderId, title,
1293 DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION);
1294
1295 long userId = PrincipalThreadLocal.getUserId();
1296
1297 for (DLFileVersion dlFileVersion : dlFileVersions) {
1298 if (hasFileEntryLock(userId, dlFileVersion.getFileEntryId())) {
1299 return dlFileVersion.getFileEntry();
1300 }
1301 }
1302
1303 StringBundler sb = new StringBundler(8);
1304
1305 sb.append("No DLFileEntry exists with the key {");
1306 sb.append("groupId=");
1307 sb.append(groupId);
1308 sb.append(", folderId=");
1309 sb.append(folderId);
1310 sb.append(", title=");
1311 sb.append(title);
1312 sb.append(StringPool.CLOSE_CURLY_BRACE);
1313
1314 throw new NoSuchFileEntryException(sb.toString());
1315 }
1316
1317 @Override
1318 public DLFileEntry getFileEntryByName(
1319 long groupId, long folderId, String name)
1320 throws PortalException {
1321
1322 return dlFileEntryPersistence.findByG_F_N(groupId, folderId, name);
1323 }
1324
1325 @Override
1326 public DLFileEntry getFileEntryByUuidAndGroupId(String uuid, long groupId)
1327 throws PortalException {
1328
1329 return dlFileEntryPersistence.findByUUID_G(uuid, groupId);
1330 }
1331
1332 @Override
1333 public List<DLFileEntry> getGroupFileEntries(
1334 long groupId, int start, int end) {
1335
1336 return getGroupFileEntries(
1337 groupId, start, end,
1338 new RepositoryModelModifiedDateComparator<DLFileEntry>());
1339 }
1340
1341 @Override
1342 public List<DLFileEntry> getGroupFileEntries(
1343 long groupId, int start, int end, OrderByComparator<DLFileEntry> obc) {
1344
1345 return dlFileEntryPersistence.findByGroupId(groupId, start, end, obc);
1346 }
1347
1348 @Override
1349 public List<DLFileEntry> getGroupFileEntries(
1350 long groupId, long userId, int start, int end) {
1351
1352 return getGroupFileEntries(
1353 groupId, userId, start, end,
1354 new RepositoryModelModifiedDateComparator<DLFileEntry>());
1355 }
1356
1357 @Override
1358 public List<DLFileEntry> getGroupFileEntries(
1359 long groupId, long userId, int start, int end,
1360 OrderByComparator<DLFileEntry> obc) {
1361
1362 if (userId <= 0) {
1363 return dlFileEntryPersistence.findByGroupId(
1364 groupId, start, end, obc);
1365 }
1366 else {
1367 return dlFileEntryPersistence.findByG_U(
1368 groupId, userId, start, end, obc);
1369 }
1370 }
1371
1372 @Override
1373 public List<DLFileEntry> getGroupFileEntries(
1374 long groupId, long userId, long rootFolderId, int start, int end,
1375 OrderByComparator<DLFileEntry> obc) {
1376
1377 return getGroupFileEntries(
1378 groupId, userId, 0, rootFolderId, start, end, obc);
1379 }
1380
1381 @Override
1382 public List<DLFileEntry> getGroupFileEntries(
1383 long groupId, long userId, long repositoryId, long rootFolderId,
1384 int start, int end, OrderByComparator<DLFileEntry> obc) {
1385
1386 List<Long> folderIds = null;
1387
1388 if (repositoryId != 0) {
1389 folderIds = dlFolderLocalService.getRepositoryFolderIds(
1390 repositoryId, rootFolderId);
1391 }
1392 else {
1393 folderIds = dlFolderLocalService.getGroupFolderIds(
1394 groupId, rootFolderId);
1395 }
1396
1397 if (folderIds.isEmpty()) {
1398 return Collections.emptyList();
1399 }
1400
1401 QueryDefinition<DLFileEntry> queryDefinition = new QueryDefinition<>(
1402 WorkflowConstants.STATUS_ANY, start, end, obc);
1403
1404 if (repositoryId == 0) {
1405 if (userId <= 0) {
1406 return dlFileEntryFinder.findByG_F(
1407 groupId, folderIds, queryDefinition);
1408 }
1409 else {
1410 return dlFileEntryFinder.findByG_U_F(
1411 groupId, userId, folderIds, queryDefinition);
1412 }
1413 }
1414 else {
1415 List<Long> repositoryIds = new ArrayList<>();
1416
1417 repositoryIds.add(repositoryId);
1418
1419 if (userId <= 0) {
1420 return dlFileEntryFinder.findByG_R_F(
1421 groupId, repositoryIds, folderIds, queryDefinition);
1422 }
1423 else {
1424 return dlFileEntryFinder.findByG_U_R_F(
1425 groupId, userId, repositoryIds, folderIds, queryDefinition);
1426 }
1427 }
1428 }
1429
1430 @Override
1431 public int getGroupFileEntriesCount(long groupId) {
1432 return dlFileEntryPersistence.countByGroupId(groupId);
1433 }
1434
1435 @Override
1436 public int getGroupFileEntriesCount(long groupId, long userId) {
1437 if (userId <= 0) {
1438 return dlFileEntryPersistence.countByGroupId(groupId);
1439 }
1440 else {
1441 return dlFileEntryPersistence.countByG_U(groupId, userId);
1442 }
1443 }
1444
1445 @Override
1446 public List<DLFileEntry> getMisversionedFileEntries() {
1447 return dlFileEntryFinder.findByMisversioned();
1448 }
1449
1450 @Override
1451 public List<DLFileEntry> getNoAssetFileEntries() {
1452 return dlFileEntryFinder.findByNoAssets();
1453 }
1454
1455 @Override
1456 public List<DLFileEntry> getOrphanedFileEntries() {
1457 return dlFileEntryFinder.findByOrphanedFileEntries();
1458 }
1459
1460 @Override
1461 public List<DLFileEntry> getRepositoryFileEntries(
1462 long repositoryId, int start, int end) {
1463
1464 return dlFileEntryPersistence.findByRepositoryId(
1465 repositoryId, start, end);
1466 }
1467
1468 @Override
1469 public int getRepositoryFileEntriesCount(long repositoryId) {
1470 return dlFileEntryPersistence.countByRepositoryId(repositoryId);
1471 }
1472
1473 @Override
1474 public String getUniqueTitle(
1475 long groupId, long folderId, long fileEntryId, String title,
1476 String extension)
1477 throws PortalException {
1478
1479 String uniqueTitle = title;
1480
1481 for (int i = 1;; i++) {
1482 String uniqueFileName = DLUtil.getSanitizedFileName(
1483 uniqueTitle, extension);
1484
1485 try {
1486 validateFile(
1487 groupId, folderId, fileEntryId, uniqueFileName,
1488 uniqueTitle);
1489
1490 return uniqueTitle;
1491 }
1492 catch (PortalException pe) {
1493 if (!(pe instanceof DuplicateFolderNameException) &&
1494 !(pe instanceof DuplicateFileEntryException)) {
1495
1496 throw pe;
1497 }
1498 }
1499
1500 uniqueTitle = FileUtil.appendParentheticalSuffix(
1501 title, String.valueOf(i));
1502 }
1503 }
1504
1505 @Override
1506 public boolean hasExtraSettings() {
1507 if (dlFileEntryFinder.countByExtraSettings() > 0) {
1508 return true;
1509 }
1510 else {
1511 return false;
1512 }
1513 }
1514
1515 @Override
1516 public boolean hasFileEntryLock(long userId, long fileEntryId)
1517 throws PortalException {
1518
1519 DLFileEntry dlFileEntry = getFileEntry(fileEntryId);
1520
1521 long folderId = dlFileEntry.getFolderId();
1522
1523 boolean hasLock = LockManagerUtil.hasLock(
1524 userId, DLFileEntry.class.getName(), fileEntryId);
1525
1526 if (!hasLock &&
1527 (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID)) {
1528
1529 hasLock = dlFolderLocalService.hasInheritableLock(folderId);
1530 }
1531
1532 return hasLock;
1533 }
1534
1535 @BufferedIncrement(
1536 configuration = "DLFileEntry", incrementClass = NumberIncrement.class
1537 )
1538 @Override
1539 public void incrementViewCounter(DLFileEntry dlFileEntry, int increment) {
1540 if (ExportImportThreadLocal.isImportInProcess()) {
1541 return;
1542 }
1543
1544 dlFileEntry.setModifiedDate(dlFileEntry.getModifiedDate());
1545 dlFileEntry.setReadCount(dlFileEntry.getReadCount() + increment);
1546
1547 dlFileEntryPersistence.update(dlFileEntry);
1548 }
1549
1550 @Override
1551 public boolean isFileEntryCheckedOut(long fileEntryId)
1552 throws PortalException {
1553
1554 DLFileVersion dlFileVersion =
1555 dlFileVersionLocalService.getLatestFileVersion(fileEntryId, false);
1556
1557 String version = dlFileVersion.getVersion();
1558
1559 if (version.equals(DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION)) {
1560 return true;
1561 }
1562 else {
1563 return false;
1564 }
1565 }
1566
1567 @Override
1568 public boolean isKeepFileVersionLabel(
1569 long fileEntryId, ServiceContext serviceContext)
1570 throws PortalException {
1571
1572 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
1573 fileEntryId);
1574
1575 DLFileVersion lastDLFileVersion =
1576 dlFileVersionLocalService.getFileVersion(
1577 dlFileEntry.getFileEntryId(), dlFileEntry.getVersion());
1578
1579 DLFileVersion latestDLFileVersion =
1580 dlFileVersionLocalService.getLatestFileVersion(fileEntryId, false);
1581
1582 return isKeepFileVersionLabel(
1583 dlFileEntry, lastDLFileVersion, latestDLFileVersion,
1584 serviceContext);
1585 }
1586
1587 @Override
1588 public Lock lockFileEntry(long userId, long fileEntryId)
1589 throws PortalException {
1590
1591 if (hasFileEntryLock(userId, fileEntryId)) {
1592 return LockManagerUtil.getLock(
1593 DLFileEntry.class.getName(), fileEntryId);
1594 }
1595
1596 return LockManagerUtil.lock(
1597 userId, DLFileEntry.class.getName(), fileEntryId, null, false,
1598 DLFileEntryImpl.LOCK_EXPIRATION_TIME);
1599 }
1600
1601 @Indexable(type = IndexableType.REINDEX)
1602 @Override
1603 public DLFileEntry moveFileEntry(
1604 long userId, long fileEntryId, long newFolderId,
1605 ServiceContext serviceContext)
1606 throws PortalException {
1607
1608 if (!hasFileEntryLock(userId, fileEntryId)) {
1609 lockFileEntry(userId, fileEntryId);
1610 }
1611
1612 try {
1613 DLFileEntry dlFileEntry = moveFileEntryImpl(
1614 userId, fileEntryId, newFolderId, serviceContext);
1615
1616 return dlFileEntryTypeLocalService.updateFileEntryFileEntryType(
1617 dlFileEntry, serviceContext);
1618 }
1619 finally {
1620 if (!isFileEntryCheckedOut(fileEntryId)) {
1621 unlockFileEntry(fileEntryId);
1622 }
1623 }
1624 }
1625
1626 @Override
1627 public void rebuildTree(long companyId) throws PortalException {
1628 dlFolderLocalService.rebuildTree(companyId);
1629 }
1630
1631 @Override
1632 public void revertFileEntry(
1633 long userId, long fileEntryId, String version,
1634 ServiceContext serviceContext)
1635 throws PortalException {
1636
1637 if (Validator.isNull(version)) {
1638 throw new InvalidFileVersionException("Version is null");
1639 }
1640
1641 if (version.equals(DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION)) {
1642 throw new InvalidFileVersionException(
1643 "Unable to revert a private working copy file version");
1644 }
1645
1646 DLFileVersion dlFileVersion = dlFileVersionLocalService.getFileVersion(
1647 fileEntryId, version);
1648
1649 if (!dlFileVersion.isApproved()) {
1650 throw new InvalidFileVersionException(
1651 "Unable to revert from an unapproved file version");
1652 }
1653
1654 DLFileVersion latestDLFileVersion =
1655 dlFileVersionLocalService.getLatestFileVersion(fileEntryId, false);
1656
1657 if (version.equals(latestDLFileVersion.getVersion())) {
1658 throw new InvalidFileVersionException(
1659 "Unable to revert from the latest file version");
1660 }
1661
1662 String sourceFileName = dlFileVersion.getTitle();
1663 String extension = dlFileVersion.getExtension();
1664 String mimeType = dlFileVersion.getMimeType();
1665 String title = dlFileVersion.getTitle();
1666 String description = dlFileVersion.getDescription();
1667 String changeLog = LanguageUtil.format(
1668 serviceContext.getLocale(), "reverted-to-x", version, false);
1669 boolean majorVersion = true;
1670 String extraSettings = dlFileVersion.getExtraSettings();
1671 long fileEntryTypeId = dlFileVersion.getFileEntryTypeId();
1672 Map<String, DDMFormValues> ddmFormValuesMap = null;
1673 InputStream is = getFileAsStream(fileEntryId, version, false);
1674 long size = dlFileVersion.getSize();
1675
1676 serviceContext.setCommand(Constants.REVERT);
1677
1678 DLFileEntry dlFileEntry = updateFileEntry(
1679 userId, fileEntryId, sourceFileName, extension, mimeType, title,
1680 description, changeLog, majorVersion, extraSettings,
1681 fileEntryTypeId, ddmFormValuesMap, null, is, size, serviceContext);
1682
1683 DLFileVersion newDlFileVersion =
1684 dlFileVersionLocalService.getFileVersion(
1685 fileEntryId, dlFileEntry.getVersion());
1686
1687 copyFileEntryMetadata(
1688 dlFileVersion.getCompanyId(), dlFileVersion.getFileEntryTypeId(),
1689 fileEntryId, dlFileVersion.getFileVersionId(),
1690 newDlFileVersion.getFileVersionId(), serviceContext);
1691 }
1692
1693 @Override
1694 public Hits search(
1695 long groupId, long userId, long creatorUserId, int status,
1696 int start, int end)
1697 throws PortalException {
1698
1699 return search(
1700 groupId, userId, creatorUserId,
1701 DLFolderConstants.DEFAULT_PARENT_FOLDER_ID, null, status, start,
1702 end);
1703 }
1704
1705 @Override
1706 public Hits search(
1707 long groupId, long userId, long creatorUserId, long folderId,
1708 String[] mimeTypes, int status, int start, int end)
1709 throws PortalException {
1710
1711 Indexer<DLFileEntry> indexer = IndexerRegistryUtil.getIndexer(
1712 DLFileEntryConstants.getClassName());
1713
1714 SearchContext searchContext = new SearchContext();
1715
1716 searchContext.setAttribute(Field.STATUS, status);
1717
1718 if (creatorUserId > 0) {
1719 searchContext.setAttribute(
1720 Field.USER_ID, String.valueOf(creatorUserId));
1721 }
1722
1723 if (ArrayUtil.isNotEmpty(mimeTypes)) {
1724 searchContext.setAttribute("mimeTypes", mimeTypes);
1725 }
1726
1727 searchContext.setAttribute("paginationType", "none");
1728
1729 Group group = groupLocalService.getGroup(groupId);
1730
1731 searchContext.setCompanyId(group.getCompanyId());
1732
1733 searchContext.setEnd(end);
1734 searchContext.setFolderIds(new long[] {folderId});
1735 searchContext.setGroupIds(new long[] {groupId});
1736 searchContext.setSorts(new Sort(Field.MODIFIED_DATE, true));
1737 searchContext.setStart(start);
1738 searchContext.setUserId(userId);
1739
1740 return indexer.search(searchContext);
1741 }
1742
1743 @Override
1744 public void setTreePaths(
1745 final long folderId, final String treePath, final boolean reindex)
1746 throws PortalException {
1747
1748 if (treePath == null) {
1749 throw new IllegalArgumentException("Tree path is null");
1750 }
1751
1752 final IndexableActionableDynamicQuery indexableActionableDynamicQuery =
1753 getIndexableActionableDynamicQuery();
1754
1755 indexableActionableDynamicQuery.setAddCriteriaMethod(
1756 new ActionableDynamicQuery.AddCriteriaMethod() {
1757
1758 @Override
1759 public void addCriteria(DynamicQuery dynamicQuery) {
1760 Property folderIdProperty = PropertyFactoryUtil.forName(
1761 "folderId");
1762
1763 dynamicQuery.add(folderIdProperty.eq(folderId));
1764
1765 Property treePathProperty = PropertyFactoryUtil.forName(
1766 "treePath");
1767
1768 dynamicQuery.add(
1769 RestrictionsFactoryUtil.or(
1770 treePathProperty.isNull(),
1771 treePathProperty.ne(treePath)));
1772 }
1773
1774 });
1775
1776 final Indexer<DLFileEntry> indexer = IndexerRegistryUtil.getIndexer(
1777 DLFileEntry.class.getName());
1778
1779 indexableActionableDynamicQuery.setPerformActionMethod(
1780 new ActionableDynamicQuery.PerformActionMethod<DLFileEntry>() {
1781
1782 @Override
1783 public void performAction(DLFileEntry dlFileEntry)
1784 throws PortalException {
1785
1786 dlFileEntry.setTreePath(treePath);
1787
1788 updateDLFileEntry(dlFileEntry);
1789
1790 if (!reindex) {
1791 return;
1792 }
1793
1794 Document document = indexer.getDocument(dlFileEntry);
1795
1796 indexableActionableDynamicQuery.addDocuments(document);
1797 }
1798
1799 });
1800
1801 indexableActionableDynamicQuery.performActions();
1802 }
1803
1804 @Override
1805 public void unlockFileEntry(long fileEntryId) {
1806 LockManagerUtil.unlock(DLFileEntry.class.getName(), fileEntryId);
1807 }
1808
1809 @Override
1810 public DLFileEntry updateFileEntry(
1811 long userId, long fileEntryId, String sourceFileName,
1812 String mimeType, String title, String description, String changeLog,
1813 boolean majorVersion, long fileEntryTypeId,
1814 Map<String, DDMFormValues> ddmFormValuesMap, File file,
1815 InputStream is, long size, ServiceContext serviceContext)
1816 throws PortalException {
1817
1818 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
1819 fileEntryId);
1820
1821 String extension = DLAppUtil.getExtension(title, sourceFileName);
1822
1823 String extraSettings = StringPool.BLANK;
1824
1825 if (fileEntryTypeId == -1) {
1826 fileEntryTypeId = dlFileEntry.getFileEntryTypeId();
1827 }
1828
1829 validateFileEntryTypeId(
1830 PortalUtil.getCurrentAndAncestorSiteGroupIds(
1831 dlFileEntry.getGroupId()),
1832 dlFileEntry.getFolderId(), fileEntryTypeId);
1833
1834 return updateFileEntry(
1835 userId, fileEntryId, sourceFileName, extension, mimeType, title,
1836 description, changeLog, majorVersion, extraSettings,
1837 fileEntryTypeId, ddmFormValuesMap, file, is, size, serviceContext);
1838 }
1839
1840 @Override
1841 public DLFileEntry updateFileEntryType(
1842 long userId, long fileEntryId, long fileEntryTypeId,
1843 ServiceContext serviceContext)
1844 throws PortalException {
1845
1846 User user = userPersistence.findByPrimaryKey(userId);
1847
1848 DLFileEntry dlFileEntry = dlFileEntryLocalService.getFileEntry(
1849 fileEntryId);
1850
1851 dlFileEntry.setFileEntryTypeId(fileEntryTypeId);
1852
1853 dlFileEntryLocalService.updateDLFileEntry(dlFileEntry);
1854
1855 DLFileVersion dlFileVersion =
1856 dlFileVersionLocalService.getLatestFileVersion(
1857 fileEntryId, !dlFileEntry.isCheckedOut());
1858
1859 dlFileVersion.setUserId(user.getUserId());
1860 dlFileVersion.setUserName(user.getFullName());
1861 dlFileVersion.setFileEntryTypeId(fileEntryTypeId);
1862
1863 dlFileVersionLocalService.updateDLFileVersion(dlFileVersion);
1864
1865 return dlFileEntry;
1866 }
1867
1868 @Override
1869 public void updateSmallImage(long smallImageId, long largeImageId)
1870 throws PortalException {
1871
1872 try {
1873 RenderedImage renderedImage = null;
1874
1875 Image largeImage = imageLocalService.getImage(largeImageId);
1876
1877 byte[] bytes = largeImage.getTextObj();
1878 String contentType = largeImage.getType();
1879
1880 if (bytes != null) {
1881 ImageBag imageBag = ImageToolUtil.read(bytes);
1882
1883 renderedImage = imageBag.getRenderedImage();
1884
1885
1886 }
1887
1888 if (renderedImage != null) {
1889 int height = PrefsPropsUtil.getInteger(
1890 PropsKeys.DL_FILE_ENTRY_THUMBNAIL_MAX_HEIGHT);
1891 int width = PrefsPropsUtil.getInteger(
1892 PropsKeys.DL_FILE_ENTRY_THUMBNAIL_MAX_WIDTH);
1893
1894 RenderedImage thumbnailRenderedImage = ImageToolUtil.scale(
1895 renderedImage, height, width);
1896
1897 imageLocalService.updateImage(
1898 smallImageId,
1899 ImageToolUtil.getBytes(
1900 thumbnailRenderedImage, contentType));
1901 }
1902 }
1903 catch (IOException ioe) {
1904 throw new ImageSizeException(ioe);
1905 }
1906 }
1907
1908 @Override
1909 public DLFileEntry updateStatus(
1910 long userId, long fileVersionId, int status,
1911 ServiceContext serviceContext,
1912 Map<String, Serializable> workflowContext)
1913 throws PortalException {
1914
1915
1916
1917 User user = userPersistence.findByPrimaryKey(userId);
1918
1919 DLFileVersion dlFileVersion = dlFileVersionPersistence.findByPrimaryKey(
1920 fileVersionId);
1921
1922 int oldStatus = dlFileVersion.getStatus();
1923
1924 dlFileVersion.setStatus(status);
1925 dlFileVersion.setStatusByUserId(user.getUserId());
1926 dlFileVersion.setStatusByUserName(user.getFullName());
1927 dlFileVersion.setStatusDate(new Date());
1928
1929 dlFileVersionPersistence.update(dlFileVersion);
1930
1931
1932
1933 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
1934 dlFileVersion.getFileEntryId());
1935
1936 if (status == WorkflowConstants.STATUS_APPROVED) {
1937 if (DLUtil.compareVersions(
1938 dlFileEntry.getVersion(),
1939 dlFileVersion.getVersion()) <= 0) {
1940
1941 dlFileEntry.setFileName(dlFileVersion.getFileName());
1942 dlFileEntry.setExtension(dlFileVersion.getExtension());
1943 dlFileEntry.setMimeType(dlFileVersion.getMimeType());
1944 dlFileEntry.setTitle(dlFileVersion.getTitle());
1945 dlFileEntry.setDescription(dlFileVersion.getDescription());
1946 dlFileEntry.setExtraSettings(dlFileVersion.getExtraSettings());
1947 dlFileEntry.setFileEntryTypeId(
1948 dlFileVersion.getFileEntryTypeId());
1949 dlFileEntry.setVersion(dlFileVersion.getVersion());
1950 dlFileEntry.setModifiedDate(dlFileVersion.getCreateDate());
1951 dlFileEntry.setSize(dlFileVersion.getSize());
1952
1953 dlFileEntryPersistence.update(dlFileEntry);
1954 }
1955 }
1956 else {
1957
1958
1959
1960 if ((status != WorkflowConstants.STATUS_IN_TRASH) &&
1961 Validator.equals(
1962 dlFileEntry.getVersion(), dlFileVersion.getVersion())) {
1963
1964 String newVersion = DLFileEntryConstants.VERSION_DEFAULT;
1965
1966 List<DLFileVersion> approvedFileVersions =
1967 dlFileVersionPersistence.findByF_S(
1968 dlFileEntry.getFileEntryId(),
1969 WorkflowConstants.STATUS_APPROVED);
1970
1971 if (!approvedFileVersions.isEmpty()) {
1972 newVersion = approvedFileVersions.get(0).getVersion();
1973 }
1974
1975 dlFileEntry.setVersion(newVersion);
1976
1977 dlFileEntryPersistence.update(dlFileEntry);
1978 }
1979
1980
1981
1982 if (Validator.equals(
1983 dlFileVersion.getVersion(),
1984 DLFileEntryConstants.VERSION_DEFAULT)) {
1985
1986 Indexer<DLFileEntry> indexer =
1987 IndexerRegistryUtil.nullSafeGetIndexer(DLFileEntry.class);
1988
1989 indexer.delete(dlFileEntry);
1990 }
1991 }
1992
1993
1994
1995 dlAppHelperLocalService.updateStatus(
1996 userId, new LiferayFileEntry(dlFileEntry),
1997 new LiferayFileVersion(dlFileVersion), oldStatus, status,
1998 serviceContext, workflowContext);
1999
2000 if (PropsValues.DL_FILE_ENTRY_COMMENTS_ENABLED) {
2001 if (status == WorkflowConstants.STATUS_IN_TRASH) {
2002 CommentManagerUtil.moveDiscussionToTrash(
2003 DLFileEntry.class.getName(), dlFileEntry.getFileEntryId());
2004 }
2005 else if (oldStatus == WorkflowConstants.STATUS_IN_TRASH) {
2006 CommentManagerUtil.restoreDiscussionFromTrash(
2007 DLFileEntry.class.getName(), dlFileEntry.getFileEntryId());
2008 }
2009 }
2010
2011
2012
2013 if (((status == WorkflowConstants.STATUS_APPROVED) ||
2014 (status == WorkflowConstants.STATUS_IN_TRASH) ||
2015 (oldStatus == WorkflowConstants.STATUS_IN_TRASH)) &&
2016 ((serviceContext == null) || serviceContext.isIndexingEnabled())) {
2017
2018 reindex(dlFileEntry);
2019 }
2020
2021 return dlFileEntry;
2022 }
2023
2024 @Override
2025 public void validateFile(
2026 long groupId, long folderId, long fileEntryId, String fileName,
2027 String title)
2028 throws PortalException {
2029
2030 DLFolder dlFolder = dlFolderPersistence.fetchByG_P_N(
2031 groupId, folderId, title);
2032
2033 if (dlFolder != null) {
2034 throw new DuplicateFolderNameException(title);
2035 }
2036
2037 DLFileEntry dlFileEntry = dlFileEntryPersistence.fetchByG_F_T(
2038 groupId, folderId, title);
2039
2040 if ((dlFileEntry != null) &&
2041 (dlFileEntry.getFileEntryId() != fileEntryId)) {
2042
2043 throw new DuplicateFileEntryException(title);
2044 }
2045
2046 dlFileEntry = dlFileEntryPersistence.fetchByG_F_FN(
2047 groupId, folderId, fileName);
2048
2049 if ((dlFileEntry != null) &&
2050 (dlFileEntry.getFileEntryId() != fileEntryId)) {
2051
2052 throw new DuplicateFileEntryException(title);
2053 }
2054 }
2055
2056 @Override
2057 public boolean verifyFileEntryCheckOut(long fileEntryId, String lockUuid)
2058 throws PortalException {
2059
2060 if (verifyFileEntryLock(fileEntryId, lockUuid) &&
2061 isFileEntryCheckedOut(fileEntryId)) {
2062
2063 return true;
2064 }
2065 else {
2066 return false;
2067 }
2068 }
2069
2070 @Override
2071 public boolean verifyFileEntryLock(long fileEntryId, String lockUuid)
2072 throws PortalException {
2073
2074 boolean lockVerified = false;
2075
2076 try {
2077 Lock lock = LockManagerUtil.getLock(
2078 DLFileEntry.class.getName(), fileEntryId);
2079
2080 if (Validator.equals(lock.getUuid(), lockUuid)) {
2081 lockVerified = true;
2082 }
2083 }
2084 catch (PortalException pe) {
2085 if ((pe instanceof ExpiredLockException) ||
2086 (pe instanceof NoSuchLockException)) {
2087
2088 DLFileEntry dlFileEntry = dlFileEntryLocalService.getFileEntry(
2089 fileEntryId);
2090
2091 lockVerified = dlFolderLocalService.verifyInheritableLock(
2092 dlFileEntry.getFolderId(), lockUuid);
2093 }
2094 else {
2095 throw pe;
2096 }
2097 }
2098
2099 return lockVerified;
2100 }
2101
2102 protected DLFileVersion addFileVersion(
2103 User user, DLFileEntry dlFileEntry, String fileName,
2104 String extension, String mimeType, String title, String description,
2105 String changeLog, String extraSettings, long fileEntryTypeId,
2106 Map<String, DDMFormValues> ddmFormValuesMap, String version,
2107 long size, int status, ServiceContext serviceContext)
2108 throws PortalException {
2109
2110 long fileVersionId = counterLocalService.increment();
2111
2112 DLFileVersion dlFileVersion = dlFileVersionPersistence.create(
2113 fileVersionId);
2114
2115 String uuid = ParamUtil.getString(
2116 serviceContext, "fileVersionUuid", serviceContext.getUuid());
2117
2118 dlFileVersion.setUuid(uuid);
2119
2120 dlFileVersion.setGroupId(dlFileEntry.getGroupId());
2121 dlFileVersion.setCompanyId(dlFileEntry.getCompanyId());
2122 dlFileVersion.setUserId(user.getUserId());
2123 dlFileVersion.setUserName(user.getFullName());
2124 dlFileVersion.setRepositoryId(dlFileEntry.getRepositoryId());
2125 dlFileVersion.setFolderId(dlFileEntry.getFolderId());
2126 dlFileVersion.setFileEntryId(dlFileEntry.getFileEntryId());
2127 dlFileVersion.setTreePath(dlFileVersion.buildTreePath());
2128 dlFileVersion.setFileName(fileName);
2129 dlFileVersion.setExtension(extension);
2130 dlFileVersion.setMimeType(mimeType);
2131 dlFileVersion.setTitle(title);
2132 dlFileVersion.setDescription(description);
2133 dlFileVersion.setChangeLog(changeLog);
2134 dlFileVersion.setExtraSettings(extraSettings);
2135 dlFileVersion.setFileEntryTypeId(fileEntryTypeId);
2136 dlFileVersion.setVersion(version);
2137 dlFileVersion.setSize(size);
2138 dlFileVersion.setStatus(status);
2139 dlFileVersion.setStatusByUserId(user.getUserId());
2140 dlFileVersion.setStatusByUserName(user.getFullName());
2141 dlFileVersion.setStatusDate(dlFileEntry.getModifiedDate());
2142
2143 ExpandoBridge oldExpandoBridge = dlFileVersion.getExpandoBridge();
2144
2145 DLFileVersion latestFileVersion =
2146 dlFileVersionLocalService.fetchLatestFileVersion(
2147 dlFileEntry.getFileEntryId(), false);
2148
2149 if (latestFileVersion != null) {
2150 oldExpandoBridge = latestFileVersion.getExpandoBridge();
2151 }
2152
2153 ExpandoBridgeUtil.setExpandoBridgeAttributes(
2154 oldExpandoBridge, dlFileVersion.getExpandoBridge(), serviceContext);
2155
2156 dlFileVersionPersistence.update(dlFileVersion);
2157
2158 if ((fileEntryTypeId > 0) && (ddmFormValuesMap != null)) {
2159 dlFileEntryMetadataLocalService.updateFileEntryMetadata(
2160 fileEntryTypeId, dlFileEntry.getFileEntryId(), fileVersionId,
2161 ddmFormValuesMap, serviceContext);
2162 }
2163
2164 return dlFileVersion;
2165 }
2166
2167 protected void convertExtraSettings(
2168 DLFileEntry dlFileEntry, DLFileVersion dlFileVersion, String[] keys)
2169 throws PortalException {
2170
2171 UnicodeProperties extraSettingsProperties =
2172 dlFileVersion.getExtraSettingsProperties();
2173
2174 ExpandoBridge expandoBridge = dlFileVersion.getExpandoBridge();
2175
2176 convertExtraSettings(extraSettingsProperties, expandoBridge, keys);
2177
2178 dlFileVersion.setExtraSettingsProperties(extraSettingsProperties);
2179
2180 dlFileVersionPersistence.update(dlFileVersion);
2181
2182 int status = dlFileVersion.getStatus();
2183
2184 if ((status == WorkflowConstants.STATUS_APPROVED) &&
2185 (DLUtil.compareVersions(
2186 dlFileEntry.getVersion(), dlFileVersion.getVersion()) <= 0)) {
2187
2188 reindex(dlFileEntry);
2189 }
2190 }
2191
2192 protected void convertExtraSettings(DLFileEntry dlFileEntry, String[] keys)
2193 throws PortalException {
2194
2195 UnicodeProperties extraSettingsProperties =
2196 dlFileEntry.getExtraSettingsProperties();
2197
2198 ExpandoBridge expandoBridge = dlFileEntry.getExpandoBridge();
2199
2200 convertExtraSettings(extraSettingsProperties, expandoBridge, keys);
2201
2202 dlFileEntry.setExtraSettingsProperties(extraSettingsProperties);
2203
2204 dlFileEntryPersistence.update(dlFileEntry);
2205
2206 List<DLFileVersion> dlFileVersions =
2207 dlFileVersionLocalService.getFileVersions(
2208 dlFileEntry.getFileEntryId(), WorkflowConstants.STATUS_ANY);
2209
2210 for (DLFileVersion dlFileVersion : dlFileVersions) {
2211 convertExtraSettings(dlFileEntry, dlFileVersion, keys);
2212 }
2213 }
2214
2215 protected void convertExtraSettings(
2216 UnicodeProperties extraSettingsProperties, ExpandoBridge expandoBridge,
2217 String[] keys) {
2218
2219 for (String key : keys) {
2220 String value = extraSettingsProperties.remove(key);
2221
2222 if (Validator.isNull(value)) {
2223 continue;
2224 }
2225
2226 int type = expandoBridge.getAttributeType(key);
2227
2228 Serializable serializable = ExpandoColumnConstants.getSerializable(
2229 type, value);
2230
2231 expandoBridge.setAttribute(key, serializable);
2232 }
2233 }
2234
2235 protected void copyExpandoRowModifiedDate(
2236 long companyId, long sourceFileVersionId,
2237 long destinationFileVersionId) {
2238
2239 ExpandoTable expandoTable = expandoTableLocalService.fetchDefaultTable(
2240 companyId, DLFileEntry.class.getName());
2241
2242 if (expandoTable == null) {
2243 return;
2244 }
2245
2246 ExpandoRow sourceExpandoRow = expandoRowLocalService.fetchRow(
2247 expandoTable.getTableId(), sourceFileVersionId);
2248
2249 if (sourceExpandoRow == null) {
2250 return;
2251 }
2252
2253 ExpandoRow destinationExpandoRow = expandoRowLocalService.fetchRow(
2254 expandoTable.getTableId(), destinationFileVersionId);
2255
2256 if (destinationExpandoRow == null) {
2257 return;
2258 }
2259
2260 destinationExpandoRow.setModifiedDate(
2261 sourceExpandoRow.getModifiedDate());
2262
2263 expandoRowLocalService.updateExpandoRow(destinationExpandoRow);
2264 }
2265
2266 protected void copyFileEntryMetadata(
2267 long companyId, long fileEntryId, long fromFileVersionId,
2268 long toFileVersionId, ServiceContext serviceContext,
2269 Map<String, DDMFormValues> ddmFormValuesMap,
2270 List<DDMStructure> ddmStructures)
2271 throws PortalException {
2272
2273 for (DDMStructure ddmStructure : ddmStructures) {
2274 DLFileEntryMetadata dlFileEntryMetadata =
2275 dlFileEntryMetadataLocalService.fetchFileEntryMetadata(
2276 ddmStructure.getStructureId(), fromFileVersionId);
2277
2278 if (dlFileEntryMetadata == null) {
2279 continue;
2280 }
2281
2282 DDMFormValues ddmFormValues =
2283 StorageEngineManagerUtil.getDDMFormValues(
2284 dlFileEntryMetadata.getDDMStorageId());
2285
2286 ddmFormValuesMap.put(ddmStructure.getStructureKey(), ddmFormValues);
2287 }
2288
2289 if (!ddmFormValuesMap.isEmpty()) {
2290 dlFileEntryMetadataLocalService.updateFileEntryMetadata(
2291 companyId, ddmStructures, fileEntryId, toFileVersionId,
2292 ddmFormValuesMap, serviceContext);
2293 }
2294 }
2295
2296 protected RepositoryEventTrigger getFolderRepositoryEventTrigger(
2297 long groupId, long folderId)
2298 throws PortalException {
2299
2300 if (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
2301 return RepositoryUtil.getFolderRepositoryEventTrigger(folderId);
2302 }
2303
2304 return RepositoryUtil.getRepositoryEventTrigger(groupId);
2305 }
2306
2307 protected String getNextVersion(
2308 DLFileEntry dlFileEntry, boolean majorVersion, int workflowAction) {
2309
2310 String version = dlFileEntry.getVersion();
2311
2312 DLFileVersion dlFileVersion =
2313 dlFileVersionLocalService.fetchLatestFileVersion(
2314 dlFileEntry.getFileEntryId(), true);
2315
2316 if (dlFileVersion != null) {
2317 version = dlFileVersion.getVersion();
2318 }
2319
2320 if (workflowAction == WorkflowConstants.ACTION_SAVE_DRAFT) {
2321 majorVersion = false;
2322 }
2323
2324 int[] versionParts = StringUtil.split(version, StringPool.PERIOD, 0);
2325
2326 if (majorVersion) {
2327 versionParts[0]++;
2328 versionParts[1] = 0;
2329 }
2330 else {
2331 versionParts[1]++;
2332 }
2333
2334 return versionParts[0] + StringPool.PERIOD + versionParts[1];
2335 }
2336
2337
2343 protected boolean isKeepFileVersionLabel(
2344 DLFileEntry dlFileEntry, DLFileVersion lastDLFileVersion,
2345 DLFileVersion latestDLFileVersion, ServiceContext serviceContext)
2346 throws PortalException {
2347
2348 if (PropsValues.DL_FILE_ENTRY_VERSION_POLICY != 1) {
2349 return false;
2350 }
2351
2352 if (Validator.equals(serviceContext.getCommand(), Constants.REVERT)) {
2353 return false;
2354 }
2355
2356 if (!Validator.equals(
2357 lastDLFileVersion.getTitle(), latestDLFileVersion.getTitle())) {
2358
2359 return false;
2360 }
2361
2362 if (!Validator.equals(
2363 lastDLFileVersion.getDescription(),
2364 latestDLFileVersion.getDescription())) {
2365
2366 return false;
2367 }
2368
2369 if (lastDLFileVersion.getFileEntryTypeId() !=
2370 latestDLFileVersion.getFileEntryTypeId()) {
2371
2372 return false;
2373 }
2374
2375 if (serviceContext.getWorkflowAction() ==
2376 WorkflowConstants.ACTION_SAVE_DRAFT) {
2377
2378 return false;
2379 }
2380
2381
2382
2383 DLFileEntryType dlFileEntryType =
2384 lastDLFileVersion.getDLFileEntryType();
2385
2386 List<DDMStructure> ddmStructures = dlFileEntryType.getDDMStructures();
2387
2388 for (DDMStructure ddmStructure : ddmStructures) {
2389 DLFileEntryMetadata lastFileEntryMetadata =
2390 dlFileEntryMetadataLocalService.fetchFileEntryMetadata(
2391 ddmStructure.getStructureId(),
2392 lastDLFileVersion.getFileVersionId());
2393
2394 if (lastFileEntryMetadata == null) {
2395 return false;
2396 }
2397
2398 DLFileEntryMetadata latestFileEntryMetadata =
2399 dlFileEntryMetadataLocalService.getFileEntryMetadata(
2400 ddmStructure.getStructureId(),
2401 latestDLFileVersion.getFileVersionId());
2402
2403 DDMFormValues lastDDMFormValues =
2404 StorageEngineManagerUtil.getDDMFormValues(
2405 lastFileEntryMetadata.getDDMStorageId());
2406 DDMFormValues latestDDMFormValues =
2407 StorageEngineManagerUtil.getDDMFormValues(
2408 latestFileEntryMetadata.getDDMStorageId());
2409
2410 if (!lastDDMFormValues.equals(latestDDMFormValues)) {
2411 return false;
2412 }
2413 }
2414
2415
2416
2417 ExpandoBridge lastExpandoBridge = lastDLFileVersion.getExpandoBridge();
2418 ExpandoBridge latestExpandoBridge =
2419 latestDLFileVersion.getExpandoBridge();
2420
2421 Map<String, Serializable> lastAttributes =
2422 lastExpandoBridge.getAttributes();
2423 Map<String, Serializable> latestAttributes =
2424 latestExpandoBridge.getAttributes();
2425
2426 if (!lastAttributes.equals(latestAttributes)) {
2427 return false;
2428 }
2429
2430
2431
2432 long lastSize = lastDLFileVersion.getSize();
2433 long latestSize = latestDLFileVersion.getSize();
2434
2435 if ((lastSize == 0) && (latestSize >= 0)) {
2436 return true;
2437 }
2438
2439 if (lastSize != latestSize) {
2440 return false;
2441 }
2442
2443
2444
2445 InputStream lastInputStream = null;
2446 InputStream latestInputStream = null;
2447
2448 try {
2449 String lastChecksum = lastDLFileVersion.getChecksum();
2450
2451 if (Validator.isNull(lastChecksum)) {
2452 lastInputStream = DLStoreUtil.getFileAsStream(
2453 dlFileEntry.getCompanyId(),
2454 dlFileEntry.getDataRepositoryId(), dlFileEntry.getName(),
2455 lastDLFileVersion.getVersion());
2456
2457 lastChecksum = DigesterUtil.digestBase64(lastInputStream);
2458
2459 lastDLFileVersion.setChecksum(lastChecksum);
2460
2461 dlFileVersionPersistence.update(lastDLFileVersion);
2462 }
2463
2464 latestInputStream = DLStoreUtil.getFileAsStream(
2465 dlFileEntry.getCompanyId(), dlFileEntry.getDataRepositoryId(),
2466 dlFileEntry.getName(), latestDLFileVersion.getVersion());
2467
2468 String latestChecksum = DigesterUtil.digestBase64(
2469 latestInputStream);
2470
2471 if (lastChecksum.equals(latestChecksum)) {
2472 return true;
2473 }
2474
2475 latestDLFileVersion.setChecksum(latestChecksum);
2476
2477 dlFileVersionPersistence.update(latestDLFileVersion);
2478 }
2479 catch (Exception e) {
2480 if (_log.isWarnEnabled()) {
2481 _log.warn(e, e);
2482 }
2483 }
2484 finally {
2485 StreamUtil.cleanUp(lastInputStream);
2486 StreamUtil.cleanUp(latestInputStream);
2487 }
2488
2489 return false;
2490 }
2491
2492 protected DLFileEntry moveFileEntryImpl(
2493 long userId, long fileEntryId, long newFolderId,
2494 ServiceContext serviceContext)
2495 throws PortalException {
2496
2497
2498
2499 User user = userPersistence.findByPrimaryKey(userId);
2500 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
2501 fileEntryId);
2502
2503 long oldDataRepositoryId = dlFileEntry.getDataRepositoryId();
2504
2505 validateFile(
2506 dlFileEntry.getGroupId(), newFolderId, dlFileEntry.getFileEntryId(),
2507 dlFileEntry.getFileName(), dlFileEntry.getTitle());
2508
2509 dlFileEntry.setFolderId(newFolderId);
2510 dlFileEntry.setTreePath(dlFileEntry.buildTreePath());
2511
2512 dlFileEntryPersistence.update(dlFileEntry);
2513
2514
2515
2516 List<DLFileVersion> dlFileVersions =
2517 dlFileVersionPersistence.findByFileEntryId(fileEntryId);
2518
2519 for (DLFileVersion dlFileVersion : dlFileVersions) {
2520 dlFileVersion.setFolderId(newFolderId);
2521 dlFileVersion.setTreePath(dlFileVersion.buildTreePath());
2522
2523 dlFileVersionPersistence.update(dlFileVersion);
2524 }
2525
2526
2527
2528 if (newFolderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
2529 DLFolder dlFolder = dlFolderPersistence.findByPrimaryKey(
2530 newFolderId);
2531
2532 dlFolder.setModifiedDate(serviceContext.getModifiedDate(null));
2533
2534 dlFolderPersistence.update(dlFolder);
2535 }
2536
2537
2538
2539 DLStoreUtil.updateFile(
2540 user.getCompanyId(), oldDataRepositoryId,
2541 dlFileEntry.getDataRepositoryId(), dlFileEntry.getName());
2542
2543 return dlFileEntry;
2544 }
2545
2546 protected void reindex(DLFileEntry dlFileEntry) throws SearchException {
2547 Indexer<DLFileEntry> indexer = IndexerRegistryUtil.nullSafeGetIndexer(
2548 DLFileEntry.class);
2549
2550 indexer.reindex(dlFileEntry);
2551 }
2552
2553 protected void removeFileVersion(
2554 DLFileEntry dlFileEntry, DLFileVersion dlFileVersion)
2555 throws PortalException {
2556
2557 dlFileVersionPersistence.remove(dlFileVersion);
2558
2559 expandoRowLocalService.deleteRows(dlFileVersion.getFileVersionId());
2560
2561 dlFileEntryMetadataLocalService.deleteFileVersionFileEntryMetadata(
2562 dlFileVersion.getFileVersionId());
2563
2564 assetEntryLocalService.deleteEntry(
2565 DLFileEntryConstants.getClassName(), dlFileVersion.getPrimaryKey());
2566
2567 DLStoreUtil.deleteFile(
2568 dlFileEntry.getCompanyId(), dlFileEntry.getDataRepositoryId(),
2569 dlFileEntry.getName(),
2570 DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION);
2571
2572 unlockFileEntry(dlFileEntry.getFileEntryId());
2573 }
2574
2575 protected DLFileEntry updateFileEntry(
2576 long userId, long fileEntryId, String sourceFileName,
2577 String extension, String mimeType, String title, String description,
2578 String changeLog, boolean majorVersion, String extraSettings,
2579 long fileEntryTypeId, Map<String, DDMFormValues> ddmFormValuesMap,
2580 File file, InputStream is, long size, ServiceContext serviceContext)
2581 throws PortalException {
2582
2583 User user = userPersistence.findByPrimaryKey(userId);
2584 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
2585 fileEntryId);
2586
2587 boolean checkedOut = dlFileEntry.isCheckedOut();
2588
2589 DLFileVersion dlFileVersion =
2590 dlFileVersionLocalService.getLatestFileVersion(
2591 fileEntryId, !checkedOut);
2592
2593 boolean autoCheckIn = false;
2594
2595 if (!checkedOut && dlFileVersion.isApproved() &&
2596 !Validator.equals(
2597 dlFileVersion.getUuid(),
2598 serviceContext.getUuidWithoutReset())) {
2599
2600 autoCheckIn = true;
2601 }
2602
2603 if (autoCheckIn) {
2604 dlFileEntry = checkOutFileEntry(
2605 userId, fileEntryId, serviceContext);
2606 }
2607 else if (!checkedOut) {
2608 lockFileEntry(userId, fileEntryId);
2609 }
2610
2611 if (!hasFileEntryLock(userId, fileEntryId)) {
2612 lockFileEntry(userId, fileEntryId);
2613 }
2614
2615 if (checkedOut || autoCheckIn) {
2616 dlFileVersion = dlFileVersionLocalService.getLatestFileVersion(
2617 fileEntryId, false);
2618 }
2619
2620 try {
2621 if (Validator.isNull(extension)) {
2622 extension = dlFileEntry.getExtension();
2623 }
2624
2625 if (Validator.isNull(mimeType)) {
2626 mimeType = dlFileEntry.getMimeType();
2627 }
2628
2629 if (Validator.isNull(title)) {
2630 title = sourceFileName;
2631
2632 if (Validator.isNull(title)) {
2633 title = dlFileEntry.getTitle();
2634 }
2635 }
2636
2637 String fileName = DLUtil.getSanitizedFileName(title, extension);
2638
2639 Date now = new Date();
2640
2641 validateFile(
2642 dlFileEntry.getGroupId(), dlFileEntry.getFolderId(),
2643 dlFileEntry.getFileEntryId(), sourceFileName, fileName,
2644 extension, title);
2645
2646
2647
2648 String version = dlFileVersion.getVersion();
2649
2650 if (size == 0) {
2651 size = dlFileVersion.getSize();
2652 }
2653
2654 updateFileVersion(
2655 user, dlFileVersion, sourceFileName, fileName, extension,
2656 mimeType, title, description, changeLog, extraSettings,
2657 fileEntryTypeId, ddmFormValuesMap, version, size,
2658 dlFileVersion.getStatus(), serviceContext.getModifiedDate(now),
2659 serviceContext);
2660
2661
2662
2663 if (!checkedOut &&
2664 (dlFileEntry.getFolderId() !=
2665 DLFolderConstants.DEFAULT_PARENT_FOLDER_ID)) {
2666
2667 dlFolderLocalService.updateLastPostDate(
2668 dlFileEntry.getFolderId(),
2669 serviceContext.getModifiedDate(now));
2670 }
2671
2672
2673
2674 if ((file != null) || (is != null)) {
2675 DLStoreUtil.deleteFile(
2676 user.getCompanyId(), dlFileEntry.getDataRepositoryId(),
2677 dlFileEntry.getName(), version);
2678
2679 if (file != null) {
2680 DLStoreUtil.updateFile(
2681 user.getCompanyId(), dlFileEntry.getDataRepositoryId(),
2682 dlFileEntry.getName(), dlFileEntry.getExtension(),
2683 false, version, sourceFileName, file);
2684 }
2685 else {
2686 DLStoreUtil.updateFile(
2687 user.getCompanyId(), dlFileEntry.getDataRepositoryId(),
2688 dlFileEntry.getName(), dlFileEntry.getExtension(),
2689 false, version, sourceFileName, is);
2690 }
2691 }
2692
2693 if (autoCheckIn) {
2694 checkInFileEntry(
2695 userId, fileEntryId, majorVersion, changeLog,
2696 serviceContext);
2697 }
2698 }
2699 catch (PortalException pe) {
2700 if (autoCheckIn) {
2701 try {
2702 cancelCheckOut(userId, fileEntryId);
2703 }
2704 catch (Exception e) {
2705 _log.error(e, e);
2706 }
2707 }
2708
2709 throw pe;
2710 }
2711 catch (SystemException se) {
2712 if (autoCheckIn) {
2713 try {
2714 cancelCheckOut(userId, fileEntryId);
2715 }
2716 catch (Exception e) {
2717 _log.error(e, e);
2718 }
2719 }
2720
2721 throw se;
2722 }
2723 finally {
2724 if (!autoCheckIn && !checkedOut) {
2725 unlockFileEntry(fileEntryId);
2726 }
2727 }
2728
2729 return dlFileEntryPersistence.findByPrimaryKey(fileEntryId);
2730 }
2731
2732 protected DLFileVersion updateFileVersion(
2733 User user, DLFileVersion dlFileVersion, String sourceFileName,
2734 String fileName, String extension, String mimeType, String title,
2735 String description, String changeLog, String extraSettings,
2736 long fileEntryTypeId, Map<String, DDMFormValues> ddmFormValuesMap,
2737 String version, long size, int status, Date statusDate,
2738 ServiceContext serviceContext)
2739 throws PortalException {
2740
2741 dlFileVersion.setUserId(user.getUserId());
2742 dlFileVersion.setUserName(user.getFullName());
2743 dlFileVersion.setModifiedDate(statusDate);
2744 dlFileVersion.setFileName(fileName);
2745
2746 if (Validator.isNotNull(sourceFileName)) {
2747 dlFileVersion.setExtension(extension);
2748 dlFileVersion.setMimeType(mimeType);
2749 }
2750
2751 dlFileVersion.setTitle(title);
2752 dlFileVersion.setDescription(description);
2753 dlFileVersion.setChangeLog(changeLog);
2754 dlFileVersion.setExtraSettings(extraSettings);
2755 dlFileVersion.setFileEntryTypeId(fileEntryTypeId);
2756 dlFileVersion.setVersion(version);
2757 dlFileVersion.setSize(size);
2758 dlFileVersion.setStatus(status);
2759 dlFileVersion.setStatusByUserId(user.getUserId());
2760 dlFileVersion.setStatusByUserName(user.getFullName());
2761 dlFileVersion.setStatusDate(statusDate);
2762
2763 ExpandoBridgeUtil.setExpandoBridgeAttributes(
2764 dlFileVersion.getExpandoBridge(), dlFileVersion.getExpandoBridge(),
2765 serviceContext);
2766
2767 dlFileVersion = dlFileVersionPersistence.update(dlFileVersion);
2768
2769 if ((fileEntryTypeId > 0) && (ddmFormValuesMap != null)) {
2770 dlFileEntryMetadataLocalService.updateFileEntryMetadata(
2771 fileEntryTypeId, dlFileVersion.getFileEntryId(),
2772 dlFileVersion.getFileVersionId(), ddmFormValuesMap,
2773 serviceContext);
2774 }
2775
2776 return dlFileVersion;
2777 }
2778
2779 protected void validateFile(
2780 long groupId, long folderId, long fileEntryId,
2781 String sourceFileName, String fileName, String extension,
2782 String title)
2783 throws PortalException {
2784
2785 DLValidatorUtil.validateFileName(title);
2786
2787 validateFileExtension(extension);
2788
2789 validateFile(groupId, folderId, fileEntryId, fileName, title);
2790 }
2791
2792 protected void validateFileEntryTypeId(
2793 long[] groupIds, long folderId, long fileEntryTypeId)
2794 throws PortalException {
2795
2796 List<DLFileEntryType> dlFileEntryTypes =
2797 dlFileEntryTypeLocalService.getFolderFileEntryTypes(
2798 groupIds, folderId, true);
2799
2800 for (DLFileEntryType dlFileEntryType : dlFileEntryTypes) {
2801 if (dlFileEntryType.getFileEntryTypeId() == fileEntryTypeId) {
2802 return;
2803 }
2804 }
2805
2806 throw new InvalidFileEntryTypeException(
2807 "Invalid file entry type " + fileEntryTypeId + " for folder " +
2808 folderId);
2809 }
2810
2811 protected void validateFileExtension(String extension)
2812 throws PortalException {
2813
2814 if (Validator.isNotNull(extension)) {
2815 int maxLength = ModelHintsUtil.getMaxLength(
2816 DLFileEntry.class.getName(), "extension");
2817
2818 if (extension.length() > maxLength) {
2819 throw new FileExtensionException(
2820 extension + " exceeds max length of " + maxLength);
2821 }
2822 }
2823 }
2824
2825 private static final Log _log = LogFactoryUtil.getLog(
2826 DLFileEntryLocalServiceImpl.class);
2827
2828 }