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.kernel.exception.PortalException;
021 import com.liferay.portal.kernel.exception.SystemException;
022 import com.liferay.portal.kernel.image.ImageBag;
023 import com.liferay.portal.kernel.image.ImageProcessorUtil;
024 import com.liferay.portal.kernel.log.Log;
025 import com.liferay.portal.kernel.log.LogFactoryUtil;
026 import com.liferay.portal.kernel.search.Indexer;
027 import com.liferay.portal.kernel.search.IndexerRegistryUtil;
028 import com.liferay.portal.kernel.search.SearchException;
029 import com.liferay.portal.kernel.util.FileUtil;
030 import com.liferay.portal.kernel.util.GetterUtil;
031 import com.liferay.portal.kernel.util.OrderByComparator;
032 import com.liferay.portal.kernel.util.PropsKeys;
033 import com.liferay.portal.kernel.util.StringPool;
034 import com.liferay.portal.kernel.util.StringUtil;
035 import com.liferay.portal.kernel.util.UnicodeProperties;
036 import com.liferay.portal.kernel.util.Validator;
037 import com.liferay.portal.kernel.workflow.WorkflowConstants;
038 import com.liferay.portal.kernel.workflow.WorkflowHandlerRegistryUtil;
039 import com.liferay.portal.model.Image;
040 import com.liferay.portal.model.Lock;
041 import com.liferay.portal.model.ResourceConstants;
042 import com.liferay.portal.model.User;
043 import com.liferay.portal.repository.liferayrepository.model.LiferayFileEntry;
044 import com.liferay.portal.repository.liferayrepository.model.LiferayFileVersion;
045 import com.liferay.portal.service.ServiceContext;
046 import com.liferay.portal.util.PortalUtil;
047 import com.liferay.portal.util.PrefsPropsUtil;
048 import com.liferay.portal.util.PropsValues;
049 import com.liferay.portlet.documentlibrary.DuplicateFileException;
050 import com.liferay.portlet.documentlibrary.DuplicateFolderNameException;
051 import com.liferay.portlet.documentlibrary.FileNameException;
052 import com.liferay.portlet.documentlibrary.ImageSizeException;
053 import com.liferay.portlet.documentlibrary.InvalidFileEntryTypeException;
054 import com.liferay.portlet.documentlibrary.NoSuchFileEntryMetadataException;
055 import com.liferay.portlet.documentlibrary.NoSuchFileException;
056 import com.liferay.portlet.documentlibrary.NoSuchFileVersionException;
057 import com.liferay.portlet.documentlibrary.model.DLFileEntry;
058 import com.liferay.portlet.documentlibrary.model.DLFileEntryConstants;
059 import com.liferay.portlet.documentlibrary.model.DLFileEntryMetadata;
060 import com.liferay.portlet.documentlibrary.model.DLFileEntryType;
061 import com.liferay.portlet.documentlibrary.model.DLFileVersion;
062 import com.liferay.portlet.documentlibrary.model.DLFolder;
063 import com.liferay.portlet.documentlibrary.model.DLFolderConstants;
064 import com.liferay.portlet.documentlibrary.model.DLSyncConstants;
065 import com.liferay.portlet.documentlibrary.model.impl.DLFileEntryImpl;
066 import com.liferay.portlet.documentlibrary.service.base.DLFileEntryLocalServiceBaseImpl;
067 import com.liferay.portlet.documentlibrary.store.DLStoreUtil;
068 import com.liferay.portlet.documentlibrary.util.DLUtil;
069 import com.liferay.portlet.documentlibrary.util.comparator.RepositoryModelModifiedDateComparator;
070 import com.liferay.portlet.dynamicdatamapping.model.DDMStructure;
071 import com.liferay.portlet.dynamicdatamapping.storage.Fields;
072 import com.liferay.portlet.dynamicdatamapping.storage.StorageEngineUtil;
073 import com.liferay.portlet.expando.model.ExpandoBridge;
074 import com.liferay.portlet.expando.model.ExpandoColumnConstants;
075
076 import java.awt.image.RenderedImage;
077
078 import java.io.File;
079 import java.io.IOException;
080 import java.io.InputStream;
081 import java.io.Serializable;
082
083 import java.util.Date;
084 import java.util.HashMap;
085 import java.util.List;
086 import java.util.Map;
087
088
103 public class DLFileEntryLocalServiceImpl
104 extends DLFileEntryLocalServiceBaseImpl {
105
106 public DLFileEntry addFileEntry(
107 long userId, long groupId, long repositoryId, long folderId,
108 String sourceFileName, String mimeType, String title,
109 String description, String changeLog, long fileEntryTypeId,
110 Map<String, Fields> fieldsMap, File file, InputStream is, long size,
111 ServiceContext serviceContext)
112 throws PortalException, SystemException {
113
114 if ((size == 0) && Validator.isNull(title)) {
115 throw new FileNameException();
116 }
117
118
119
120 User user = userPersistence.findByPrimaryKey(userId);
121 folderId = dlFolderLocalService.getFolderId(
122 user.getCompanyId(), folderId);
123 String name = String.valueOf(
124 counterLocalService.increment(DLFileEntry.class.getName()));
125 String extension = getExtension(title, sourceFileName);
126 fileEntryTypeId = getFileEntryTypeId(
127 DLUtil.getGroupIds(groupId), folderId, fileEntryTypeId);
128 Date now = new Date();
129
130 validateFile(groupId, folderId, title, extension, file, is);
131
132 long fileEntryId = counterLocalService.increment();
133
134 DLFileEntry dlFileEntry = dlFileEntryPersistence.create(fileEntryId);
135
136 dlFileEntry.setUuid(serviceContext.getUuid());
137 dlFileEntry.setGroupId(groupId);
138 dlFileEntry.setCompanyId(user.getCompanyId());
139 dlFileEntry.setUserId(user.getUserId());
140 dlFileEntry.setUserName(user.getFullName());
141 dlFileEntry.setVersionUserId(user.getUserId());
142 dlFileEntry.setVersionUserName(user.getFullName());
143 dlFileEntry.setCreateDate(serviceContext.getCreateDate(now));
144 dlFileEntry.setModifiedDate(serviceContext.getModifiedDate(now));
145 dlFileEntry.setRepositoryId(repositoryId);
146 dlFileEntry.setFolderId(folderId);
147 dlFileEntry.setName(name);
148 dlFileEntry.setExtension(extension);
149 dlFileEntry.setMimeType(mimeType);
150 dlFileEntry.setTitle(title);
151 dlFileEntry.setDescription(description);
152 dlFileEntry.setFileEntryTypeId(fileEntryTypeId);
153 dlFileEntry.setVersion(DLFileEntryConstants.VERSION_DEFAULT);
154 dlFileEntry.setSize(size);
155 dlFileEntry.setReadCount(DLFileEntryConstants.DEFAULT_READ_COUNT);
156
157 dlFileEntryPersistence.update(dlFileEntry, false);
158
159
160
161 DLFileVersion dlFileVersion = addFileVersion(
162 user, dlFileEntry, serviceContext.getModifiedDate(now), extension,
163 mimeType, title, description, null, StringPool.BLANK,
164 fileEntryTypeId, fieldsMap, DLFileEntryConstants.VERSION_DEFAULT,
165 size, WorkflowConstants.STATUS_DRAFT, serviceContext);
166
167 dlFileEntry.setFileVersion(dlFileVersion);
168
169
170
171 if (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
172 dlFolderLocalService.updateLastPostDate(
173 dlFileEntry.getFolderId(), dlFileEntry.getModifiedDate());
174 }
175
176
177
178 if (file != null) {
179 DLStoreUtil.addFile(
180 user.getCompanyId(), dlFileEntry.getDataRepositoryId(), name,
181 false, file);
182 }
183 else {
184 DLStoreUtil.addFile(
185 user.getCompanyId(), dlFileEntry.getDataRepositoryId(), name,
186 false, is);
187 }
188
189
190
191 reindex(dlFileEntry);
192
193 return dlFileEntry;
194 }
195
196 public void addFileEntryResources(
197 DLFileEntry dlFileEntry, boolean addGroupPermissions,
198 boolean addGuestPermissions)
199 throws PortalException, SystemException {
200
201 resourceLocalService.addResources(
202 dlFileEntry.getCompanyId(), dlFileEntry.getGroupId(),
203 dlFileEntry.getUserId(), DLFileEntry.class.getName(),
204 dlFileEntry.getFileEntryId(), false, addGroupPermissions,
205 addGuestPermissions);
206 }
207
208 public void addFileEntryResources(
209 DLFileEntry dlFileEntry, String[] groupPermissions,
210 String[] guestPermissions)
211 throws PortalException, SystemException {
212
213 resourceLocalService.addModelResources(
214 dlFileEntry.getCompanyId(), dlFileEntry.getGroupId(),
215 dlFileEntry.getUserId(), DLFileEntry.class.getName(),
216 dlFileEntry.getFileEntryId(), groupPermissions, guestPermissions);
217 }
218
219 public void cancelCheckOut(long userId, long fileEntryId)
220 throws PortalException, SystemException {
221
222 if (!isFileEntryCheckedOut(fileEntryId)) {
223 return;
224 }
225
226 if (!hasFileEntryLock(userId, fileEntryId)) {
227 lockFileEntry(userId, fileEntryId);
228 }
229
230 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
231 fileEntryId);
232
233 DLFileVersion dlFileVersion =
234 dlFileVersionLocalService.getLatestFileVersion(fileEntryId, false);
235
236 dlFileVersionPersistence.remove(dlFileVersion);
237
238 try {
239 DLStoreUtil.deleteFile(
240 dlFileEntry.getCompanyId(), dlFileEntry.getDataRepositoryId(),
241 dlFileEntry.getName(),
242 DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION);
243 }
244 catch (NoSuchFileException nsfe) {
245 }
246
247 lockLocalService.unlock(DLFileEntry.class.getName(), fileEntryId);
248 }
249
250 public void checkInFileEntry(
251 long userId, long fileEntryId, boolean majorVersion,
252 String changeLog, ServiceContext serviceContext)
253 throws PortalException, SystemException {
254
255 if (!isFileEntryCheckedOut(fileEntryId)) {
256 return;
257 }
258
259 if (!hasFileEntryLock(userId, fileEntryId)) {
260 lockFileEntry(userId, fileEntryId);
261 }
262
263 User user = userPersistence.findByPrimaryKey(userId);
264 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
265 fileEntryId);
266
267 String version = getNextVersion(
268 dlFileEntry, majorVersion, serviceContext.getWorkflowAction());
269
270 DLFileVersion dlFileVersion =
271 dlFileVersionLocalService.getLatestFileVersion(fileEntryId, false);
272
273 dlFileVersion.setVersion(version);
274 dlFileVersion.setChangeLog(changeLog);
275
276 dlFileVersionPersistence.update(dlFileVersion, false);
277
278
279
280 dlAppHelperLocalService.updateAsset(
281 userId, new LiferayFileEntry(dlFileEntry),
282 new LiferayFileVersion(dlFileVersion),
283 dlFileVersion.getFileVersionId());
284
285
286
287 if (dlFileEntry.getFolderId() !=
288 DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
289
290 dlFolderLocalService.updateLastPostDate(
291 dlFileEntry.getFolderId(), dlFileEntry.getModifiedDate());
292 }
293
294
295
296 DLStoreUtil.updateFileVersion(
297 user.getCompanyId(), dlFileEntry.getDataRepositoryId(),
298 dlFileEntry.getName(),
299 DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION, version);
300
301
302
303 reindex(dlFileEntry);
304
305 if (serviceContext.getWorkflowAction() ==
306 WorkflowConstants.ACTION_PUBLISH) {
307
308 Map<String, Serializable> workflowContext =
309 new HashMap<String, Serializable>();
310
311 workflowContext.put("event", DLSyncConstants.EVENT_UPDATE);
312
313 WorkflowHandlerRegistryUtil.startWorkflowInstance(
314 dlFileVersion.getCompanyId(), dlFileVersion.getGroupId(),
315 userId, DLFileEntry.class.getName(),
316 dlFileVersion.getFileVersionId(), dlFileVersion, serviceContext,
317 workflowContext);
318 }
319
320 lockLocalService.unlock(DLFileEntry.class.getName(), fileEntryId);
321 }
322
323 public void checkInFileEntry(long userId, long fileEntryId, String lockUuid)
324 throws PortalException, SystemException {
325
326 if (Validator.isNotNull(lockUuid)) {
327 try {
328 Lock lock = lockLocalService.getLock(
329 DLFileEntry.class.getName(), fileEntryId);
330
331 if (!lock.getUuid().equals(lockUuid)) {
332 throw new InvalidLockException("UUIDs do not match");
333 }
334 }
335 catch (PortalException pe) {
336 if ((pe instanceof ExpiredLockException) ||
337 (pe instanceof NoSuchLockException)) {
338 }
339 else {
340 throw pe;
341 }
342 }
343 }
344
345 checkInFileEntry(
346 userId, fileEntryId, false, StringPool.BLANK, new ServiceContext());
347 }
348
349 public DLFileEntry checkOutFileEntry(long userId, long fileEntryId)
350 throws PortalException, SystemException {
351
352 return checkOutFileEntry(
353 userId, fileEntryId, StringPool.BLANK,
354 DLFileEntryImpl.LOCK_EXPIRATION_TIME);
355 }
356
357 public DLFileEntry checkOutFileEntry(
358 long userId, long fileEntryId, String owner, long expirationTime)
359 throws PortalException, SystemException {
360
361 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
362 fileEntryId);
363
364 boolean hasLock = hasFileEntryLock(userId, fileEntryId);
365
366 if (!hasLock) {
367 if ((expirationTime <= 0) ||
368 (expirationTime > DLFileEntryImpl.LOCK_EXPIRATION_TIME)) {
369
370 expirationTime = DLFileEntryImpl.LOCK_EXPIRATION_TIME;
371 }
372
373 lockLocalService.lock(
374 userId, DLFileEntry.class.getName(), fileEntryId, owner,
375 false, expirationTime);
376 }
377
378 User user = userPersistence.findByPrimaryKey(userId);
379
380 dlFileEntryPersistence.update(dlFileEntry, false);
381
382 DLFileVersion dlFileVersion =
383 dlFileVersionLocalService.getLatestFileVersion(fileEntryId, false);
384
385 long dlFileVersionId = dlFileVersion.getFileVersionId();
386
387 String version = dlFileVersion.getVersion();
388
389 if (!version.equals(
390 DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION)) {
391
392 ServiceContext serviceContext = new ServiceContext();
393
394 serviceContext.setCompanyId(user.getCompanyId());
395 serviceContext.setUserId(userId);
396
397 dlFileVersion = addFileVersion(
398 user, dlFileEntry, new Date(), dlFileVersion.getExtension(),
399 dlFileVersion.getMimeType(), dlFileVersion.getTitle(),
400 dlFileVersion.getDescription(), dlFileVersion.getChangeLog(),
401 dlFileVersion.getExtraSettings(),
402 dlFileVersion.getFileEntryTypeId(), null,
403 DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION,
404 dlFileVersion.getSize(), WorkflowConstants.STATUS_DRAFT,
405 serviceContext);
406
407 try {
408 DLStoreUtil.deleteFile(
409 dlFileEntry.getCompanyId(),
410 dlFileEntry.getDataRepositoryId(), dlFileEntry.getName(),
411 DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION);
412 }
413 catch (NoSuchFileException nsfe) {
414 }
415
416 DLStoreUtil.copyFileVersion(
417 user.getCompanyId(), dlFileEntry.getDataRepositoryId(),
418 dlFileEntry.getName(), version,
419 DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION);
420
421 copyFileEntryMetadata(
422 dlFileEntry.getCompanyId(), dlFileVersion.getFileEntryTypeId(),
423 fileEntryId, dlFileVersionId, dlFileVersion.getFileVersionId(),
424 serviceContext);
425
426
427
428 reindex(dlFileEntry);
429 }
430
431 return dlFileEntry;
432 }
433
434 public void convertExtraSettings(String[] keys)
435 throws PortalException, SystemException {
436
437 int count = dlFileEntryFinder.countByExtraSettings();
438 int pages = count / Indexer.DEFAULT_INTERVAL;
439
440 for (int i = 0; i <= pages; i++) {
441 int start = (i * Indexer.DEFAULT_INTERVAL);
442 int end = start + Indexer.DEFAULT_INTERVAL;
443
444 List<DLFileEntry> dlFileEntries =
445 dlFileEntryFinder.findByExtraSettings(start, end);
446
447 for (DLFileEntry dlFileEntry : dlFileEntries) {
448 convertExtraSettings(dlFileEntry, keys);
449 }
450 }
451 }
452
453 public void copyFileEntryMetadata(
454 long companyId, long fileEntryTypeId, long fileEntryId,
455 long fromFileVersionId, long toFileVersionId,
456 ServiceContext serviceContext)
457 throws PortalException, SystemException {
458
459 Map<String, Fields> fieldsMap = new HashMap<String, Fields>();
460
461 List<DDMStructure> ddmStructures = null;
462
463 if (fileEntryTypeId > 0) {
464 DLFileEntryType dlFileEntryType =
465 dlFileEntryTypeLocalService.getFileEntryType(fileEntryTypeId);
466
467 ddmStructures = dlFileEntryType.getDDMStructures();
468
469 for (DDMStructure ddmStructure : ddmStructures) {
470 try {
471 DLFileEntryMetadata dlFileEntryMetadata =
472 dlFileEntryMetadataLocalService.getFileEntryMetadata(
473 ddmStructure.getStructureId(), fromFileVersionId);
474
475 Fields fields = StorageEngineUtil.getFields(
476 dlFileEntryMetadata.getDDMStorageId());
477
478 fieldsMap.put(ddmStructure.getStructureKey(), fields);
479 }
480 catch (NoSuchFileEntryMetadataException nsfeme) {
481 }
482 }
483
484 dlFileEntryMetadataLocalService.updateFileEntryMetadata(
485 companyId, ddmStructures, fileEntryTypeId, fileEntryId,
486 toFileVersionId, fieldsMap, serviceContext);
487 }
488
489 long classNameId = PortalUtil.getClassNameId(DLFileEntry.class);
490
491 ddmStructures = ddmStructureLocalService.getClassStructures(
492 classNameId);
493
494 for (DDMStructure ddmStructure : ddmStructures) {
495 try {
496 DLFileEntryMetadata fileEntryMetadata =
497 dlFileEntryMetadataLocalService.getFileEntryMetadata(
498 ddmStructure.getStructureId(), fromFileVersionId);
499
500 Fields fields = StorageEngineUtil.getFields(
501 fileEntryMetadata.getDDMStorageId());
502
503 fieldsMap.put(ddmStructure.getStructureKey(), fields);
504 }
505 catch (NoSuchFileEntryMetadataException nsfme) {
506 }
507 }
508
509 dlFileEntryMetadataLocalService.updateFileEntryMetadata(
510 companyId, ddmStructures, fileEntryTypeId, fileEntryId,
511 toFileVersionId, fieldsMap, serviceContext);
512 }
513
514 public void deleteFileEntries(long groupId, long folderId)
515 throws PortalException, SystemException {
516
517 List<DLFileEntry> dlFileEntries = dlFileEntryPersistence.findByG_F(
518 groupId, folderId);
519
520 for (DLFileEntry dlFileEntry : dlFileEntries) {
521 dlAppHelperLocalService.deleteFileEntry(
522 new LiferayFileEntry(dlFileEntry));
523
524 deleteFileEntry(dlFileEntry);
525 }
526 }
527
528 public void deleteFileEntry(long fileEntryId)
529 throws PortalException, SystemException {
530
531 DLFileEntry dlFileEntry = getFileEntry(fileEntryId);
532
533 deleteFileEntry(dlFileEntry);
534 }
535
536 public void deleteFileEntry(long userId, long fileEntryId)
537 throws PortalException, SystemException {
538
539 if (!hasFileEntryLock(userId, fileEntryId)) {
540 lockFileEntry(userId, fileEntryId);
541 }
542
543 try {
544 deleteFileEntry(fileEntryId);
545 }
546 finally {
547 unlockFileEntry(fileEntryId);
548 }
549 }
550
551 public DLFileEntry fetchFileEntryByAnyImageId(long imageId)
552 throws SystemException {
553
554 return dlFileEntryFinder.fetchByAnyImageId(imageId);
555 }
556
557 public List<DLFileEntry> getExtraSettingsFileEntries(int start, int end)
558 throws SystemException {
559
560 return dlFileEntryFinder.findByExtraSettings(start, end);
561 }
562
563 public File getFile(
564 long userId, long fileEntryId, String version,
565 boolean incrementCounter)
566 throws PortalException, SystemException {
567
568 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
569 fileEntryId);
570
571 if (PropsValues.DL_FILE_ENTRY_READ_COUNT_ENABLED &&
572 incrementCounter) {
573
574 dlFileEntry.setReadCount(dlFileEntry.getReadCount() + 1);
575
576 dlFileEntryPersistence.update(dlFileEntry, false);
577 }
578
579 dlAppHelperLocalService.getFileAsStream(
580 userId, new LiferayFileEntry(dlFileEntry), incrementCounter);
581
582 return DLStoreUtil.getFile(
583 dlFileEntry.getCompanyId(), dlFileEntry.getDataRepositoryId(),
584 dlFileEntry.getName(), version);
585 }
586
587 public InputStream getFileAsStream(
588 long userId, long fileEntryId, String version)
589 throws PortalException, SystemException {
590
591 return getFileAsStream(userId, fileEntryId, version, true);
592 }
593
594 public InputStream getFileAsStream(
595 long userId, long fileEntryId, String version,
596 boolean incrementCounter)
597 throws PortalException, SystemException {
598
599 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
600 fileEntryId);
601
602 if (PropsValues.DL_FILE_ENTRY_READ_COUNT_ENABLED &&
603 incrementCounter) {
604
605 dlFileEntry.setReadCount(dlFileEntry.getReadCount() + 1);
606
607 dlFileEntryPersistence.update(dlFileEntry, false);
608 }
609
610 dlAppHelperLocalService.getFileAsStream(
611 userId, new LiferayFileEntry(dlFileEntry), incrementCounter);
612
613 return DLStoreUtil.getFileAsStream(
614 dlFileEntry.getCompanyId(), dlFileEntry.getDataRepositoryId(),
615 dlFileEntry.getName(), version);
616 }
617
618 public List<DLFileEntry> getFileEntries(int start, int end)
619 throws SystemException {
620
621 return dlFileEntryPersistence.findAll(start, end);
622 }
623
624 public List<DLFileEntry> getFileEntries(
625 long groupId, long folderId, int start, int end,
626 OrderByComparator obc)
627 throws SystemException {
628
629 return dlFileEntryPersistence.findByG_F(
630 groupId, folderId, start, end, obc);
631 }
632
633 public int getFileEntriesCount() throws SystemException {
634 return dlFileEntryPersistence.countAll();
635 }
636
637 public int getFileEntriesCount(long groupId, long folderId)
638 throws SystemException {
639
640 return dlFileEntryPersistence.countByG_F(groupId, folderId);
641 }
642
643 public DLFileEntry getFileEntry(long fileEntryId)
644 throws PortalException, SystemException {
645
646 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
647 fileEntryId);
648
649 DLFileVersion dlFileVersion = dlFileVersionLocalService.getFileVersion(
650 fileEntryId, dlFileEntry.getVersion());
651
652 dlFileEntry.setFileVersion(dlFileVersion);
653
654 return dlFileEntry;
655 }
656
657 public DLFileEntry getFileEntry(long groupId, long folderId, String title)
658 throws PortalException, SystemException {
659
660 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByG_F_T(
661 groupId, folderId, title);
662
663 DLFileVersion dlFileVersion = dlFileVersionLocalService.getFileVersion(
664 dlFileEntry.getFileEntryId(), dlFileEntry.getVersion());
665
666 dlFileEntry.setFileVersion(dlFileVersion);
667
668 return dlFileEntry;
669 }
670
671 public DLFileEntry getFileEntryByName(
672 long groupId, long folderId, String name)
673 throws PortalException, SystemException {
674
675 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByG_F_N(
676 groupId, folderId, name);
677
678 DLFileVersion dlFileVersion = dlFileVersionLocalService.getFileVersion(
679 dlFileEntry.getFileEntryId(), dlFileEntry.getVersion());
680
681 dlFileEntry.setFileVersion(dlFileVersion);
682
683 return dlFileEntry;
684 }
685
686 public DLFileEntry getFileEntryByUuidAndGroupId(String uuid, long groupId)
687 throws PortalException, SystemException {
688
689 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByUUID_G(
690 uuid, groupId);
691
692 DLFileVersion dlFileVersion = dlFileVersionLocalService.getFileVersion(
693 dlFileEntry.getFileEntryId(), dlFileEntry.getVersion());
694
695 dlFileEntry.setFileVersion(dlFileVersion);
696
697 return dlFileEntry;
698 }
699
700 public List<DLFileEntry> getGroupFileEntries(
701 long groupId, int start, int end)
702 throws SystemException {
703
704 return getGroupFileEntries(
705 groupId, start, end, new RepositoryModelModifiedDateComparator());
706 }
707
708 public List<DLFileEntry> getGroupFileEntries(
709 long groupId, int start, int end, OrderByComparator obc)
710 throws SystemException {
711
712 return dlFileEntryPersistence.findByGroupId(groupId, start, end, obc);
713 }
714
715 public List<DLFileEntry> getGroupFileEntries(
716 long groupId, long userId, int start, int end)
717 throws SystemException {
718
719 return getGroupFileEntries(
720 groupId, userId, start, end,
721 new RepositoryModelModifiedDateComparator());
722 }
723
724 public List<DLFileEntry> getGroupFileEntries(
725 long groupId, long userId, int start, int end,
726 OrderByComparator obc)
727 throws SystemException {
728
729 if (userId <= 0) {
730 return dlFileEntryPersistence.findByGroupId(
731 groupId, start, end, obc);
732 }
733 else {
734 return dlFileEntryPersistence.findByG_U(
735 groupId, userId, start, end, obc);
736 }
737 }
738
739 public int getGroupFileEntriesCount(long groupId) throws SystemException {
740 return dlFileEntryPersistence.countByGroupId(groupId);
741 }
742
743 public int getGroupFileEntriesCount(long groupId, long userId)
744 throws SystemException {
745
746 if (userId <= 0) {
747 return dlFileEntryPersistence.countByGroupId(groupId);
748 }
749 else {
750 return dlFileEntryPersistence.countByG_U(groupId, userId);
751 }
752 }
753
754 public List<DLFileEntry> getNoAssetFileEntries() throws SystemException {
755 return dlFileEntryFinder.findByNoAssets();
756 }
757
758 public List<DLFileEntry> getOrphanedFileEntries() throws SystemException {
759 return dlFileEntryFinder.findByOrphanedFileEntries();
760 }
761
762 public boolean hasExtraSettings() throws SystemException {
763 if (dlFileEntryFinder.countByExtraSettings() > 0) {
764 return true;
765 }
766 else {
767 return false;
768 }
769 }
770
771 public boolean hasFileEntryLock(long userId, long fileEntryId)
772 throws PortalException, SystemException {
773
774 DLFileEntry dlFileEntry = getFileEntry(fileEntryId);
775
776 long folderId = dlFileEntry.getFolderId();
777
778 boolean hasLock = lockLocalService.hasLock(
779 userId, DLFileEntry.class.getName(), fileEntryId);
780
781 if (!hasLock &&
782 (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID)) {
783
784 hasLock = dlFolderService.hasInheritableLock(folderId);
785 }
786
787 return hasLock;
788 }
789
790 public boolean isFileEntryCheckedOut(long fileEntryId)
791 throws PortalException, SystemException {
792
793 DLFileVersion dlFileVersion =
794 dlFileVersionLocalService.getLatestFileVersion(fileEntryId, false);
795
796 String version = dlFileVersion.getVersion();
797
798 if (version.equals(
799 DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION)) {
800
801 return true;
802 }
803 else {
804 return false;
805 }
806 }
807
808 public DLFileEntry moveFileEntry(
809 long userId, long fileEntryId, long newFolderId,
810 ServiceContext serviceContext)
811 throws PortalException, SystemException {
812
813 if (!hasFileEntryLock(userId, fileEntryId)) {
814 lockFileEntry(userId, fileEntryId);
815 }
816
817 try {
818 DLFileEntry dlFileEntry = moveFileEntryImpl(
819 userId, fileEntryId, newFolderId, serviceContext);
820
821 return dlFileEntryTypeLocalService.updateFileEntryFileEntryType(
822 dlFileEntry, serviceContext);
823 }
824 finally {
825 if (!isFileEntryCheckedOut(fileEntryId)) {
826 unlockFileEntry(fileEntryId);
827 }
828 }
829 }
830
831 public void revertFileEntry(
832 long userId, long fileEntryId, String version,
833 ServiceContext serviceContext)
834 throws PortalException, SystemException {
835
836 DLFileVersion dlFileVersion = dlFileVersionLocalService.getFileVersion(
837 fileEntryId, version);
838
839 if (!dlFileVersion.isApproved()) {
840 return;
841 }
842
843 String sourceFileName = dlFileVersion.getTitle();
844 String extension = dlFileVersion.getExtension();
845 String mimeType = dlFileVersion.getMimeType();
846 String title = dlFileVersion.getTitle();
847 String description = dlFileVersion.getDescription();
848 String changeLog = "Reverted to " + version;
849 boolean majorVersion = true;
850 String extraSettings = dlFileVersion.getExtraSettings();
851 long fileEntryTypeId = dlFileVersion.getFileEntryTypeId();
852 Map<String, Fields> fieldsMap = null;
853 InputStream is = getFileAsStream(userId, fileEntryId, version);
854 long size = dlFileVersion.getSize();
855
856 DLFileEntry dlFileEntry = updateFileEntry(
857 userId, fileEntryId, sourceFileName, extension, mimeType, title,
858 description, changeLog, majorVersion, extraSettings,
859 fileEntryTypeId, fieldsMap, null, is, size, serviceContext);
860
861 DLFileVersion newDlFileVersion =
862 dlFileVersionLocalService.getFileVersion(
863 fileEntryId, dlFileEntry.getVersion());
864
865 copyFileEntryMetadata(
866 dlFileVersion.getCompanyId(), dlFileVersion.getFileEntryTypeId(),
867 fileEntryId, newDlFileVersion.getFileVersionId(),
868 dlFileVersion.getFileVersionId(), serviceContext);
869 }
870
871 public DLFileEntry updateFileEntry(
872 long userId, long fileEntryId, String sourceFileName,
873 String mimeType, String title, String description, String changeLog,
874 boolean majorVersion, long fileEntryTypeId,
875 Map<String, Fields> fieldsMap, File file, InputStream is, long size,
876 ServiceContext serviceContext)
877 throws PortalException, SystemException {
878
879 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
880 fileEntryId);
881
882 String extension = getExtension(title, sourceFileName);
883
884 String extraSettings = StringPool.BLANK;
885
886 fileEntryTypeId = getFileEntryTypeId(
887 DLUtil.getGroupIds(dlFileEntry.getGroupId()),
888 dlFileEntry.getFolderId(), fileEntryTypeId);
889
890 return updateFileEntry(
891 userId, fileEntryId, sourceFileName, extension, mimeType, title,
892 description, changeLog, majorVersion, extraSettings,
893 fileEntryTypeId, fieldsMap, file, is, size, serviceContext);
894 }
895
896 public void updateSmallImage(long smallImageId, long largeImageId)
897 throws PortalException, SystemException {
898
899 try {
900 RenderedImage renderedImage = null;
901
902 Image largeImage = imageLocalService.getImage(largeImageId);
903
904 byte[] bytes = largeImage.getTextObj();
905 String contentType = largeImage.getType();
906
907 if (bytes != null) {
908 ImageBag imageBag = ImageProcessorUtil.read(bytes);
909
910 renderedImage = imageBag.getRenderedImage();
911
912
913 }
914
915 if (renderedImage != null) {
916 int height = PrefsPropsUtil.getInteger(
917 PropsKeys.DL_FILE_ENTRY_THUMBNAIL_MAX_HEIGHT);
918 int width = PrefsPropsUtil.getInteger(
919 PropsKeys.DL_FILE_ENTRY_THUMBNAIL_MAX_WIDTH);
920
921 RenderedImage thumbnailRenderedImage =
922 ImageProcessorUtil.scale(renderedImage, height, width);
923
924 imageLocalService.updateImage(
925 smallImageId,
926 ImageProcessorUtil.getBytes(
927 thumbnailRenderedImage, contentType));
928 }
929 }
930 catch (IOException ioe) {
931 throw new ImageSizeException(ioe);
932 }
933 }
934
935 public DLFileEntry updateStatus(
936 long userId, long fileVersionId, int status,
937 Map<String, Serializable> workflowContext,
938 ServiceContext serviceContext)
939 throws PortalException, SystemException {
940
941
942
943 User user = userPersistence.findByPrimaryKey(userId);
944
945 DLFileVersion dlFileVersion = dlFileVersionPersistence.findByPrimaryKey(
946 fileVersionId);
947
948 dlFileVersion.setStatus(status);
949 dlFileVersion.setStatusByUserId(user.getUserId());
950 dlFileVersion.setStatusByUserName(user.getFullName());
951 dlFileVersion.setStatusDate(new Date());
952
953 dlFileVersionPersistence.update(dlFileVersion, false);
954
955
956
957 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
958 dlFileVersion.getFileEntryId());
959
960 if (status == WorkflowConstants.STATUS_APPROVED) {
961 if (DLUtil.compareVersions(
962 dlFileEntry.getVersion(),
963 dlFileVersion.getVersion()) <= 0) {
964
965 dlFileEntry.setExtension(dlFileVersion.getExtension());
966 dlFileEntry.setTitle(dlFileVersion.getTitle());
967 dlFileEntry.setDescription(dlFileVersion.getDescription());
968 dlFileEntry.setExtraSettings(dlFileVersion.getExtraSettings());
969 dlFileEntry.setFileEntryTypeId(
970 dlFileVersion.getFileEntryTypeId());
971 dlFileEntry.setVersion(dlFileVersion.getVersion());
972 dlFileEntry.setVersionUserId(dlFileVersion.getUserId());
973 dlFileEntry.setVersionUserName(dlFileVersion.getUserName());
974 dlFileEntry.setModifiedDate(dlFileVersion.getCreateDate());
975 dlFileEntry.setSize(dlFileVersion.getSize());
976
977 dlFileEntryPersistence.update(dlFileEntry, false);
978 }
979
980
981
982 reindex(dlFileEntry);
983 }
984 else {
985
986
987
988 if (dlFileEntry.getVersion().equals(dlFileVersion.getVersion())) {
989 String newVersion = DLFileEntryConstants.VERSION_DEFAULT;
990
991 List<DLFileVersion> approvedFileVersions =
992 dlFileVersionPersistence.findByF_S(
993 dlFileEntry.getFileEntryId(),
994 WorkflowConstants.STATUS_APPROVED);
995
996 if (!approvedFileVersions.isEmpty()) {
997 newVersion = approvedFileVersions.get(0).getVersion();
998 }
999
1000 dlFileEntry.setVersion(newVersion);
1001
1002 dlFileEntryPersistence.update(dlFileEntry, false);
1003 }
1004
1005
1006
1007 if (dlFileVersion.getVersion().equals(
1008 DLFileEntryConstants.VERSION_DEFAULT)) {
1009
1010 Indexer indexer = IndexerRegistryUtil.getIndexer(
1011 DLFileEntry.class);
1012
1013 indexer.delete(dlFileEntry);
1014 }
1015 }
1016
1017
1018
1019 dlAppHelperLocalService.updateStatus(
1020 userId, new LiferayFileEntry(dlFileEntry),
1021 new LiferayFileVersion(dlFileVersion), status, workflowContext);
1022
1023 return dlFileEntry;
1024 }
1025
1026 public boolean verifyFileEntryCheckOut(long fileEntryId, String lockUuid)
1027 throws PortalException, SystemException {
1028
1029 boolean lockVerified = false;
1030
1031 try {
1032 Lock lock = lockLocalService.getLock(
1033 DLFileEntry.class.getName(), fileEntryId);
1034
1035 if (lock.getUuid().equals(lockUuid)) {
1036 lockVerified = true;
1037 }
1038 }
1039 catch (PortalException pe) {
1040 if ((pe instanceof ExpiredLockException) ||
1041 (pe instanceof NoSuchLockException)) {
1042
1043 DLFileEntry dlFileEntry = dlFileEntryLocalService.getFileEntry(
1044 fileEntryId);
1045
1046 lockVerified = dlFolderService.verifyInheritableLock(
1047 dlFileEntry.getFolderId(), lockUuid);
1048 }
1049 else {
1050 throw pe;
1051 }
1052 }
1053
1054 if (lockVerified && isFileEntryCheckedOut(fileEntryId)) {
1055 return true;
1056 }
1057 else {
1058 return false;
1059 }
1060 }
1061
1062 protected void addFileEntryResources(
1063 long fileEntryId, boolean addGroupPermissions,
1064 boolean addGuestPermissions)
1065 throws PortalException, SystemException {
1066
1067 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
1068 fileEntryId);
1069
1070 addFileEntryResources(
1071 dlFileEntry, addGroupPermissions, addGuestPermissions);
1072 }
1073
1074 protected void addFileEntryResources(
1075 long fileEntryId, String[] groupPermissions,
1076 String[] guestPermissions)
1077 throws PortalException, SystemException {
1078
1079 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
1080 fileEntryId);
1081
1082 addFileEntryResources(
1083 dlFileEntry, groupPermissions, guestPermissions);
1084 }
1085
1086 protected DLFileVersion addFileVersion(
1087 User user, DLFileEntry dlFileEntry, Date modifiedDate,
1088 String extension, String mimeType, String title, String description,
1089 String changeLog, String extraSettings, long fileEntryTypeId,
1090 Map<String, Fields> fieldsMap, String version, long size,
1091 int status, ServiceContext serviceContext)
1092 throws PortalException, SystemException {
1093
1094 long fileVersionId = counterLocalService.increment();
1095
1096 DLFileVersion dlFileVersion = dlFileVersionPersistence.create(
1097 fileVersionId);
1098
1099 long versionUserId = dlFileEntry.getVersionUserId();
1100
1101 if (versionUserId <= 0) {
1102 versionUserId = dlFileEntry.getUserId();
1103 }
1104
1105 String versionUserName = GetterUtil.getString(
1106 dlFileEntry.getVersionUserName(), dlFileEntry.getUserName());
1107
1108 dlFileVersion.setGroupId(dlFileEntry.getGroupId());
1109 dlFileVersion.setCompanyId(dlFileEntry.getCompanyId());
1110 dlFileVersion.setUserId(versionUserId);
1111 dlFileVersion.setUserName(versionUserName);
1112 dlFileVersion.setCreateDate(modifiedDate);
1113 dlFileVersion.setModifiedDate(modifiedDate);
1114 dlFileVersion.setRepositoryId(dlFileEntry.getRepositoryId());
1115 dlFileVersion.setFolderId(dlFileEntry.getFolderId());
1116 dlFileVersion.setFileEntryId(dlFileEntry.getFileEntryId());
1117 dlFileVersion.setExtension(extension);
1118 dlFileVersion.setMimeType(mimeType);
1119 dlFileVersion.setTitle(title);
1120 dlFileVersion.setDescription(description);
1121 dlFileVersion.setChangeLog(changeLog);
1122 dlFileVersion.setExtraSettings(extraSettings);
1123 dlFileVersion.setFileEntryTypeId(fileEntryTypeId);
1124 dlFileVersion.setVersion(version);
1125 dlFileVersion.setSize(size);
1126 dlFileVersion.setStatus(status);
1127 dlFileVersion.setStatusByUserId(user.getUserId());
1128 dlFileVersion.setStatusByUserName(user.getFullName());
1129 dlFileVersion.setStatusDate(dlFileEntry.getModifiedDate());
1130 dlFileVersion.setExpandoBridgeAttributes(serviceContext);
1131
1132 dlFileVersionPersistence.update(dlFileVersion, false);
1133
1134 if ((fileEntryTypeId > 0) && (fieldsMap != null)) {
1135 dlFileEntryMetadataLocalService.updateFileEntryMetadata(
1136 fileEntryTypeId, dlFileEntry.getFileEntryId(), fileVersionId,
1137 fieldsMap, serviceContext);
1138 }
1139
1140 return dlFileVersion;
1141 }
1142
1143 protected void convertExtraSettings(
1144 DLFileEntry dlFileEntry, DLFileVersion dlFileVersion, String[] keys)
1145 throws PortalException, SystemException {
1146
1147 UnicodeProperties extraSettingsProperties =
1148 dlFileVersion.getExtraSettingsProperties();
1149
1150 ExpandoBridge expandoBridge = dlFileVersion.getExpandoBridge();
1151
1152 convertExtraSettings(extraSettingsProperties, expandoBridge, keys);
1153
1154 dlFileVersion.setExtraSettingsProperties(extraSettingsProperties);
1155
1156 dlFileVersionPersistence.update(dlFileVersion, false);
1157
1158 int status = dlFileVersion.getStatus();
1159
1160 if ((status == WorkflowConstants.STATUS_APPROVED) &&
1161 (DLUtil.compareVersions(
1162 dlFileEntry.getVersion(), dlFileVersion.getVersion()) <= 0)) {
1163
1164 reindex(dlFileEntry);
1165 }
1166 }
1167
1168 protected void convertExtraSettings(DLFileEntry dlFileEntry, String[] keys)
1169 throws PortalException, SystemException {
1170
1171 UnicodeProperties extraSettingsProperties =
1172 dlFileEntry.getExtraSettingsProperties();
1173
1174 ExpandoBridge expandoBridge = dlFileEntry.getExpandoBridge();
1175
1176 convertExtraSettings(extraSettingsProperties, expandoBridge, keys);
1177
1178 dlFileEntry.setExtraSettingsProperties(extraSettingsProperties);
1179
1180 dlFileEntryPersistence.update(dlFileEntry, false);
1181
1182 List<DLFileVersion> dlFileVersions =
1183 dlFileVersionLocalService.getFileVersions(
1184 dlFileEntry.getFileEntryId(), WorkflowConstants.STATUS_ANY);
1185
1186 for (DLFileVersion dlFileVersion : dlFileVersions) {
1187 convertExtraSettings(dlFileEntry, dlFileVersion, keys);
1188 }
1189 }
1190
1191 protected void convertExtraSettings(
1192 UnicodeProperties extraSettingsProperties, ExpandoBridge expandoBridge,
1193 String[] keys) {
1194
1195 for (String key : keys) {
1196 String value = extraSettingsProperties.remove(key);
1197
1198 if (Validator.isNull(value)) {
1199 continue;
1200 }
1201
1202 int type = expandoBridge.getAttributeType(key);
1203
1204 Serializable serializable = ExpandoColumnConstants.getSerializable(
1205 type, value);
1206
1207 expandoBridge.setAttribute(key, serializable);
1208 }
1209 }
1210
1211 protected void deleteFileEntry(DLFileEntry dlFileEntry)
1212 throws PortalException, SystemException {
1213
1214
1215
1216 dlFileEntryPersistence.remove(dlFileEntry);
1217
1218
1219
1220 resourceLocalService.deleteResource(
1221 dlFileEntry.getCompanyId(), DLFileEntry.class.getName(),
1222 ResourceConstants.SCOPE_INDIVIDUAL, dlFileEntry.getFileEntryId());
1223
1224
1225
1226 webDAVPropsLocalService.deleteWebDAVProps(
1227 DLFileEntry.class.getName(), dlFileEntry.getFileEntryId());
1228
1229
1230
1231 dlFileEntryMetadataLocalService.deleteFileEntryMetadata(
1232 dlFileEntry.getFileEntryId());
1233
1234
1235
1236 List<DLFileVersion> dlFileVersions =
1237 dlFileVersionPersistence.findByFileEntryId(
1238 dlFileEntry.getFileEntryId());
1239
1240 for (DLFileVersion dlFileVersion : dlFileVersions) {
1241 dlFileVersionPersistence.remove(dlFileVersion);
1242
1243 expandoValueLocalService.deleteValues(
1244 DLFileVersion.class.getName(),
1245 dlFileVersion.getFileVersionId());
1246
1247 workflowInstanceLinkLocalService.deleteWorkflowInstanceLinks(
1248 dlFileEntry.getCompanyId(), dlFileEntry.getGroupId(),
1249 DLFileEntry.class.getName(), dlFileVersion.getFileVersionId());
1250 }
1251
1252
1253
1254 expandoValueLocalService.deleteValues(
1255 DLFileEntry.class.getName(), dlFileEntry.getFileEntryId());
1256
1257
1258
1259 lockLocalService.unlock(
1260 DLFileEntry.class.getName(), dlFileEntry.getFileEntryId());
1261
1262
1263
1264 try {
1265 DLStoreUtil.deleteFile(
1266 dlFileEntry.getCompanyId(), dlFileEntry.getDataRepositoryId(),
1267 dlFileEntry.getName());
1268 }
1269 catch (Exception e) {
1270 if (_log.isWarnEnabled()) {
1271 _log.warn(e, e);
1272 }
1273 }
1274
1275
1276
1277 Indexer indexer = IndexerRegistryUtil.getIndexer(DLFileEntry.class);
1278
1279 indexer.delete(dlFileEntry);
1280 }
1281
1282 protected String getExtension(String title, String sourceFileName) {
1283 if (Validator.isNull(sourceFileName)) {
1284 sourceFileName = title;
1285 }
1286
1287 return FileUtil.getExtension(sourceFileName);
1288 }
1289
1290 protected Long getFileEntryTypeId(
1291 long[] groupIds, long folderId, long fileEntryTypeId)
1292 throws PortalException, SystemException {
1293
1294 if (fileEntryTypeId == -1) {
1295 fileEntryTypeId =
1296 dlFileEntryTypeLocalService.getDefaultFileEntryTypeId(folderId);
1297 }
1298 else {
1299 List<DLFileEntryType> dlFileEntryTypes =
1300 dlFileEntryTypeLocalService.getFolderFileEntryTypes(
1301 groupIds, folderId, true);
1302
1303 boolean found = false;
1304
1305 for (DLFileEntryType dlFileEntryType : dlFileEntryTypes) {
1306 if (dlFileEntryType.getFileEntryTypeId() == fileEntryTypeId) {
1307 found = true;
1308
1309 break;
1310 }
1311 }
1312
1313 if (!found) {
1314 throw new InvalidFileEntryTypeException(
1315 "Invalid file entry type " + fileEntryTypeId +
1316 " for folder " + folderId);
1317 }
1318 }
1319
1320 return fileEntryTypeId;
1321 }
1322
1323 protected String getNextVersion(
1324 DLFileEntry dlFileEntry, boolean majorVersion, int workflowAction)
1325 throws PortalException, SystemException {
1326
1327 String version = dlFileEntry.getVersion();
1328
1329 try {
1330 DLFileVersion dlFileVersion =
1331 dlFileVersionLocalService.getLatestFileVersion(
1332 dlFileEntry.getFileEntryId(), true);
1333
1334 version = dlFileVersion.getVersion();
1335 }
1336 catch (NoSuchFileVersionException nsfve) {
1337 }
1338
1339 if (workflowAction == WorkflowConstants.ACTION_SAVE_DRAFT) {
1340 majorVersion = false;
1341 }
1342
1343 int[] versionParts = StringUtil.split(version, StringPool.PERIOD, 0);
1344
1345 if (majorVersion) {
1346 versionParts[0]++;
1347 versionParts[1] = 0;
1348 }
1349 else {
1350 versionParts[1]++;
1351 }
1352
1353 return versionParts[0] + StringPool.PERIOD + versionParts[1];
1354 }
1355
1356 protected Lock lockFileEntry(long userId, long fileEntryId)
1357 throws PortalException, SystemException {
1358
1359 return lockFileEntry(
1360 userId, fileEntryId, null, DLFileEntryImpl.LOCK_EXPIRATION_TIME);
1361 }
1362
1363 protected Lock lockFileEntry(
1364 long userId, long fileEntryId, String owner, long expirationTime)
1365 throws PortalException, SystemException {
1366
1367 if ((expirationTime <= 0) ||
1368 (expirationTime > DLFileEntryImpl.LOCK_EXPIRATION_TIME)) {
1369
1370 expirationTime = DLFileEntryImpl.LOCK_EXPIRATION_TIME;
1371 }
1372
1373 return lockLocalService.lock(
1374 userId, DLFileEntry.class.getName(), fileEntryId, owner, false,
1375 expirationTime);
1376 }
1377
1378 protected DLFileEntry moveFileEntryImpl(
1379 long userId, long fileEntryId, long newFolderId,
1380 ServiceContext serviceContext)
1381 throws PortalException, SystemException {
1382
1383
1384
1385 User user = userPersistence.findByPrimaryKey(userId);
1386 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
1387 fileEntryId);
1388
1389 long oldDataRepositoryId = dlFileEntry.getDataRepositoryId();
1390
1391 validateFile(
1392 dlFileEntry.getGroupId(), newFolderId, dlFileEntry.getFileEntryId(),
1393 dlFileEntry.getTitle());
1394
1395 if (DLStoreUtil.hasFile(
1396 user.getCompanyId(),
1397 DLFolderConstants.getDataRepositoryId(
1398 dlFileEntry.getGroupId(), newFolderId),
1399 dlFileEntry.getName(), StringPool.BLANK)) {
1400
1401 throw new DuplicateFileException(dlFileEntry.getName());
1402 }
1403
1404 dlFileEntry.setFolderId(newFolderId);
1405
1406 dlFileEntryPersistence.update(dlFileEntry, false);
1407
1408
1409
1410 List<DLFileVersion> dlFileVersions =
1411 dlFileVersionPersistence.findByFileEntryId(fileEntryId);
1412
1413 for (DLFileVersion dlFileVersion : dlFileVersions) {
1414 dlFileVersion.setFolderId(newFolderId);
1415
1416 dlFileVersionPersistence.update(dlFileVersion, false);
1417 }
1418
1419
1420
1421 DLStoreUtil.updateFile(
1422 user.getCompanyId(), oldDataRepositoryId,
1423 dlFileEntry.getDataRepositoryId(), dlFileEntry.getName());
1424
1425
1426
1427 reindex(dlFileEntry);
1428
1429 return dlFileEntry;
1430 }
1431
1432 protected void reindex(DLFileEntry dlFileEntry) throws SearchException {
1433 Indexer indexer = IndexerRegistryUtil.getIndexer(DLFileEntry.class);
1434
1435 indexer.reindex(dlFileEntry);
1436 }
1437
1438 protected void unlockFileEntry(long fileEntryId) throws SystemException {
1439 lockLocalService.unlock(DLFileEntry.class.getName(), fileEntryId);
1440 }
1441
1442 protected DLFileEntry updateFileEntry(
1443 long userId, long fileEntryId, String sourceFileName,
1444 String extension, String mimeType, String title, String description,
1445 String changeLog, boolean majorVersion, String extraSettings,
1446 long fileEntryTypeId, Map<String, Fields> fieldsMap, File file,
1447 InputStream is, long size, ServiceContext serviceContext)
1448 throws PortalException, SystemException {
1449
1450 User user = userPersistence.findByPrimaryKey(userId);
1451 DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
1452 fileEntryId);
1453
1454 boolean checkedOut = dlFileEntry.isCheckedOut();
1455
1456 DLFileVersion dlFileVersion =
1457 dlFileVersionLocalService.getLatestFileVersion(
1458 fileEntryId, !checkedOut);
1459
1460 boolean autoCheckIn = !checkedOut && dlFileVersion.isApproved();
1461
1462 if (autoCheckIn) {
1463 dlFileEntry = checkOutFileEntry(userId, fileEntryId);
1464 }
1465 else if (!checkedOut) {
1466 lockFileEntry(userId, fileEntryId);
1467 }
1468 else if (!hasFileEntryLock(userId, fileEntryId)) {
1469 lockFileEntry(userId, fileEntryId);
1470 }
1471
1472 if (checkedOut || autoCheckIn) {
1473 dlFileVersion = dlFileVersionLocalService.getLatestFileVersion(
1474 fileEntryId, false);
1475 }
1476
1477 try {
1478 if (Validator.isNull(extension)) {
1479 extension = dlFileEntry.getExtension();
1480 }
1481
1482 if (Validator.isNull(mimeType)) {
1483 mimeType = dlFileEntry.getMimeType();
1484 }
1485
1486 if (Validator.isNull(title)) {
1487 title = sourceFileName;
1488
1489 if (Validator.isNull(title)) {
1490 title = dlFileEntry.getTitle();
1491 }
1492 }
1493
1494 Date now = new Date();
1495
1496 validateFile(
1497 dlFileEntry.getGroupId(), dlFileEntry.getFolderId(),
1498 dlFileEntry.getFileEntryId(), extension, title, sourceFileName,
1499 file, is);
1500
1501
1502
1503 String version = dlFileVersion.getVersion();
1504
1505 if (size == 0) {
1506 size = dlFileVersion.getSize();
1507 }
1508
1509 updateFileVersion(
1510 user, dlFileVersion, sourceFileName, extension, mimeType, title,
1511 description, changeLog, extraSettings, fileEntryTypeId,
1512 fieldsMap, version, size, dlFileVersion.getStatus(),
1513 serviceContext.getModifiedDate(now), serviceContext);
1514
1515
1516
1517 dlAppHelperLocalService.updateAsset(
1518 userId, new LiferayFileEntry(dlFileEntry),
1519 new LiferayFileVersion(dlFileVersion),
1520 serviceContext.getAssetCategoryIds(),
1521 serviceContext.getAssetTagNames(),
1522 serviceContext.getAssetLinkEntryIds());
1523
1524
1525
1526 if ((file != null) || (is != null)) {
1527 try {
1528 DLStoreUtil.deleteFile(
1529 user.getCompanyId(), dlFileEntry.getDataRepositoryId(),
1530 dlFileEntry.getName(), version);
1531 }
1532 catch (NoSuchFileException nsfe) {
1533 }
1534
1535 if (file != null) {
1536 DLStoreUtil.updateFile(
1537 user.getCompanyId(), dlFileEntry.getDataRepositoryId(),
1538 dlFileEntry.getName(), dlFileEntry.getExtension(),
1539 false, version, sourceFileName, file);
1540 }
1541 else {
1542 DLStoreUtil.updateFile(
1543 user.getCompanyId(), dlFileEntry.getDataRepositoryId(),
1544 dlFileEntry.getName(), dlFileEntry.getExtension(),
1545 false, version, sourceFileName, is);
1546 }
1547
1548
1549
1550 reindex(dlFileEntry);
1551 }
1552
1553 if (autoCheckIn) {
1554 checkInFileEntry(
1555 userId, fileEntryId, majorVersion, changeLog,
1556 serviceContext);
1557 }
1558 }
1559 catch (PortalException pe) {
1560 if (autoCheckIn) {
1561 cancelCheckOut(userId, fileEntryId);
1562 }
1563
1564 throw pe;
1565 }
1566 catch (SystemException se) {
1567 if (autoCheckIn) {
1568 cancelCheckOut(userId, fileEntryId);
1569 }
1570
1571 throw se;
1572 }
1573 finally {
1574 if (!autoCheckIn && !checkedOut) {
1575 unlockFileEntry(fileEntryId);
1576 }
1577 }
1578
1579 return dlFileEntry;
1580 }
1581
1582 protected void updateFileVersion(
1583 User user, DLFileVersion dlFileVersion, String sourceFileName,
1584 String extension, String mimeType, String title, String description,
1585 String changeLog, String extraSettings, long fileEntryTypeId,
1586 Map<String, Fields> fieldsMap, String version, long size,
1587 int status, Date statusDate, ServiceContext serviceContext)
1588 throws PortalException, SystemException {
1589
1590 dlFileVersion.setModifiedDate(statusDate);
1591
1592 if (Validator.isNotNull(sourceFileName)) {
1593 dlFileVersion.setExtension(extension);
1594 dlFileVersion.setMimeType(mimeType);
1595 }
1596
1597 dlFileVersion.setTitle(title);
1598 dlFileVersion.setDescription(description);
1599 dlFileVersion.setChangeLog(changeLog);
1600 dlFileVersion.setExtraSettings(extraSettings);
1601 dlFileVersion.setFileEntryTypeId(fileEntryTypeId);
1602 dlFileVersion.setVersion(version);
1603 dlFileVersion.setSize(size);
1604 dlFileVersion.setStatus(status);
1605 dlFileVersion.setStatusByUserId(user.getUserId());
1606 dlFileVersion.setStatusByUserName(user.getFullName());
1607 dlFileVersion.setStatusDate(statusDate);
1608 dlFileVersion.setExpandoBridgeAttributes(serviceContext);
1609
1610 dlFileVersionPersistence.update(dlFileVersion, false);
1611
1612 if ((fileEntryTypeId > 0) && (fieldsMap != null)) {
1613 dlFileEntryMetadataLocalService.updateFileEntryMetadata(
1614 fileEntryTypeId, dlFileVersion.getFileEntryId(),
1615 dlFileVersion.getFileVersionId(), fieldsMap,
1616 serviceContext);
1617 }
1618 }
1619
1620 protected void validateFile(
1621 long groupId, long folderId, long fileEntryId, String title)
1622 throws PortalException, SystemException {
1623
1624 DLFolder dlFolder = dlFolderPersistence.fetchByG_P_N(
1625 groupId, folderId, title);
1626
1627 if (dlFolder != null) {
1628 throw new DuplicateFolderNameException(title);
1629 }
1630
1631 DLFileEntry dlFileEntry = dlFileEntryPersistence.fetchByG_F_T(
1632 groupId, folderId, title);
1633
1634 if ((dlFileEntry != null) &&
1635 (dlFileEntry.getFileEntryId() != fileEntryId)) {
1636
1637 throw new DuplicateFileException(title);
1638 }
1639 }
1640
1641 protected void validateFile(
1642 long groupId, long folderId, long fileEntryId, String extension,
1643 String title, String sourceFileName, File file, InputStream is)
1644 throws PortalException, SystemException {
1645
1646 if (Validator.isNotNull(sourceFileName)) {
1647 if (file != null) {
1648 DLStoreUtil.validate(
1649 sourceFileName, extension, sourceFileName, true, file);
1650 }
1651 else {
1652 DLStoreUtil.validate(
1653 sourceFileName, extension, sourceFileName, true, is);
1654 }
1655 }
1656
1657 validateFileName(title);
1658
1659 DLStoreUtil.validate(title, false);
1660
1661 validateFile(groupId, folderId, fileEntryId, title);
1662 }
1663
1664 protected void validateFile(
1665 long groupId, long folderId, String title, String extension,
1666 File file, InputStream is)
1667 throws PortalException, SystemException {
1668
1669 String fileName = title + StringPool.PERIOD + extension;
1670
1671 validateFileName(fileName);
1672
1673 if (file != null) {
1674 DLStoreUtil.validate(fileName, true, file);
1675 }
1676 else {
1677 DLStoreUtil.validate(fileName, true, is);
1678 }
1679
1680 validateFile(groupId, folderId, 0, title);
1681 }
1682
1683 protected void validateFileName(String fileName) throws PortalException {
1684 if (fileName.contains(StringPool.SLASH)) {
1685 throw new FileNameException(fileName);
1686 }
1687 }
1688
1689 private static Log _log = LogFactoryUtil.getLog(
1690 DLFileEntryLocalServiceImpl.class);
1691
1692 }