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