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