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 = dlFileEntryLocalService.getFileEntry(
1679 fileEntryId);
1680
1681 try {
1682 validateFileEntryTypeId(
1683 PortalUtil.getCurrentAndAncestorSiteGroupIds(
1684 dlFileEntry.getGroupId()),
1685 dlFileEntry.getFolderId(), fileEntryTypeId);
1686 }
1687 catch (InvalidFileEntryTypeException ifete) {
1688 fileEntryTypeId =
1689 dlFileEntryTypeLocalService.getDefaultFileEntryTypeId(
1690 dlFileEntry.getFolderId());
1691 }
1692
1693 updateFileEntry(
1694 userId, fileEntryId, sourceFileName, extension, mimeType, title,
1695 description, changeLog, majorVersion, extraSettings,
1696 fileEntryTypeId, ddmFormValuesMap, null, is, size, serviceContext);
1697
1698 DLFileVersion newDlFileVersion =
1699 dlFileVersionLocalService.getLatestFileVersion(fileEntryId, false);
1700
1701 copyFileEntryMetadata(
1702 dlFileVersion.getCompanyId(), dlFileVersion.getFileEntryTypeId(),
1703 fileEntryId, dlFileVersion.getFileVersionId(),
1704 newDlFileVersion.getFileVersionId(), serviceContext);
1705 }
1706
1707 @Override
1708 public Hits search(
1709 long groupId, long userId, long creatorUserId, int status,
1710 int start, int end)
1711 throws PortalException {
1712
1713 return search(
1714 groupId, userId, creatorUserId,
1715 DLFolderConstants.DEFAULT_PARENT_FOLDER_ID, null, status, start,
1716 end);
1717 }
1718
1719 @Override
1720 public Hits search(
1721 long groupId, long userId, long creatorUserId, long folderId,
1722 String[] mimeTypes, int status, int start, int end)
1723 throws PortalException {
1724
1725 Indexer<DLFileEntry> indexer = IndexerRegistryUtil.getIndexer(
1726 DLFileEntryConstants.getClassName());
1727
1728 SearchContext searchContext = new SearchContext();
1729
1730 searchContext.setAttribute(Field.STATUS, status);
1731
1732 if (creatorUserId > 0) {
1733 searchContext.setAttribute(
1734 Field.USER_ID, String.valueOf(creatorUserId));
1735 }
1736
1737 if (ArrayUtil.isNotEmpty(mimeTypes)) {
1738 searchContext.setAttribute("mimeTypes", mimeTypes);
1739 }
1740
1741 searchContext.setAttribute("paginationType", "none");
1742
1743 Group group = groupLocalService.getGroup(groupId);
1744
1745 searchContext.setCompanyId(group.getCompanyId());
1746
1747 searchContext.setEnd(end);
1748 searchContext.setFolderIds(new long[] {folderId});
1749 searchContext.setGroupIds(new long[] {groupId});
1750 searchContext.setSorts(new Sort(Field.MODIFIED_DATE, true));
1751 searchContext.setStart(start);
1752 searchContext.setUserId(userId);
1753
1754 return indexer.search(searchContext);
1755 }
1756
1757 @Override
1758 public void setTreePaths(
1759 final long folderId, final String treePath, final boolean reindex)
1760 throws PortalException {
1761
1762 if (treePath == null) {
1763 throw new IllegalArgumentException("Tree path is null");
1764 }
1765
1766 final IndexableActionableDynamicQuery indexableActionableDynamicQuery =
1767 getIndexableActionableDynamicQuery();
1768
1769 indexableActionableDynamicQuery.setAddCriteriaMethod(
1770 new ActionableDynamicQuery.AddCriteriaMethod() {
1771
1772 @Override
1773 public void addCriteria(DynamicQuery dynamicQuery) {
1774 Property folderIdProperty = PropertyFactoryUtil.forName(
1775 "folderId");
1776
1777 dynamicQuery.add(folderIdProperty.eq(folderId));
1778
1779 Property treePathProperty = PropertyFactoryUtil.forName(
1780 "treePath");
1781
1782 dynamicQuery.add(
1783 RestrictionsFactoryUtil.or(
1784 treePathProperty.isNull(),
1785 treePathProperty.ne(treePath)));
1786 }
1787
1788 });
1789
1790 final Indexer<DLFileEntry> indexer = IndexerRegistryUtil.getIndexer(
1791 DLFileEntry.class.getName());
1792
1793 indexableActionableDynamicQuery.setPerformActionMethod(
1794 new ActionableDynamicQuery.PerformActionMethod<DLFileEntry>() {
1795
1796 @Override
1797 public void performAction(DLFileEntry dlFileEntry)
1798 throws PortalException {
1799
1800 dlFileEntry.setTreePath(treePath);
1801
1802 updateDLFileEntry(dlFileEntry);
1803
1804 if (!reindex) {
1805 return;
1806 }
1807
1808 Document document = indexer.getDocument(dlFileEntry);
1809
1810 indexableActionableDynamicQuery.addDocuments(document);
1811 }
1812
1813 });
1814
1815 indexableActionableDynamicQuery.performActions();
1816 }
1817
1818 @Override
1819 public void unlockFileEntry(long fileEntryId) {
1820 LockManagerUtil.unlock(DLFileEntry.class.getName(), fileEntryId);
1821 }
1822
1823 @Override
1824 public DLFileEntry updateFileEntry(
1825 long userId, long fileEntryId, String sourceFileName,
1826 String mimeType, String title, String description, String changeLog,
1827 boolean majorVersion, long fileEntryTypeId,
1828 Map<String, DDMFormValues> ddmFormValuesMap, File file,
1829 InputStream is, long size, ServiceContext serviceContext)
1830 throws PortalException {
1831
1832 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
1833 fileEntryId);
1834
1835 String extension = DLAppUtil.getExtension(title, sourceFileName);
1836
1837 String extraSettings = StringPool.BLANK;
1838
1839 if (fileEntryTypeId == -1) {
1840 fileEntryTypeId = dlFileEntry.getFileEntryTypeId();
1841 }
1842
1843 validateFileEntryTypeId(
1844 PortalUtil.getCurrentAndAncestorSiteGroupIds(
1845 dlFileEntry.getGroupId()),
1846 dlFileEntry.getFolderId(), fileEntryTypeId);
1847
1848 return updateFileEntry(
1849 userId, fileEntryId, sourceFileName, extension, mimeType, title,
1850 description, changeLog, majorVersion, extraSettings,
1851 fileEntryTypeId, ddmFormValuesMap, file, is, size, serviceContext);
1852 }
1853
1854 @Override
1855 public DLFileEntry updateFileEntryType(
1856 long userId, long fileEntryId, long fileEntryTypeId,
1857 ServiceContext serviceContext)
1858 throws PortalException {
1859
1860 User user = userPersistence.findByPrimaryKey(userId);
1861
1862 DLFileEntry dlFileEntry = dlFileEntryLocalService.getFileEntry(
1863 fileEntryId);
1864
1865 dlFileEntry.setFileEntryTypeId(fileEntryTypeId);
1866
1867 dlFileEntryLocalService.updateDLFileEntry(dlFileEntry);
1868
1869 DLFileVersion dlFileVersion =
1870 dlFileVersionLocalService.getLatestFileVersion(
1871 fileEntryId, !dlFileEntry.isCheckedOut());
1872
1873 dlFileVersion.setUserId(user.getUserId());
1874 dlFileVersion.setUserName(user.getFullName());
1875 dlFileVersion.setFileEntryTypeId(fileEntryTypeId);
1876
1877 dlFileVersionLocalService.updateDLFileVersion(dlFileVersion);
1878
1879 return dlFileEntry;
1880 }
1881
1882 @Override
1883 public void updateSmallImage(long smallImageId, long largeImageId)
1884 throws PortalException {
1885
1886 try {
1887 RenderedImage renderedImage = null;
1888
1889 Image largeImage = imageLocalService.getImage(largeImageId);
1890
1891 byte[] bytes = largeImage.getTextObj();
1892 String contentType = largeImage.getType();
1893
1894 if (bytes != null) {
1895 ImageBag imageBag = ImageToolUtil.read(bytes);
1896
1897 renderedImage = imageBag.getRenderedImage();
1898
1899
1900 }
1901
1902 if (renderedImage != null) {
1903 int height = PrefsPropsUtil.getInteger(
1904 PropsKeys.DL_FILE_ENTRY_THUMBNAIL_MAX_HEIGHT);
1905 int width = PrefsPropsUtil.getInteger(
1906 PropsKeys.DL_FILE_ENTRY_THUMBNAIL_MAX_WIDTH);
1907
1908 RenderedImage thumbnailRenderedImage = ImageToolUtil.scale(
1909 renderedImage, height, width);
1910
1911 imageLocalService.updateImage(
1912 smallImageId,
1913 ImageToolUtil.getBytes(
1914 thumbnailRenderedImage, contentType));
1915 }
1916 }
1917 catch (IOException ioe) {
1918 throw new ImageSizeException(ioe);
1919 }
1920 }
1921
1922 @Override
1923 public DLFileEntry updateStatus(
1924 long userId, long fileVersionId, int status,
1925 ServiceContext serviceContext,
1926 Map<String, Serializable> workflowContext)
1927 throws PortalException {
1928
1929
1930
1931 User user = userPersistence.findByPrimaryKey(userId);
1932
1933 DLFileVersion dlFileVersion = dlFileVersionPersistence.findByPrimaryKey(
1934 fileVersionId);
1935
1936 int oldStatus = dlFileVersion.getStatus();
1937
1938 dlFileVersion.setStatus(status);
1939 dlFileVersion.setStatusByUserId(user.getUserId());
1940 dlFileVersion.setStatusByUserName(user.getFullName());
1941 dlFileVersion.setStatusDate(new Date());
1942
1943 dlFileVersionPersistence.update(dlFileVersion);
1944
1945
1946
1947 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
1948 dlFileVersion.getFileEntryId());
1949
1950 if (status == WorkflowConstants.STATUS_APPROVED) {
1951 if (DLUtil.compareVersions(
1952 dlFileEntry.getVersion(),
1953 dlFileVersion.getVersion()) <= 0) {
1954
1955 dlFileEntry.setFileName(dlFileVersion.getFileName());
1956 dlFileEntry.setExtension(dlFileVersion.getExtension());
1957 dlFileEntry.setMimeType(dlFileVersion.getMimeType());
1958 dlFileEntry.setTitle(dlFileVersion.getTitle());
1959 dlFileEntry.setDescription(dlFileVersion.getDescription());
1960 dlFileEntry.setExtraSettings(dlFileVersion.getExtraSettings());
1961 dlFileEntry.setFileEntryTypeId(
1962 dlFileVersion.getFileEntryTypeId());
1963 dlFileEntry.setVersion(dlFileVersion.getVersion());
1964 dlFileEntry.setModifiedDate(dlFileVersion.getCreateDate());
1965 dlFileEntry.setSize(dlFileVersion.getSize());
1966
1967 dlFileEntryPersistence.update(dlFileEntry);
1968 }
1969 }
1970 else {
1971
1972
1973
1974 if ((status != WorkflowConstants.STATUS_IN_TRASH) &&
1975 Validator.equals(
1976 dlFileEntry.getVersion(), dlFileVersion.getVersion())) {
1977
1978 String newVersion = DLFileEntryConstants.VERSION_DEFAULT;
1979
1980 List<DLFileVersion> approvedFileVersions =
1981 dlFileVersionPersistence.findByF_S(
1982 dlFileEntry.getFileEntryId(),
1983 WorkflowConstants.STATUS_APPROVED);
1984
1985 if (!approvedFileVersions.isEmpty()) {
1986 newVersion = approvedFileVersions.get(0).getVersion();
1987 }
1988
1989 dlFileEntry.setVersion(newVersion);
1990
1991 dlFileEntryPersistence.update(dlFileEntry);
1992 }
1993
1994
1995
1996 if (Validator.equals(
1997 dlFileVersion.getVersion(),
1998 DLFileEntryConstants.VERSION_DEFAULT)) {
1999
2000 Indexer<DLFileEntry> indexer =
2001 IndexerRegistryUtil.nullSafeGetIndexer(DLFileEntry.class);
2002
2003 indexer.delete(dlFileEntry);
2004 }
2005 }
2006
2007
2008
2009 dlAppHelperLocalService.updateStatus(
2010 userId, new LiferayFileEntry(dlFileEntry),
2011 new LiferayFileVersion(dlFileVersion), oldStatus, status,
2012 serviceContext, workflowContext);
2013
2014 if (PropsValues.DL_FILE_ENTRY_COMMENTS_ENABLED) {
2015 if (status == WorkflowConstants.STATUS_IN_TRASH) {
2016 CommentManagerUtil.moveDiscussionToTrash(
2017 DLFileEntry.class.getName(), dlFileEntry.getFileEntryId());
2018 }
2019 else if (oldStatus == WorkflowConstants.STATUS_IN_TRASH) {
2020 CommentManagerUtil.restoreDiscussionFromTrash(
2021 DLFileEntry.class.getName(), dlFileEntry.getFileEntryId());
2022 }
2023 }
2024
2025
2026
2027 if (((status == WorkflowConstants.STATUS_APPROVED) ||
2028 (status == WorkflowConstants.STATUS_IN_TRASH) ||
2029 (oldStatus == WorkflowConstants.STATUS_IN_TRASH)) &&
2030 ((serviceContext == null) || serviceContext.isIndexingEnabled())) {
2031
2032 reindex(dlFileEntry);
2033 }
2034
2035 return dlFileEntry;
2036 }
2037
2038 @Override
2039 public void validateFile(
2040 long groupId, long folderId, long fileEntryId, String fileName,
2041 String title)
2042 throws PortalException {
2043
2044 DLFolder dlFolder = dlFolderPersistence.fetchByG_P_N(
2045 groupId, folderId, title);
2046
2047 if (dlFolder != null) {
2048 throw new DuplicateFolderNameException(title);
2049 }
2050
2051 DLFileEntry dlFileEntry = dlFileEntryPersistence.fetchByG_F_T(
2052 groupId, folderId, title);
2053
2054 if ((dlFileEntry != null) &&
2055 (dlFileEntry.getFileEntryId() != fileEntryId)) {
2056
2057 throw new DuplicateFileEntryException(title);
2058 }
2059
2060 dlFileEntry = dlFileEntryPersistence.fetchByG_F_FN(
2061 groupId, folderId, fileName);
2062
2063 if ((dlFileEntry != null) &&
2064 (dlFileEntry.getFileEntryId() != fileEntryId)) {
2065
2066 throw new DuplicateFileEntryException(title);
2067 }
2068 }
2069
2070 @Override
2071 public boolean verifyFileEntryCheckOut(long fileEntryId, String lockUuid)
2072 throws PortalException {
2073
2074 if (verifyFileEntryLock(fileEntryId, lockUuid) &&
2075 isFileEntryCheckedOut(fileEntryId)) {
2076
2077 return true;
2078 }
2079 else {
2080 return false;
2081 }
2082 }
2083
2084 @Override
2085 public boolean verifyFileEntryLock(long fileEntryId, String lockUuid)
2086 throws PortalException {
2087
2088 boolean lockVerified = false;
2089
2090 try {
2091 Lock lock = LockManagerUtil.getLock(
2092 DLFileEntry.class.getName(), fileEntryId);
2093
2094 if (Validator.equals(lock.getUuid(), lockUuid)) {
2095 lockVerified = true;
2096 }
2097 }
2098 catch (PortalException pe) {
2099 if ((pe instanceof ExpiredLockException) ||
2100 (pe instanceof NoSuchLockException)) {
2101
2102 DLFileEntry dlFileEntry = dlFileEntryLocalService.getFileEntry(
2103 fileEntryId);
2104
2105 lockVerified = dlFolderLocalService.verifyInheritableLock(
2106 dlFileEntry.getFolderId(), lockUuid);
2107 }
2108 else {
2109 throw pe;
2110 }
2111 }
2112
2113 return lockVerified;
2114 }
2115
2116 protected DLFileVersion addFileVersion(
2117 User user, DLFileEntry dlFileEntry, String fileName,
2118 String extension, String mimeType, String title, String description,
2119 String changeLog, String extraSettings, long fileEntryTypeId,
2120 Map<String, DDMFormValues> ddmFormValuesMap, String version,
2121 long size, int status, ServiceContext serviceContext)
2122 throws PortalException {
2123
2124 long fileVersionId = counterLocalService.increment();
2125
2126 DLFileVersion dlFileVersion = dlFileVersionPersistence.create(
2127 fileVersionId);
2128
2129 String uuid = ParamUtil.getString(
2130 serviceContext, "fileVersionUuid", serviceContext.getUuid());
2131
2132 dlFileVersion.setUuid(uuid);
2133
2134 dlFileVersion.setGroupId(dlFileEntry.getGroupId());
2135 dlFileVersion.setCompanyId(dlFileEntry.getCompanyId());
2136 dlFileVersion.setUserId(user.getUserId());
2137 dlFileVersion.setUserName(user.getFullName());
2138 dlFileVersion.setRepositoryId(dlFileEntry.getRepositoryId());
2139 dlFileVersion.setFolderId(dlFileEntry.getFolderId());
2140 dlFileVersion.setFileEntryId(dlFileEntry.getFileEntryId());
2141 dlFileVersion.setTreePath(dlFileVersion.buildTreePath());
2142 dlFileVersion.setFileName(fileName);
2143 dlFileVersion.setExtension(extension);
2144 dlFileVersion.setMimeType(mimeType);
2145 dlFileVersion.setTitle(title);
2146 dlFileVersion.setDescription(description);
2147 dlFileVersion.setChangeLog(changeLog);
2148 dlFileVersion.setExtraSettings(extraSettings);
2149 dlFileVersion.setFileEntryTypeId(fileEntryTypeId);
2150 dlFileVersion.setVersion(version);
2151 dlFileVersion.setSize(size);
2152 dlFileVersion.setStatus(status);
2153 dlFileVersion.setStatusByUserId(user.getUserId());
2154 dlFileVersion.setStatusByUserName(user.getFullName());
2155 dlFileVersion.setStatusDate(dlFileEntry.getModifiedDate());
2156
2157 ExpandoBridge oldExpandoBridge = dlFileVersion.getExpandoBridge();
2158
2159 DLFileVersion latestFileVersion =
2160 dlFileVersionLocalService.fetchLatestFileVersion(
2161 dlFileEntry.getFileEntryId(), false);
2162
2163 if (latestFileVersion != null) {
2164 oldExpandoBridge = latestFileVersion.getExpandoBridge();
2165 }
2166
2167 ExpandoBridgeUtil.setExpandoBridgeAttributes(
2168 oldExpandoBridge, dlFileVersion.getExpandoBridge(), serviceContext);
2169
2170 dlFileVersionPersistence.update(dlFileVersion);
2171
2172 if ((fileEntryTypeId > 0) && (ddmFormValuesMap != null)) {
2173 dlFileEntryMetadataLocalService.updateFileEntryMetadata(
2174 fileEntryTypeId, dlFileEntry.getFileEntryId(), fileVersionId,
2175 ddmFormValuesMap, serviceContext);
2176 }
2177
2178 return dlFileVersion;
2179 }
2180
2181 protected void convertExtraSettings(
2182 DLFileEntry dlFileEntry, DLFileVersion dlFileVersion, String[] keys)
2183 throws PortalException {
2184
2185 UnicodeProperties extraSettingsProperties =
2186 dlFileVersion.getExtraSettingsProperties();
2187
2188 ExpandoBridge expandoBridge = dlFileVersion.getExpandoBridge();
2189
2190 convertExtraSettings(extraSettingsProperties, expandoBridge, keys);
2191
2192 dlFileVersion.setExtraSettingsProperties(extraSettingsProperties);
2193
2194 dlFileVersionPersistence.update(dlFileVersion);
2195
2196 int status = dlFileVersion.getStatus();
2197
2198 if ((status == WorkflowConstants.STATUS_APPROVED) &&
2199 (DLUtil.compareVersions(
2200 dlFileEntry.getVersion(), dlFileVersion.getVersion()) <= 0)) {
2201
2202 reindex(dlFileEntry);
2203 }
2204 }
2205
2206 protected void convertExtraSettings(DLFileEntry dlFileEntry, String[] keys)
2207 throws PortalException {
2208
2209 UnicodeProperties extraSettingsProperties =
2210 dlFileEntry.getExtraSettingsProperties();
2211
2212 ExpandoBridge expandoBridge = dlFileEntry.getExpandoBridge();
2213
2214 convertExtraSettings(extraSettingsProperties, expandoBridge, keys);
2215
2216 dlFileEntry.setExtraSettingsProperties(extraSettingsProperties);
2217
2218 dlFileEntryPersistence.update(dlFileEntry);
2219
2220 List<DLFileVersion> dlFileVersions =
2221 dlFileVersionLocalService.getFileVersions(
2222 dlFileEntry.getFileEntryId(), WorkflowConstants.STATUS_ANY);
2223
2224 for (DLFileVersion dlFileVersion : dlFileVersions) {
2225 convertExtraSettings(dlFileEntry, dlFileVersion, keys);
2226 }
2227 }
2228
2229 protected void convertExtraSettings(
2230 UnicodeProperties extraSettingsProperties, ExpandoBridge expandoBridge,
2231 String[] keys) {
2232
2233 for (String key : keys) {
2234 String value = extraSettingsProperties.remove(key);
2235
2236 if (Validator.isNull(value)) {
2237 continue;
2238 }
2239
2240 int type = expandoBridge.getAttributeType(key);
2241
2242 Serializable serializable = ExpandoColumnConstants.getSerializable(
2243 type, value);
2244
2245 expandoBridge.setAttribute(key, serializable);
2246 }
2247 }
2248
2249 protected void copyExpandoRowModifiedDate(
2250 long companyId, long sourceFileVersionId,
2251 long destinationFileVersionId) {
2252
2253 ExpandoTable expandoTable = expandoTableLocalService.fetchDefaultTable(
2254 companyId, DLFileEntry.class.getName());
2255
2256 if (expandoTable == null) {
2257 return;
2258 }
2259
2260 ExpandoRow sourceExpandoRow = expandoRowLocalService.fetchRow(
2261 expandoTable.getTableId(), sourceFileVersionId);
2262
2263 if (sourceExpandoRow == null) {
2264 return;
2265 }
2266
2267 ExpandoRow destinationExpandoRow = expandoRowLocalService.fetchRow(
2268 expandoTable.getTableId(), destinationFileVersionId);
2269
2270 if (destinationExpandoRow == null) {
2271 return;
2272 }
2273
2274 destinationExpandoRow.setModifiedDate(
2275 sourceExpandoRow.getModifiedDate());
2276
2277 expandoRowLocalService.updateExpandoRow(destinationExpandoRow);
2278 }
2279
2280 protected void copyFileEntryMetadata(
2281 long companyId, long fileEntryId, long fromFileVersionId,
2282 long toFileVersionId, ServiceContext serviceContext,
2283 Map<String, DDMFormValues> ddmFormValuesMap,
2284 List<DDMStructure> ddmStructures)
2285 throws PortalException {
2286
2287 for (DDMStructure ddmStructure : ddmStructures) {
2288 DLFileEntryMetadata dlFileEntryMetadata =
2289 dlFileEntryMetadataLocalService.fetchFileEntryMetadata(
2290 ddmStructure.getStructureId(), fromFileVersionId);
2291
2292 if (dlFileEntryMetadata == null) {
2293 continue;
2294 }
2295
2296 DDMFormValues ddmFormValues =
2297 StorageEngineManagerUtil.getDDMFormValues(
2298 dlFileEntryMetadata.getDDMStorageId());
2299
2300 ddmFormValuesMap.put(ddmStructure.getStructureKey(), ddmFormValues);
2301 }
2302
2303 if (!ddmFormValuesMap.isEmpty()) {
2304 dlFileEntryMetadataLocalService.updateFileEntryMetadata(
2305 companyId, ddmStructures, fileEntryId, toFileVersionId,
2306 ddmFormValuesMap, serviceContext);
2307 }
2308 }
2309
2310 protected RepositoryEventTrigger getFolderRepositoryEventTrigger(
2311 long groupId, long folderId)
2312 throws PortalException {
2313
2314 if (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
2315 return RepositoryUtil.getFolderRepositoryEventTrigger(folderId);
2316 }
2317
2318 return RepositoryUtil.getRepositoryEventTrigger(groupId);
2319 }
2320
2321 protected String getNextVersion(
2322 DLFileEntry dlFileEntry, boolean majorVersion, int workflowAction) {
2323
2324 String version = dlFileEntry.getVersion();
2325
2326 DLFileVersion dlFileVersion =
2327 dlFileVersionLocalService.fetchLatestFileVersion(
2328 dlFileEntry.getFileEntryId(), true);
2329
2330 if (dlFileVersion != null) {
2331 version = dlFileVersion.getVersion();
2332 }
2333
2334 if (workflowAction == WorkflowConstants.ACTION_SAVE_DRAFT) {
2335 majorVersion = false;
2336 }
2337
2338 int[] versionParts = StringUtil.split(version, StringPool.PERIOD, 0);
2339
2340 if (majorVersion) {
2341 versionParts[0]++;
2342 versionParts[1] = 0;
2343 }
2344 else {
2345 versionParts[1]++;
2346 }
2347
2348 return versionParts[0] + StringPool.PERIOD + versionParts[1];
2349 }
2350
2351
2357 protected boolean isKeepFileVersionLabel(
2358 DLFileEntry dlFileEntry, DLFileVersion lastDLFileVersion,
2359 DLFileVersion latestDLFileVersion, ServiceContext serviceContext)
2360 throws PortalException {
2361
2362 if (PropsValues.DL_FILE_ENTRY_VERSION_POLICY != 1) {
2363 return false;
2364 }
2365
2366 if (Validator.equals(serviceContext.getCommand(), Constants.REVERT)) {
2367 return false;
2368 }
2369
2370 if (!Validator.equals(
2371 lastDLFileVersion.getTitle(), latestDLFileVersion.getTitle())) {
2372
2373 return false;
2374 }
2375
2376 if (!Validator.equals(
2377 lastDLFileVersion.getDescription(),
2378 latestDLFileVersion.getDescription())) {
2379
2380 return false;
2381 }
2382
2383 if (lastDLFileVersion.getFileEntryTypeId() !=
2384 latestDLFileVersion.getFileEntryTypeId()) {
2385
2386 return false;
2387 }
2388
2389 if (serviceContext.getWorkflowAction() ==
2390 WorkflowConstants.ACTION_SAVE_DRAFT) {
2391
2392 return false;
2393 }
2394
2395
2396
2397 DLFileEntryType dlFileEntryType =
2398 lastDLFileVersion.getDLFileEntryType();
2399
2400 List<DDMStructure> ddmStructures = dlFileEntryType.getDDMStructures();
2401
2402 for (DDMStructure ddmStructure : ddmStructures) {
2403 DLFileEntryMetadata lastFileEntryMetadata =
2404 dlFileEntryMetadataLocalService.fetchFileEntryMetadata(
2405 ddmStructure.getStructureId(),
2406 lastDLFileVersion.getFileVersionId());
2407
2408 if (lastFileEntryMetadata == null) {
2409 return false;
2410 }
2411
2412 DLFileEntryMetadata latestFileEntryMetadata =
2413 dlFileEntryMetadataLocalService.getFileEntryMetadata(
2414 ddmStructure.getStructureId(),
2415 latestDLFileVersion.getFileVersionId());
2416
2417 DDMFormValues lastDDMFormValues =
2418 StorageEngineManagerUtil.getDDMFormValues(
2419 lastFileEntryMetadata.getDDMStorageId());
2420 DDMFormValues latestDDMFormValues =
2421 StorageEngineManagerUtil.getDDMFormValues(
2422 latestFileEntryMetadata.getDDMStorageId());
2423
2424 if (!lastDDMFormValues.equals(latestDDMFormValues)) {
2425 return false;
2426 }
2427 }
2428
2429
2430
2431 ExpandoBridge lastExpandoBridge = lastDLFileVersion.getExpandoBridge();
2432 ExpandoBridge latestExpandoBridge =
2433 latestDLFileVersion.getExpandoBridge();
2434
2435 Map<String, Serializable> lastAttributes =
2436 lastExpandoBridge.getAttributes();
2437 Map<String, Serializable> latestAttributes =
2438 latestExpandoBridge.getAttributes();
2439
2440 if (!lastAttributes.equals(latestAttributes)) {
2441 return false;
2442 }
2443
2444
2445
2446 long lastSize = lastDLFileVersion.getSize();
2447 long latestSize = latestDLFileVersion.getSize();
2448
2449 if ((lastSize == 0) && (latestSize >= 0)) {
2450 return true;
2451 }
2452
2453 if (lastSize != latestSize) {
2454 return false;
2455 }
2456
2457
2458
2459 InputStream lastInputStream = null;
2460 InputStream latestInputStream = null;
2461
2462 try {
2463 String lastChecksum = lastDLFileVersion.getChecksum();
2464
2465 if (Validator.isNull(lastChecksum)) {
2466 lastInputStream = DLStoreUtil.getFileAsStream(
2467 dlFileEntry.getCompanyId(),
2468 dlFileEntry.getDataRepositoryId(), dlFileEntry.getName(),
2469 lastDLFileVersion.getVersion());
2470
2471 lastChecksum = DigesterUtil.digestBase64(lastInputStream);
2472
2473 lastDLFileVersion.setChecksum(lastChecksum);
2474
2475 dlFileVersionPersistence.update(lastDLFileVersion);
2476 }
2477
2478 latestInputStream = DLStoreUtil.getFileAsStream(
2479 dlFileEntry.getCompanyId(), dlFileEntry.getDataRepositoryId(),
2480 dlFileEntry.getName(), latestDLFileVersion.getVersion());
2481
2482 String latestChecksum = DigesterUtil.digestBase64(
2483 latestInputStream);
2484
2485 if (lastChecksum.equals(latestChecksum)) {
2486 return true;
2487 }
2488
2489 latestDLFileVersion.setChecksum(latestChecksum);
2490
2491 dlFileVersionPersistence.update(latestDLFileVersion);
2492 }
2493 catch (Exception e) {
2494 if (_log.isWarnEnabled()) {
2495 _log.warn(e, e);
2496 }
2497 }
2498 finally {
2499 StreamUtil.cleanUp(lastInputStream);
2500 StreamUtil.cleanUp(latestInputStream);
2501 }
2502
2503 return false;
2504 }
2505
2506 protected DLFileEntry moveFileEntryImpl(
2507 long userId, long fileEntryId, long newFolderId,
2508 ServiceContext serviceContext)
2509 throws PortalException {
2510
2511
2512
2513 User user = userPersistence.findByPrimaryKey(userId);
2514 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
2515 fileEntryId);
2516
2517 long oldDataRepositoryId = dlFileEntry.getDataRepositoryId();
2518
2519 validateFile(
2520 dlFileEntry.getGroupId(), newFolderId, dlFileEntry.getFileEntryId(),
2521 dlFileEntry.getFileName(), dlFileEntry.getTitle());
2522
2523 dlFileEntry.setFolderId(newFolderId);
2524 dlFileEntry.setTreePath(dlFileEntry.buildTreePath());
2525
2526 dlFileEntryPersistence.update(dlFileEntry);
2527
2528
2529
2530 List<DLFileVersion> dlFileVersions =
2531 dlFileVersionPersistence.findByFileEntryId(fileEntryId);
2532
2533 for (DLFileVersion dlFileVersion : dlFileVersions) {
2534 dlFileVersion.setFolderId(newFolderId);
2535 dlFileVersion.setTreePath(dlFileVersion.buildTreePath());
2536
2537 dlFileVersionPersistence.update(dlFileVersion);
2538 }
2539
2540
2541
2542 if (newFolderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
2543 DLFolder dlFolder = dlFolderPersistence.findByPrimaryKey(
2544 newFolderId);
2545
2546 dlFolder.setModifiedDate(serviceContext.getModifiedDate(null));
2547
2548 dlFolderPersistence.update(dlFolder);
2549 }
2550
2551
2552
2553 DLStoreUtil.updateFile(
2554 user.getCompanyId(), oldDataRepositoryId,
2555 dlFileEntry.getDataRepositoryId(), dlFileEntry.getName());
2556
2557 return dlFileEntry;
2558 }
2559
2560 protected void reindex(DLFileEntry dlFileEntry) throws SearchException {
2561 Indexer<DLFileEntry> indexer = IndexerRegistryUtil.nullSafeGetIndexer(
2562 DLFileEntry.class);
2563
2564 indexer.reindex(dlFileEntry);
2565 }
2566
2567 protected void removeFileVersion(
2568 DLFileEntry dlFileEntry, DLFileVersion dlFileVersion)
2569 throws PortalException {
2570
2571 dlFileVersionPersistence.remove(dlFileVersion);
2572
2573 expandoRowLocalService.deleteRows(dlFileVersion.getFileVersionId());
2574
2575 dlFileEntryMetadataLocalService.deleteFileVersionFileEntryMetadata(
2576 dlFileVersion.getFileVersionId());
2577
2578 assetEntryLocalService.deleteEntry(
2579 DLFileEntryConstants.getClassName(), dlFileVersion.getPrimaryKey());
2580
2581 DLStoreUtil.deleteFile(
2582 dlFileEntry.getCompanyId(), dlFileEntry.getDataRepositoryId(),
2583 dlFileEntry.getName(),
2584 DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION);
2585
2586 unlockFileEntry(dlFileEntry.getFileEntryId());
2587 }
2588
2589 protected DLFileEntry updateFileEntry(
2590 long userId, long fileEntryId, String sourceFileName,
2591 String extension, String mimeType, String title, String description,
2592 String changeLog, boolean majorVersion, String extraSettings,
2593 long fileEntryTypeId, Map<String, DDMFormValues> ddmFormValuesMap,
2594 File file, InputStream is, long size, ServiceContext serviceContext)
2595 throws PortalException {
2596
2597 User user = userPersistence.findByPrimaryKey(userId);
2598 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
2599 fileEntryId);
2600
2601 boolean checkedOut = dlFileEntry.isCheckedOut();
2602
2603 DLFileVersion dlFileVersion =
2604 dlFileVersionLocalService.getLatestFileVersion(
2605 fileEntryId, !checkedOut);
2606
2607 boolean autoCheckIn = false;
2608
2609 if (!checkedOut && dlFileVersion.isApproved() &&
2610 !Validator.equals(
2611 dlFileVersion.getUuid(),
2612 serviceContext.getUuidWithoutReset())) {
2613
2614 autoCheckIn = true;
2615 }
2616
2617 if (autoCheckIn) {
2618 dlFileEntry = checkOutFileEntry(
2619 userId, fileEntryId, serviceContext);
2620 }
2621 else if (!checkedOut) {
2622 lockFileEntry(userId, fileEntryId);
2623 }
2624
2625 if (!hasFileEntryLock(userId, fileEntryId)) {
2626 lockFileEntry(userId, fileEntryId);
2627 }
2628
2629 if (checkedOut || autoCheckIn) {
2630 dlFileVersion = dlFileVersionLocalService.getLatestFileVersion(
2631 fileEntryId, false);
2632 }
2633
2634 try {
2635 if (Validator.isNull(extension)) {
2636 extension = dlFileEntry.getExtension();
2637 }
2638
2639 if (Validator.isNull(mimeType)) {
2640 mimeType = dlFileEntry.getMimeType();
2641 }
2642
2643 if (Validator.isNull(title)) {
2644 title = sourceFileName;
2645
2646 if (Validator.isNull(title)) {
2647 title = dlFileEntry.getTitle();
2648 }
2649 }
2650
2651 String fileName = DLUtil.getSanitizedFileName(title, extension);
2652
2653 Date now = new Date();
2654
2655 validateFile(
2656 dlFileEntry.getGroupId(), dlFileEntry.getFolderId(),
2657 dlFileEntry.getFileEntryId(), sourceFileName, fileName,
2658 extension, title);
2659
2660
2661
2662 String version = dlFileVersion.getVersion();
2663
2664 if (size == 0) {
2665 size = dlFileVersion.getSize();
2666 }
2667
2668 updateFileVersion(
2669 user, dlFileVersion, sourceFileName, fileName, extension,
2670 mimeType, title, description, changeLog, extraSettings,
2671 fileEntryTypeId, ddmFormValuesMap, version, size,
2672 dlFileVersion.getStatus(), serviceContext.getModifiedDate(now),
2673 serviceContext);
2674
2675
2676
2677 if (!checkedOut &&
2678 (dlFileEntry.getFolderId() !=
2679 DLFolderConstants.DEFAULT_PARENT_FOLDER_ID)) {
2680
2681 dlFolderLocalService.updateLastPostDate(
2682 dlFileEntry.getFolderId(),
2683 serviceContext.getModifiedDate(now));
2684 }
2685
2686
2687
2688 if ((file != null) || (is != null)) {
2689 DLStoreUtil.deleteFile(
2690 user.getCompanyId(), dlFileEntry.getDataRepositoryId(),
2691 dlFileEntry.getName(), version);
2692
2693 if (file != null) {
2694 DLStoreUtil.updateFile(
2695 user.getCompanyId(), dlFileEntry.getDataRepositoryId(),
2696 dlFileEntry.getName(), dlFileEntry.getExtension(),
2697 false, version, sourceFileName, file);
2698 }
2699 else {
2700 DLStoreUtil.updateFile(
2701 user.getCompanyId(), dlFileEntry.getDataRepositoryId(),
2702 dlFileEntry.getName(), dlFileEntry.getExtension(),
2703 false, version, sourceFileName, is);
2704 }
2705 }
2706
2707 if (autoCheckIn) {
2708 checkInFileEntry(
2709 userId, fileEntryId, majorVersion, changeLog,
2710 serviceContext);
2711 }
2712 }
2713 catch (PortalException pe) {
2714 if (autoCheckIn) {
2715 try {
2716 cancelCheckOut(userId, fileEntryId);
2717 }
2718 catch (Exception e) {
2719 _log.error(e, e);
2720 }
2721 }
2722
2723 throw pe;
2724 }
2725 catch (SystemException se) {
2726 if (autoCheckIn) {
2727 try {
2728 cancelCheckOut(userId, fileEntryId);
2729 }
2730 catch (Exception e) {
2731 _log.error(e, e);
2732 }
2733 }
2734
2735 throw se;
2736 }
2737 finally {
2738 if (!autoCheckIn && !checkedOut) {
2739 unlockFileEntry(fileEntryId);
2740 }
2741 }
2742
2743 return dlFileEntryPersistence.findByPrimaryKey(fileEntryId);
2744 }
2745
2746 protected DLFileVersion updateFileVersion(
2747 User user, DLFileVersion dlFileVersion, String sourceFileName,
2748 String fileName, String extension, String mimeType, String title,
2749 String description, String changeLog, String extraSettings,
2750 long fileEntryTypeId, Map<String, DDMFormValues> ddmFormValuesMap,
2751 String version, long size, int status, Date statusDate,
2752 ServiceContext serviceContext)
2753 throws PortalException {
2754
2755 dlFileVersion.setUserId(user.getUserId());
2756 dlFileVersion.setUserName(user.getFullName());
2757 dlFileVersion.setModifiedDate(statusDate);
2758 dlFileVersion.setFileName(fileName);
2759
2760 if (Validator.isNotNull(sourceFileName)) {
2761 dlFileVersion.setExtension(extension);
2762 dlFileVersion.setMimeType(mimeType);
2763 }
2764
2765 dlFileVersion.setTitle(title);
2766 dlFileVersion.setDescription(description);
2767 dlFileVersion.setChangeLog(changeLog);
2768 dlFileVersion.setExtraSettings(extraSettings);
2769 dlFileVersion.setFileEntryTypeId(fileEntryTypeId);
2770 dlFileVersion.setVersion(version);
2771 dlFileVersion.setSize(size);
2772 dlFileVersion.setStatus(status);
2773 dlFileVersion.setStatusByUserId(user.getUserId());
2774 dlFileVersion.setStatusByUserName(user.getFullName());
2775 dlFileVersion.setStatusDate(statusDate);
2776
2777 ExpandoBridgeUtil.setExpandoBridgeAttributes(
2778 dlFileVersion.getExpandoBridge(), dlFileVersion.getExpandoBridge(),
2779 serviceContext);
2780
2781 dlFileVersion = dlFileVersionPersistence.update(dlFileVersion);
2782
2783 if ((fileEntryTypeId > 0) && (ddmFormValuesMap != null)) {
2784 dlFileEntryMetadataLocalService.updateFileEntryMetadata(
2785 fileEntryTypeId, dlFileVersion.getFileEntryId(),
2786 dlFileVersion.getFileVersionId(), ddmFormValuesMap,
2787 serviceContext);
2788 }
2789
2790 return dlFileVersion;
2791 }
2792
2793 protected void validateFile(
2794 long groupId, long folderId, long fileEntryId,
2795 String sourceFileName, String fileName, String extension,
2796 String title)
2797 throws PortalException {
2798
2799 DLValidatorUtil.validateFileName(title);
2800
2801 validateFileExtension(extension);
2802
2803 validateFile(groupId, folderId, fileEntryId, fileName, title);
2804 }
2805
2806 protected void validateFileEntryTypeId(
2807 long[] groupIds, long folderId, long fileEntryTypeId)
2808 throws PortalException {
2809
2810 List<DLFileEntryType> dlFileEntryTypes =
2811 dlFileEntryTypeLocalService.getFolderFileEntryTypes(
2812 groupIds, folderId, true);
2813
2814 for (DLFileEntryType dlFileEntryType : dlFileEntryTypes) {
2815 if (dlFileEntryType.getFileEntryTypeId() == fileEntryTypeId) {
2816 return;
2817 }
2818 }
2819
2820 throw new InvalidFileEntryTypeException(
2821 "Invalid file entry type " + fileEntryTypeId + " for folder " +
2822 folderId);
2823 }
2824
2825 protected void validateFileExtension(String extension)
2826 throws PortalException {
2827
2828 if (Validator.isNotNull(extension)) {
2829 int maxLength = ModelHintsUtil.getMaxLength(
2830 DLFileEntry.class.getName(), "extension");
2831
2832 if (extension.length() > maxLength) {
2833 throw new FileExtensionException(
2834 extension + " exceeds max length of " + maxLength);
2835 }
2836 }
2837 }
2838
2839 private static final Log _log = LogFactoryUtil.getLog(
2840 DLFileEntryLocalServiceImpl.class);
2841
2842 }