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