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