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