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