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