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