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