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