001    /**
002     * Copyright (c) 2000-2012 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.portal.ExpiredLockException;
018    import com.liferay.portal.InvalidLockException;
019    import com.liferay.portal.NoSuchLockException;
020    import com.liferay.portal.kernel.exception.PortalException;
021    import com.liferay.portal.kernel.exception.SystemException;
022    import com.liferay.portal.kernel.image.ImageBag;
023    import com.liferay.portal.kernel.image.ImageToolUtil;
024    import com.liferay.portal.kernel.log.Log;
025    import com.liferay.portal.kernel.log.LogFactoryUtil;
026    import com.liferay.portal.kernel.search.Indexer;
027    import com.liferay.portal.kernel.search.IndexerRegistryUtil;
028    import com.liferay.portal.kernel.search.SearchException;
029    import com.liferay.portal.kernel.util.FileUtil;
030    import com.liferay.portal.kernel.util.GetterUtil;
031    import com.liferay.portal.kernel.util.OrderByComparator;
032    import com.liferay.portal.kernel.util.PropsKeys;
033    import com.liferay.portal.kernel.util.StringPool;
034    import com.liferay.portal.kernel.util.StringUtil;
035    import com.liferay.portal.kernel.util.UnicodeProperties;
036    import com.liferay.portal.kernel.util.Validator;
037    import com.liferay.portal.kernel.workflow.WorkflowConstants;
038    import com.liferay.portal.kernel.workflow.WorkflowHandlerRegistryUtil;
039    import com.liferay.portal.model.Image;
040    import com.liferay.portal.model.Lock;
041    import com.liferay.portal.model.ResourceConstants;
042    import com.liferay.portal.model.User;
043    import com.liferay.portal.repository.liferayrepository.model.LiferayFileEntry;
044    import com.liferay.portal.repository.liferayrepository.model.LiferayFileVersion;
045    import com.liferay.portal.service.ServiceContext;
046    import com.liferay.portal.util.PortalUtil;
047    import com.liferay.portal.util.PrefsPropsUtil;
048    import com.liferay.portal.util.PropsValues;
049    import com.liferay.portlet.documentlibrary.DuplicateFileException;
050    import com.liferay.portlet.documentlibrary.DuplicateFolderNameException;
051    import com.liferay.portlet.documentlibrary.FileNameException;
052    import com.liferay.portlet.documentlibrary.ImageSizeException;
053    import com.liferay.portlet.documentlibrary.InvalidFileEntryTypeException;
054    import com.liferay.portlet.documentlibrary.NoSuchFileEntryMetadataException;
055    import com.liferay.portlet.documentlibrary.NoSuchFileException;
056    import com.liferay.portlet.documentlibrary.NoSuchFileVersionException;
057    import com.liferay.portlet.documentlibrary.model.DLFileEntry;
058    import com.liferay.portlet.documentlibrary.model.DLFileEntryConstants;
059    import com.liferay.portlet.documentlibrary.model.DLFileEntryMetadata;
060    import com.liferay.portlet.documentlibrary.model.DLFileEntryType;
061    import com.liferay.portlet.documentlibrary.model.DLFileVersion;
062    import com.liferay.portlet.documentlibrary.model.DLFolder;
063    import com.liferay.portlet.documentlibrary.model.DLFolderConstants;
064    import com.liferay.portlet.documentlibrary.model.DLSyncConstants;
065    import com.liferay.portlet.documentlibrary.model.impl.DLFileEntryImpl;
066    import com.liferay.portlet.documentlibrary.service.base.DLFileEntryLocalServiceBaseImpl;
067    import com.liferay.portlet.documentlibrary.store.DLStoreUtil;
068    import com.liferay.portlet.documentlibrary.util.DLUtil;
069    import com.liferay.portlet.documentlibrary.util.comparator.RepositoryModelModifiedDateComparator;
070    import com.liferay.portlet.dynamicdatamapping.model.DDMStructure;
071    import com.liferay.portlet.dynamicdatamapping.storage.Fields;
072    import com.liferay.portlet.dynamicdatamapping.storage.StorageEngineUtil;
073    import com.liferay.portlet.expando.model.ExpandoBridge;
074    import com.liferay.portlet.expando.model.ExpandoColumnConstants;
075    
076    import java.awt.image.RenderedImage;
077    
078    import java.io.File;
079    import java.io.IOException;
080    import java.io.InputStream;
081    import java.io.Serializable;
082    
083    import java.util.Date;
084    import java.util.HashMap;
085    import java.util.List;
086    import java.util.Map;
087    
088    /**
089     * The document library file entry local service.
090     *
091     * <p>
092     * Due to legacy code, the names of some file entry properties are not
093     * intuitive. Each file entry has both a name and title. The <code>name</code>
094     * is a unique identifier for a given file and is generally numeric, whereas the
095     * <code>title</code> is the actual name specified by the user (such as
096     * &quot;Budget.xls&quot;).
097     * </p>
098     *
099     * @author Brian Wing Shun Chan
100     * @author Harry Mark
101     * @author Alexander Chow
102     */
103    public class DLFileEntryLocalServiceImpl
104            extends DLFileEntryLocalServiceBaseImpl {
105    
106            public DLFileEntry addFileEntry(
107                            long userId, long groupId, long repositoryId, long folderId,
108                            String sourceFileName, String mimeType, String title,
109                            String description, String changeLog, long fileEntryTypeId,
110                            Map<String, Fields> fieldsMap, File file, InputStream is, long size,
111                            ServiceContext serviceContext)
112                    throws PortalException, SystemException {
113    
114                    if ((size == 0) && Validator.isNull(title)) {
115                            throw new FileNameException();
116                    }
117    
118                    // File entry
119    
120                    User user = userPersistence.findByPrimaryKey(userId);
121                    folderId = dlFolderLocalService.getFolderId(
122                            user.getCompanyId(), folderId);
123                    String name = String.valueOf(
124                            counterLocalService.increment(DLFileEntry.class.getName()));
125                    String extension = getExtension(title, sourceFileName);
126                    fileEntryTypeId = getFileEntryTypeId(
127                            DLUtil.getGroupIds(groupId), folderId, fileEntryTypeId);
128                    Date now = new Date();
129    
130                    validateFile(groupId, folderId, title, extension, file, is);
131    
132                    long fileEntryId = counterLocalService.increment();
133    
134                    DLFileEntry dlFileEntry = dlFileEntryPersistence.create(fileEntryId);
135    
136                    dlFileEntry.setUuid(serviceContext.getUuid());
137                    dlFileEntry.setGroupId(groupId);
138                    dlFileEntry.setCompanyId(user.getCompanyId());
139                    dlFileEntry.setUserId(user.getUserId());
140                    dlFileEntry.setUserName(user.getFullName());
141                    dlFileEntry.setVersionUserId(user.getUserId());
142                    dlFileEntry.setVersionUserName(user.getFullName());
143                    dlFileEntry.setCreateDate(serviceContext.getCreateDate(now));
144                    dlFileEntry.setModifiedDate(serviceContext.getModifiedDate(now));
145                    dlFileEntry.setRepositoryId(repositoryId);
146                    dlFileEntry.setFolderId(folderId);
147                    dlFileEntry.setName(name);
148                    dlFileEntry.setExtension(extension);
149                    dlFileEntry.setMimeType(mimeType);
150                    dlFileEntry.setTitle(title);
151                    dlFileEntry.setDescription(description);
152                    dlFileEntry.setFileEntryTypeId(fileEntryTypeId);
153                    dlFileEntry.setVersion(DLFileEntryConstants.VERSION_DEFAULT);
154                    dlFileEntry.setSize(size);
155                    dlFileEntry.setReadCount(DLFileEntryConstants.DEFAULT_READ_COUNT);
156    
157                    dlFileEntryPersistence.update(dlFileEntry, false);
158    
159                    // File version
160    
161                    DLFileVersion dlFileVersion = addFileVersion(
162                            user, dlFileEntry, serviceContext.getModifiedDate(now), extension,
163                            mimeType, title, description, null, StringPool.BLANK,
164                            fileEntryTypeId, fieldsMap, DLFileEntryConstants.VERSION_DEFAULT,
165                            size, WorkflowConstants.STATUS_DRAFT, serviceContext);
166    
167                    dlFileEntry.setFileVersion(dlFileVersion);
168    
169                    // Folder
170    
171                    if (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
172                            dlFolderLocalService.updateLastPostDate(
173                                    dlFileEntry.getFolderId(), dlFileEntry.getModifiedDate());
174                    }
175    
176                    // File
177    
178                    if (file != null) {
179                            DLStoreUtil.addFile(
180                                    user.getCompanyId(), dlFileEntry.getDataRepositoryId(), name,
181                                    false, file);
182                    }
183                    else {
184                            DLStoreUtil.addFile(
185                                    user.getCompanyId(), dlFileEntry.getDataRepositoryId(), name,
186                                    false, is);
187                    }
188    
189                    return dlFileEntry;
190            }
191    
192            public void addFileEntryResources(
193                            DLFileEntry dlFileEntry, boolean addGroupPermissions,
194                            boolean addGuestPermissions)
195                    throws PortalException, SystemException {
196    
197                    resourceLocalService.addResources(
198                            dlFileEntry.getCompanyId(), dlFileEntry.getGroupId(),
199                            dlFileEntry.getUserId(), DLFileEntry.class.getName(),
200                            dlFileEntry.getFileEntryId(), false, addGroupPermissions,
201                            addGuestPermissions);
202            }
203    
204            public void addFileEntryResources(
205                            DLFileEntry dlFileEntry, String[] groupPermissions,
206                            String[] guestPermissions)
207                    throws PortalException, SystemException {
208    
209                    resourceLocalService.addModelResources(
210                            dlFileEntry.getCompanyId(), dlFileEntry.getGroupId(),
211                            dlFileEntry.getUserId(), DLFileEntry.class.getName(),
212                            dlFileEntry.getFileEntryId(), groupPermissions, guestPermissions);
213            }
214    
215            public void cancelCheckOut(long userId, long fileEntryId)
216                    throws PortalException, SystemException {
217    
218                    if (!isFileEntryCheckedOut(fileEntryId)) {
219                            return;
220                    }
221    
222                    if (!hasFileEntryLock(userId, fileEntryId)) {
223                            lockFileEntry(userId, fileEntryId);
224                    }
225    
226                    DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
227                            fileEntryId);
228    
229                    DLFileVersion dlFileVersion =
230                            dlFileVersionLocalService.getLatestFileVersion(fileEntryId, false);
231    
232                    dlFileVersionPersistence.remove(dlFileVersion);
233    
234                    try {
235                            DLStoreUtil.deleteFile(
236                                    dlFileEntry.getCompanyId(), dlFileEntry.getDataRepositoryId(),
237                                    dlFileEntry.getName(),
238                                    DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION);
239                    }
240                    catch (NoSuchFileException nsfe) {
241                    }
242    
243                    lockLocalService.unlock(DLFileEntry.class.getName(), fileEntryId);
244            }
245    
246            public void checkInFileEntry(
247                            long userId, long fileEntryId, boolean majorVersion,
248                            String changeLog, ServiceContext serviceContext)
249                    throws PortalException, SystemException {
250    
251                    if (!isFileEntryCheckedOut(fileEntryId)) {
252                            return;
253                    }
254    
255                    if (!hasFileEntryLock(userId, fileEntryId)) {
256                            lockFileEntry(userId, fileEntryId);
257                    }
258    
259                    User user = userPersistence.findByPrimaryKey(userId);
260                    DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
261                            fileEntryId);
262    
263                    String version = getNextVersion(
264                            dlFileEntry, majorVersion, serviceContext.getWorkflowAction());
265    
266                    DLFileVersion dlFileVersion =
267                            dlFileVersionLocalService.getLatestFileVersion(fileEntryId, false);
268    
269                    dlFileVersion.setVersion(version);
270                    dlFileVersion.setChangeLog(changeLog);
271    
272                    dlFileVersionPersistence.update(dlFileVersion, false);
273    
274                    // Folder
275    
276                    if (dlFileEntry.getFolderId() !=
277                                    DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
278    
279                            dlFolderLocalService.updateLastPostDate(
280                                    dlFileEntry.getFolderId(), dlFileEntry.getModifiedDate());
281                    }
282    
283                    // File
284    
285                    DLStoreUtil.updateFileVersion(
286                            user.getCompanyId(), dlFileEntry.getDataRepositoryId(),
287                            dlFileEntry.getName(),
288                            DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION, version);
289    
290                    if (serviceContext.getWorkflowAction() ==
291                                    WorkflowConstants.ACTION_PUBLISH) {
292    
293                            startWorkflowInstance(
294                                    userId, serviceContext, dlFileVersion,
295                                    DLSyncConstants.EVENT_UPDATE);
296                    }
297    
298                    lockLocalService.unlock(DLFileEntry.class.getName(), fileEntryId);
299            }
300    
301            public void checkInFileEntry(long userId, long fileEntryId, String lockUuid)
302                    throws PortalException, SystemException {
303    
304                    if (Validator.isNotNull(lockUuid)) {
305                            try {
306                                    Lock lock = lockLocalService.getLock(
307                                            DLFileEntry.class.getName(), fileEntryId);
308    
309                                    if (!lock.getUuid().equals(lockUuid)) {
310                                            throw new InvalidLockException("UUIDs do not match");
311                                    }
312                            }
313                            catch (PortalException pe) {
314                                    if ((pe instanceof ExpiredLockException) ||
315                                            (pe instanceof NoSuchLockException)) {
316                                    }
317                                    else {
318                                            throw pe;
319                                    }
320                            }
321                    }
322    
323                    checkInFileEntry(
324                            userId, fileEntryId, false, StringPool.BLANK, new ServiceContext());
325            }
326    
327            public DLFileEntry checkOutFileEntry(long userId, long fileEntryId)
328                    throws PortalException, SystemException {
329    
330                    return checkOutFileEntry(
331                            userId, fileEntryId, StringPool.BLANK,
332                            DLFileEntryImpl.LOCK_EXPIRATION_TIME);
333            }
334    
335            public DLFileEntry checkOutFileEntry(
336                            long userId, long fileEntryId, String owner, long expirationTime)
337                    throws PortalException, SystemException {
338    
339                    DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
340                            fileEntryId);
341    
342                    boolean hasLock = hasFileEntryLock(userId, fileEntryId);
343    
344                    if (!hasLock) {
345                            if ((expirationTime <= 0) ||
346                                    (expirationTime > DLFileEntryImpl.LOCK_EXPIRATION_TIME)) {
347    
348                                    expirationTime = DLFileEntryImpl.LOCK_EXPIRATION_TIME;
349                            }
350    
351                            lockLocalService.lock(
352                                    userId, DLFileEntry.class.getName(), fileEntryId, owner,
353                                    false, expirationTime);
354                    }
355    
356                    User user = userPersistence.findByPrimaryKey(userId);
357    
358                    dlFileEntryPersistence.update(dlFileEntry, false);
359    
360                    DLFileVersion dlFileVersion =
361                            dlFileVersionLocalService.getLatestFileVersion(fileEntryId, false);
362    
363                    long dlFileVersionId = dlFileVersion.getFileVersionId();
364    
365                    String version = dlFileVersion.getVersion();
366    
367                    if (!version.equals(
368                                    DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION)) {
369    
370                            ServiceContext serviceContext = new ServiceContext();
371    
372                            serviceContext.setCompanyId(user.getCompanyId());
373                            serviceContext.setUserId(userId);
374    
375                            dlFileVersion = addFileVersion(
376                                    user, dlFileEntry, new Date(), dlFileVersion.getExtension(),
377                                    dlFileVersion.getMimeType(), dlFileVersion.getTitle(),
378                                    dlFileVersion.getDescription(), dlFileVersion.getChangeLog(),
379                                    dlFileVersion.getExtraSettings(),
380                                    dlFileVersion.getFileEntryTypeId(), null,
381                                    DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION,
382                                    dlFileVersion.getSize(), WorkflowConstants.STATUS_DRAFT,
383                                    serviceContext);
384    
385                            try {
386                                    DLStoreUtil.deleteFile(
387                                            dlFileEntry.getCompanyId(),
388                                            dlFileEntry.getDataRepositoryId(), dlFileEntry.getName(),
389                                            DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION);
390                            }
391                            catch (NoSuchFileException nsfe) {
392                            }
393    
394                            DLStoreUtil.copyFileVersion(
395                                    user.getCompanyId(), dlFileEntry.getDataRepositoryId(),
396                                    dlFileEntry.getName(), version,
397                                    DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION);
398    
399                            copyFileEntryMetadata(
400                                    dlFileEntry.getCompanyId(), dlFileVersion.getFileEntryTypeId(),
401                                    fileEntryId, dlFileVersionId, dlFileVersion.getFileVersionId(),
402                                    serviceContext);
403                    }
404    
405                    return dlFileEntry;
406            }
407    
408            public void convertExtraSettings(String[] keys)
409                    throws PortalException, SystemException {
410    
411                    int count = dlFileEntryFinder.countByExtraSettings();
412    
413                    int pages = count / Indexer.DEFAULT_INTERVAL;
414    
415                    for (int i = 0; i <= pages; i++) {
416                            int start = (i * Indexer.DEFAULT_INTERVAL);
417                            int end = start + Indexer.DEFAULT_INTERVAL;
418    
419                            List<DLFileEntry> dlFileEntries =
420                                    dlFileEntryFinder.findByExtraSettings(start, end);
421    
422                            for (DLFileEntry dlFileEntry : dlFileEntries) {
423                                    convertExtraSettings(dlFileEntry, keys);
424                            }
425                    }
426            }
427    
428            public void copyFileEntryMetadata(
429                            long companyId, long fileEntryTypeId, long fileEntryId,
430                            long fromFileVersionId, long toFileVersionId,
431                            ServiceContext serviceContext)
432                    throws PortalException, SystemException {
433    
434                    Map<String, Fields> fieldsMap = new HashMap<String, Fields>();
435    
436                    List<DDMStructure> ddmStructures = null;
437    
438                    if (fileEntryTypeId > 0) {
439                            DLFileEntryType dlFileEntryType =
440                                    dlFileEntryTypeLocalService.getFileEntryType(fileEntryTypeId);
441    
442                            ddmStructures = dlFileEntryType.getDDMStructures();
443    
444                            for (DDMStructure ddmStructure : ddmStructures) {
445                                    try {
446                                            DLFileEntryMetadata dlFileEntryMetadata =
447                                                    dlFileEntryMetadataLocalService.getFileEntryMetadata(
448                                                            ddmStructure.getStructureId(), fromFileVersionId);
449    
450                                            Fields fields = StorageEngineUtil.getFields(
451                                                    dlFileEntryMetadata.getDDMStorageId());
452    
453                                            fieldsMap.put(ddmStructure.getStructureKey(), fields);
454                                    }
455                                    catch (NoSuchFileEntryMetadataException nsfeme) {
456                                    }
457                            }
458    
459                            dlFileEntryMetadataLocalService.updateFileEntryMetadata(
460                                    companyId, ddmStructures, fileEntryTypeId, fileEntryId,
461                                    toFileVersionId, fieldsMap, serviceContext);
462                    }
463    
464                    long classNameId = PortalUtil.getClassNameId(DLFileEntry.class);
465    
466                    ddmStructures = ddmStructureLocalService.getClassStructures(
467                            classNameId);
468    
469                    for (DDMStructure ddmStructure : ddmStructures) {
470                            try {
471                                    DLFileEntryMetadata fileEntryMetadata =
472                                            dlFileEntryMetadataLocalService.getFileEntryMetadata(
473                                                    ddmStructure.getStructureId(), fromFileVersionId);
474    
475                                    Fields fields = StorageEngineUtil.getFields(
476                                            fileEntryMetadata.getDDMStorageId());
477    
478                                    fieldsMap.put(ddmStructure.getStructureKey(), fields);
479                            }
480                            catch (NoSuchFileEntryMetadataException nsfme) {
481                            }
482                    }
483    
484                    dlFileEntryMetadataLocalService.updateFileEntryMetadata(
485                            companyId, ddmStructures, fileEntryTypeId, fileEntryId,
486                            toFileVersionId, fieldsMap, serviceContext);
487            }
488    
489            public void deleteFileEntries(long groupId, long folderId)
490                    throws PortalException, SystemException {
491    
492                    int count = dlFileEntryPersistence.countByG_F(groupId, folderId);
493    
494                    int pages = count / _DELETE_INTERVAL;
495    
496                    for (int i = 0; i <= pages; i++) {
497                            int start = (i * _DELETE_INTERVAL);
498                            int end = start + _DELETE_INTERVAL;
499    
500                            List<DLFileEntry> dlFileEntries = dlFileEntryPersistence.findByG_F(
501                                    groupId, folderId, start, end);
502    
503                            for (DLFileEntry dlFileEntry : dlFileEntries) {
504                                    dlAppHelperLocalService.deleteFileEntry(
505                                            new LiferayFileEntry(dlFileEntry));
506    
507                                    deleteFileEntry(dlFileEntry);
508                            }
509                    }
510            }
511    
512            public void deleteFileEntry(long fileEntryId)
513                    throws PortalException, SystemException {
514    
515                    DLFileEntry dlFileEntry = getFileEntry(fileEntryId);
516    
517                    deleteFileEntry(dlFileEntry);
518            }
519    
520            public void deleteFileEntry(long userId, long fileEntryId)
521                    throws PortalException, SystemException {
522    
523                    if (!hasFileEntryLock(userId, fileEntryId)) {
524                            lockFileEntry(userId, fileEntryId);
525                    }
526    
527                    try {
528                            deleteFileEntry(fileEntryId);
529                    }
530                    finally {
531                            unlockFileEntry(fileEntryId);
532                    }
533            }
534    
535            public DLFileEntry fetchFileEntryByAnyImageId(long imageId)
536                    throws SystemException {
537    
538                    return dlFileEntryFinder.fetchByAnyImageId(imageId);
539            }
540    
541            public List<DLFileEntry> getExtraSettingsFileEntries(int start, int end)
542                    throws SystemException {
543    
544                    return dlFileEntryFinder.findByExtraSettings(start, end);
545            }
546    
547            public File getFile(
548                            long userId, long fileEntryId, String version,
549                            boolean incrementCounter)
550                    throws PortalException, SystemException {
551    
552                    DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
553                            fileEntryId);
554    
555                    if (PropsValues.DL_FILE_ENTRY_READ_COUNT_ENABLED && incrementCounter) {
556                            dlFileEntry.setReadCount(dlFileEntry.getReadCount() + 1);
557    
558                            dlFileEntryPersistence.update(dlFileEntry, false);
559                    }
560    
561                    dlAppHelperLocalService.getFileAsStream(
562                            userId, new LiferayFileEntry(dlFileEntry), incrementCounter);
563    
564                    return DLStoreUtil.getFile(
565                            dlFileEntry.getCompanyId(), dlFileEntry.getDataRepositoryId(),
566                            dlFileEntry.getName(), version);
567            }
568    
569            public InputStream getFileAsStream(
570                            long userId, long fileEntryId, String version)
571                    throws PortalException, SystemException {
572    
573                    return getFileAsStream(userId, fileEntryId, version, true);
574            }
575    
576            public InputStream getFileAsStream(
577                            long userId, long fileEntryId, String version,
578                            boolean incrementCounter)
579                    throws PortalException, SystemException {
580    
581                    DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
582                            fileEntryId);
583    
584                    if (PropsValues.DL_FILE_ENTRY_READ_COUNT_ENABLED && incrementCounter) {
585                            dlFileEntry.setReadCount(dlFileEntry.getReadCount() + 1);
586    
587                            dlFileEntryPersistence.update(dlFileEntry, false);
588                    }
589    
590                    dlAppHelperLocalService.getFileAsStream(
591                            userId, new LiferayFileEntry(dlFileEntry), incrementCounter);
592    
593                    return DLStoreUtil.getFileAsStream(
594                            dlFileEntry.getCompanyId(), dlFileEntry.getDataRepositoryId(),
595                            dlFileEntry.getName(), version);
596            }
597    
598            public List<DLFileEntry> getFileEntries(int start, int end)
599                    throws SystemException {
600    
601                    return dlFileEntryPersistence.findAll(start, end);
602            }
603    
604            public List<DLFileEntry> getFileEntries(
605                            long groupId, long folderId, int start, int end,
606                            OrderByComparator obc)
607                    throws SystemException {
608    
609                    return dlFileEntryPersistence.findByG_F(
610                            groupId, folderId, start, end, obc);
611            }
612    
613            public int getFileEntriesCount() throws SystemException {
614                    return dlFileEntryPersistence.countAll();
615            }
616    
617            public int getFileEntriesCount(long groupId, long folderId)
618                    throws SystemException {
619    
620                    return dlFileEntryPersistence.countByG_F(groupId, folderId);
621            }
622    
623            public DLFileEntry getFileEntry(long fileEntryId)
624                    throws PortalException, SystemException {
625    
626                    DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
627                            fileEntryId);
628    
629                    DLFileVersion dlFileVersion = dlFileVersionLocalService.getFileVersion(
630                            fileEntryId, dlFileEntry.getVersion());
631    
632                    dlFileEntry.setFileVersion(dlFileVersion);
633    
634                    return dlFileEntry;
635            }
636    
637            public DLFileEntry getFileEntry(long groupId, long folderId, String title)
638                    throws PortalException, SystemException {
639    
640                    DLFileEntry dlFileEntry = dlFileEntryPersistence.findByG_F_T(
641                            groupId, folderId, title);
642    
643                    DLFileVersion dlFileVersion = dlFileVersionLocalService.getFileVersion(
644                            dlFileEntry.getFileEntryId(), dlFileEntry.getVersion());
645    
646                    dlFileEntry.setFileVersion(dlFileVersion);
647    
648                    return dlFileEntry;
649            }
650    
651            public DLFileEntry getFileEntryByName(
652                            long groupId, long folderId, String name)
653                    throws PortalException, SystemException {
654    
655                    DLFileEntry dlFileEntry = dlFileEntryPersistence.findByG_F_N(
656                            groupId, folderId, name);
657    
658                    DLFileVersion dlFileVersion = dlFileVersionLocalService.getFileVersion(
659                            dlFileEntry.getFileEntryId(), dlFileEntry.getVersion());
660    
661                    dlFileEntry.setFileVersion(dlFileVersion);
662    
663                    return dlFileEntry;
664            }
665    
666            public DLFileEntry getFileEntryByUuidAndGroupId(String uuid, long groupId)
667                    throws PortalException, SystemException {
668    
669                    DLFileEntry dlFileEntry = dlFileEntryPersistence.findByUUID_G(
670                            uuid, groupId);
671    
672                    DLFileVersion dlFileVersion = dlFileVersionLocalService.getFileVersion(
673                            dlFileEntry.getFileEntryId(), dlFileEntry.getVersion());
674    
675                    dlFileEntry.setFileVersion(dlFileVersion);
676    
677                    return dlFileEntry;
678            }
679    
680            public List<DLFileEntry> getGroupFileEntries(
681                            long groupId, int start, int end)
682                    throws SystemException {
683    
684                    return getGroupFileEntries(
685                            groupId, start, end, new RepositoryModelModifiedDateComparator());
686            }
687    
688            public List<DLFileEntry> getGroupFileEntries(
689                            long groupId, int start, int end, OrderByComparator obc)
690                    throws SystemException {
691    
692                    return dlFileEntryPersistence.findByGroupId(groupId, start, end, obc);
693            }
694    
695            public List<DLFileEntry> getGroupFileEntries(
696                            long groupId, long userId, int start, int end)
697                    throws SystemException {
698    
699                    return getGroupFileEntries(
700                            groupId, userId, start, end,
701                            new RepositoryModelModifiedDateComparator());
702            }
703    
704            public List<DLFileEntry> getGroupFileEntries(
705                            long groupId, long userId, int start, int end,
706                            OrderByComparator obc)
707                    throws SystemException {
708    
709                    if (userId <= 0) {
710                            return dlFileEntryPersistence.findByGroupId(
711                                    groupId, start, end, obc);
712                    }
713                    else {
714                            return dlFileEntryPersistence.findByG_U(
715                                    groupId, userId, start, end, obc);
716                    }
717            }
718    
719            public int getGroupFileEntriesCount(long groupId) throws SystemException {
720                    return dlFileEntryPersistence.countByGroupId(groupId);
721            }
722    
723            public int getGroupFileEntriesCount(long groupId, long userId)
724                    throws SystemException {
725    
726                    if (userId <= 0) {
727                            return dlFileEntryPersistence.countByGroupId(groupId);
728                    }
729                    else {
730                            return dlFileEntryPersistence.countByG_U(groupId, userId);
731                    }
732            }
733    
734            public List<DLFileEntry> getNoAssetFileEntries() throws SystemException {
735                    return dlFileEntryFinder.findByNoAssets();
736            }
737    
738            public List<DLFileEntry> getOrphanedFileEntries() throws SystemException {
739                    return dlFileEntryFinder.findByOrphanedFileEntries();
740            }
741    
742            public boolean hasExtraSettings() throws SystemException {
743                    if (dlFileEntryFinder.countByExtraSettings() > 0) {
744                            return true;
745                    }
746                    else {
747                            return false;
748                    }
749            }
750    
751            public boolean hasFileEntryLock(long userId, long fileEntryId)
752                    throws PortalException, SystemException {
753    
754                    DLFileEntry dlFileEntry = getFileEntry(fileEntryId);
755    
756                    long folderId = dlFileEntry.getFolderId();
757    
758                    boolean hasLock = lockLocalService.hasLock(
759                            userId, DLFileEntry.class.getName(), fileEntryId);
760    
761                    if (!hasLock &&
762                            (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID)) {
763    
764                            hasLock = dlFolderService.hasInheritableLock(folderId);
765                    }
766    
767                    return hasLock;
768            }
769    
770            public boolean isFileEntryCheckedOut(long fileEntryId)
771                    throws PortalException, SystemException {
772    
773                    DLFileVersion dlFileVersion =
774                            dlFileVersionLocalService.getLatestFileVersion(fileEntryId, false);
775    
776                    String version = dlFileVersion.getVersion();
777    
778                    if (version.equals(DLFileEntryConstants.PRIVATE_WORKING_COPY_VERSION)) {
779                            return true;
780                    }
781                    else {
782                            return false;
783                    }
784            }
785    
786            public Lock lockFileEntry(long userId, long fileEntryId)
787                    throws PortalException, SystemException {
788    
789                    return lockFileEntry(
790                            userId, fileEntryId, null, DLFileEntryImpl.LOCK_EXPIRATION_TIME);
791            }
792    
793            public Lock lockFileEntry(
794                            long userId, long fileEntryId, String owner, long expirationTime)
795                    throws PortalException, SystemException {
796    
797                    if (hasFileEntryLock(userId, fileEntryId)) {
798                            return lockLocalService.getLock(
799                                    DLFileEntry.class.getName(), fileEntryId);
800                    }
801    
802                    if ((expirationTime <= 0) ||
803                            (expirationTime > DLFileEntryImpl.LOCK_EXPIRATION_TIME)) {
804    
805                            expirationTime = DLFileEntryImpl.LOCK_EXPIRATION_TIME;
806                    }
807    
808                    return lockLocalService.lock(
809                            userId, DLFileEntry.class.getName(), fileEntryId, owner, false,
810                            expirationTime);
811            }
812    
813            public DLFileEntry moveFileEntry(
814                            long userId, long fileEntryId, long newFolderId,
815                            ServiceContext serviceContext)
816                    throws PortalException, SystemException {
817    
818                    if (!hasFileEntryLock(userId, fileEntryId)) {
819                            lockFileEntry(userId, fileEntryId);
820                    }
821    
822                    try {
823                            DLFileEntry dlFileEntry = moveFileEntryImpl(
824                                    userId, fileEntryId, newFolderId, serviceContext);
825    
826                            dlAppHelperLocalService.moveFileEntry(
827                                    new LiferayFileEntry(dlFileEntry));
828    
829                            return dlFileEntryTypeLocalService.updateFileEntryFileEntryType(
830                                    dlFileEntry, serviceContext);
831                    }
832                    finally {
833                            if (!isFileEntryCheckedOut(fileEntryId)) {
834                                    unlockFileEntry(fileEntryId);
835                            }
836                    }
837            }
838    
839            public void revertFileEntry(
840                            long userId, long fileEntryId, String version,
841                            ServiceContext serviceContext)
842                    throws PortalException, SystemException {
843    
844                    DLFileVersion dlFileVersion = dlFileVersionLocalService.getFileVersion(
845                            fileEntryId, version);
846    
847                    if (!dlFileVersion.isApproved()) {
848                            return;
849                    }
850    
851                    String sourceFileName = dlFileVersion.getTitle();
852                    String extension = dlFileVersion.getExtension();
853                    String mimeType = dlFileVersion.getMimeType();
854                    String title = dlFileVersion.getTitle();
855                    String description = dlFileVersion.getDescription();
856                    String changeLog = "Reverted to " + version;
857                    boolean majorVersion = true;
858                    String extraSettings = dlFileVersion.getExtraSettings();
859                    long fileEntryTypeId = dlFileVersion.getFileEntryTypeId();
860                    Map<String, Fields> fieldsMap = null;
861                    InputStream is = getFileAsStream(userId, fileEntryId, version);
862                    long size = dlFileVersion.getSize();
863    
864                    DLFileEntry dlFileEntry = updateFileEntry(
865                            userId, fileEntryId, sourceFileName, extension, mimeType, title,
866                            description, changeLog, majorVersion, extraSettings,
867                            fileEntryTypeId, fieldsMap, null, is, size, serviceContext);
868    
869                    DLFileVersion newDlFileVersion =
870                            dlFileVersionLocalService.getFileVersion(
871                                    fileEntryId, dlFileEntry.getVersion());
872    
873                    copyFileEntryMetadata(
874                            dlFileVersion.getCompanyId(), dlFileVersion.getFileEntryTypeId(),
875                            fileEntryId, newDlFileVersion.getFileVersionId(),
876                            dlFileVersion.getFileVersionId(), serviceContext);
877            }
878    
879            public void unlockFileEntry(long fileEntryId) throws SystemException {
880                    lockLocalService.unlock(DLFileEntry.class.getName(), fileEntryId);
881            }
882    
883            public void unlockFileEntry(long fileEntryId, String lockUuid)
884                    throws PortalException, SystemException {
885    
886                    if (Validator.isNotNull(lockUuid)) {
887                            try {
888                                    Lock lock = lockLocalService.getLock(
889                                            DLFileEntry.class.getName(), fileEntryId);
890    
891                                    if (!lock.getUuid().equals(lockUuid)) {
892                                            throw new InvalidLockException("UUIDs do not match");
893                                    }
894                            }
895                            catch (PortalException pe) {
896                                    if ((pe instanceof ExpiredLockException) ||
897                                            (pe instanceof NoSuchLockException)) {
898                                    }
899                                    else {
900                                            throw pe;
901                                    }
902                            }
903                    }
904    
905                    if (!isFileEntryCheckedOut(fileEntryId)) {
906                            lockLocalService.unlock(DLFileEntry.class.getName(), fileEntryId);
907                    }
908            }
909    
910            public DLFileEntry updateFileEntry(
911                            long userId, long fileEntryId, String sourceFileName,
912                            String mimeType, String title, String description, String changeLog,
913                            boolean majorVersion, long fileEntryTypeId,
914                            Map<String, Fields> fieldsMap, File file, InputStream is, long size,
915                            ServiceContext serviceContext)
916                    throws PortalException, SystemException {
917    
918                    DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
919                            fileEntryId);
920    
921                    String extension = getExtension(title, sourceFileName);
922    
923                    String extraSettings = StringPool.BLANK;
924    
925                    fileEntryTypeId = getFileEntryTypeId(
926                            DLUtil.getGroupIds(dlFileEntry.getGroupId()),
927                            dlFileEntry.getFolderId(), fileEntryTypeId);
928    
929                    return updateFileEntry(
930                            userId, fileEntryId, sourceFileName, extension, mimeType, title,
931                            description, changeLog, majorVersion, extraSettings,
932                            fileEntryTypeId, fieldsMap, file, is, size, serviceContext);
933            }
934    
935            public void updateSmallImage(long smallImageId, long largeImageId)
936                    throws PortalException, SystemException {
937    
938                    try {
939                            RenderedImage renderedImage = null;
940    
941                            Image largeImage = imageLocalService.getImage(largeImageId);
942    
943                            byte[] bytes = largeImage.getTextObj();
944                            String contentType = largeImage.getType();
945    
946                            if (bytes != null) {
947                                    ImageBag imageBag = ImageToolUtil.read(bytes);
948    
949                                    renderedImage = imageBag.getRenderedImage();
950    
951                                    //validate(bytes);
952                            }
953    
954                            if (renderedImage != null) {
955                                    int height = PrefsPropsUtil.getInteger(
956                                            PropsKeys.DL_FILE_ENTRY_THUMBNAIL_MAX_HEIGHT);
957                                    int width = PrefsPropsUtil.getInteger(
958                                            PropsKeys.DL_FILE_ENTRY_THUMBNAIL_MAX_WIDTH);
959    
960                                    RenderedImage thumbnailRenderedImage =
961                                            ImageToolUtil.scale(renderedImage, height, width);
962    
963                                    imageLocalService.updateImage(
964                                            smallImageId,
965                                            ImageToolUtil.getBytes(
966                                                    thumbnailRenderedImage, contentType));
967                            }
968                    }
969                    catch (IOException ioe) {
970                            throw new ImageSizeException(ioe);
971                    }
972            }
973    
974            public DLFileEntry updateStatus(
975                            long userId, long fileVersionId, int status,
976                            Map<String, Serializable> workflowContext,
977                            ServiceContext serviceContext)
978                    throws PortalException, SystemException {
979    
980                    // File version
981    
982                    User user = userPersistence.findByPrimaryKey(userId);
983    
984                    DLFileVersion dlFileVersion = dlFileVersionPersistence.findByPrimaryKey(
985                            fileVersionId);
986    
987                    dlFileVersion.setStatus(status);
988                    dlFileVersion.setStatusByUserId(user.getUserId());
989                    dlFileVersion.setStatusByUserName(user.getFullName());
990                    dlFileVersion.setStatusDate(new Date());
991    
992                    dlFileVersionPersistence.update(dlFileVersion, false);
993    
994                    // File entry
995    
996                    DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
997                            dlFileVersion.getFileEntryId());
998    
999                    if (status == WorkflowConstants.STATUS_APPROVED) {
1000                            if (DLUtil.compareVersions(
1001                                            dlFileEntry.getVersion(),
1002                                            dlFileVersion.getVersion()) <= 0) {
1003    
1004                                    dlFileEntry.setExtension(dlFileVersion.getExtension());
1005                                    dlFileEntry.setTitle(dlFileVersion.getTitle());
1006                                    dlFileEntry.setDescription(dlFileVersion.getDescription());
1007                                    dlFileEntry.setExtraSettings(dlFileVersion.getExtraSettings());
1008                                    dlFileEntry.setFileEntryTypeId(
1009                                            dlFileVersion.getFileEntryTypeId());
1010                                    dlFileEntry.setVersion(dlFileVersion.getVersion());
1011                                    dlFileEntry.setVersionUserId(dlFileVersion.getUserId());
1012                                    dlFileEntry.setVersionUserName(dlFileVersion.getUserName());
1013                                    dlFileEntry.setModifiedDate(dlFileVersion.getCreateDate());
1014                                    dlFileEntry.setSize(dlFileVersion.getSize());
1015    
1016                                    dlFileEntryPersistence.update(dlFileEntry, false);
1017                            }
1018                    }
1019                    else {
1020    
1021                            // File entry
1022    
1023                            if (dlFileEntry.getVersion().equals(dlFileVersion.getVersion())) {
1024                                    String newVersion = DLFileEntryConstants.VERSION_DEFAULT;
1025    
1026                                    List<DLFileVersion> approvedFileVersions =
1027                                            dlFileVersionPersistence.findByF_S(
1028                                                    dlFileEntry.getFileEntryId(),
1029                                                    WorkflowConstants.STATUS_APPROVED);
1030    
1031                                    if (!approvedFileVersions.isEmpty()) {
1032                                            newVersion = approvedFileVersions.get(0).getVersion();
1033                                    }
1034    
1035                                    dlFileEntry.setVersion(newVersion);
1036    
1037                                    dlFileEntryPersistence.update(dlFileEntry, false);
1038                            }
1039    
1040                            // Indexer
1041    
1042                            if (dlFileVersion.getVersion().equals(
1043                                            DLFileEntryConstants.VERSION_DEFAULT)) {
1044    
1045                                    Indexer indexer = IndexerRegistryUtil.getIndexer(
1046                                            DLFileEntry.class);
1047    
1048                                    indexer.delete(dlFileEntry);
1049                            }
1050                    }
1051    
1052                    // App helper
1053    
1054                    dlAppHelperLocalService.updateStatus(
1055                            userId, new LiferayFileEntry(dlFileEntry),
1056                            new LiferayFileVersion(dlFileVersion), status, workflowContext);
1057    
1058                    // Indexer
1059    
1060                    if (status == WorkflowConstants.STATUS_APPROVED) {
1061                            reindex(dlFileEntry);
1062                    }
1063    
1064                    return dlFileEntry;
1065            }
1066    
1067            public boolean verifyFileEntryCheckOut(long fileEntryId, String lockUuid)
1068                    throws PortalException, SystemException {
1069    
1070                    if (verifyFileEntryLock(fileEntryId, lockUuid) &&
1071                            isFileEntryCheckedOut(fileEntryId)) {
1072    
1073                            return true;
1074                    }
1075                    else {
1076                            return false;
1077                    }
1078            }
1079    
1080            public boolean verifyFileEntryLock(long fileEntryId, String lockUuid)
1081                    throws PortalException, SystemException {
1082    
1083                    boolean lockVerified = false;
1084    
1085                    try {
1086                            Lock lock = lockLocalService.getLock(
1087                                    DLFileEntry.class.getName(), fileEntryId);
1088    
1089                            if (lock.getUuid().equals(lockUuid)) {
1090                                    lockVerified = true;
1091                            }
1092                    }
1093                    catch (PortalException pe) {
1094                            if ((pe instanceof ExpiredLockException) ||
1095                                    (pe instanceof NoSuchLockException)) {
1096    
1097                                    DLFileEntry dlFileEntry = dlFileEntryLocalService.getFileEntry(
1098                                            fileEntryId);
1099    
1100                                    lockVerified = dlFolderService.verifyInheritableLock(
1101                                            dlFileEntry.getFolderId(), lockUuid);
1102                            }
1103                            else {
1104                                    throw pe;
1105                            }
1106                    }
1107    
1108                    return lockVerified;
1109            }
1110    
1111            protected DLFileVersion addFileVersion(
1112                            User user, DLFileEntry dlFileEntry, Date modifiedDate,
1113                            String extension, String mimeType, String title, String description,
1114                            String changeLog, String extraSettings, long fileEntryTypeId,
1115                            Map<String, Fields> fieldsMap, String version, long size,
1116                            int status, ServiceContext serviceContext)
1117                    throws PortalException, SystemException {
1118    
1119                    long fileVersionId = counterLocalService.increment();
1120    
1121                    DLFileVersion dlFileVersion = dlFileVersionPersistence.create(
1122                            fileVersionId);
1123    
1124                    long versionUserId = dlFileEntry.getVersionUserId();
1125    
1126                    if (versionUserId <= 0) {
1127                            versionUserId = dlFileEntry.getUserId();
1128                    }
1129    
1130                    String versionUserName = GetterUtil.getString(
1131                            dlFileEntry.getVersionUserName(), dlFileEntry.getUserName());
1132    
1133                    dlFileVersion.setGroupId(dlFileEntry.getGroupId());
1134                    dlFileVersion.setCompanyId(dlFileEntry.getCompanyId());
1135                    dlFileVersion.setUserId(versionUserId);
1136                    dlFileVersion.setUserName(versionUserName);
1137                    dlFileVersion.setCreateDate(modifiedDate);
1138                    dlFileVersion.setModifiedDate(modifiedDate);
1139                    dlFileVersion.setRepositoryId(dlFileEntry.getRepositoryId());
1140                    dlFileVersion.setFolderId(dlFileEntry.getFolderId());
1141                    dlFileVersion.setFileEntryId(dlFileEntry.getFileEntryId());
1142                    dlFileVersion.setExtension(extension);
1143                    dlFileVersion.setMimeType(mimeType);
1144                    dlFileVersion.setTitle(title);
1145                    dlFileVersion.setDescription(description);
1146                    dlFileVersion.setChangeLog(changeLog);
1147                    dlFileVersion.setExtraSettings(extraSettings);
1148                    dlFileVersion.setFileEntryTypeId(fileEntryTypeId);
1149                    dlFileVersion.setVersion(version);
1150                    dlFileVersion.setSize(size);
1151                    dlFileVersion.setStatus(status);
1152                    dlFileVersion.setStatusByUserId(user.getUserId());
1153                    dlFileVersion.setStatusByUserName(user.getFullName());
1154                    dlFileVersion.setStatusDate(dlFileEntry.getModifiedDate());
1155                    dlFileVersion.setExpandoBridgeAttributes(serviceContext);
1156    
1157                    dlFileVersionPersistence.update(dlFileVersion, false);
1158    
1159                    if ((fileEntryTypeId > 0) && (fieldsMap != null)) {
1160                            dlFileEntryMetadataLocalService.updateFileEntryMetadata(
1161                                    fileEntryTypeId, dlFileEntry.getFileEntryId(), fileVersionId,
1162                                    fieldsMap, serviceContext);
1163                    }
1164    
1165                    return dlFileVersion;
1166            }
1167    
1168            protected void convertExtraSettings(
1169                            DLFileEntry dlFileEntry, DLFileVersion dlFileVersion, String[] keys)
1170                    throws PortalException, SystemException {
1171    
1172                    UnicodeProperties extraSettingsProperties =
1173                            dlFileVersion.getExtraSettingsProperties();
1174    
1175                    ExpandoBridge expandoBridge = dlFileVersion.getExpandoBridge();
1176    
1177                    convertExtraSettings(extraSettingsProperties, expandoBridge, keys);
1178    
1179                    dlFileVersion.setExtraSettingsProperties(extraSettingsProperties);
1180    
1181                    dlFileVersionPersistence.update(dlFileVersion, false);
1182    
1183                    int status = dlFileVersion.getStatus();
1184    
1185                    if ((status == WorkflowConstants.STATUS_APPROVED) &&
1186                            (DLUtil.compareVersions(
1187                                    dlFileEntry.getVersion(), dlFileVersion.getVersion()) <= 0)) {
1188    
1189                            reindex(dlFileEntry);
1190                    }
1191            }
1192    
1193            protected void convertExtraSettings(DLFileEntry dlFileEntry, String[] keys)
1194                    throws PortalException, SystemException {
1195    
1196                    UnicodeProperties extraSettingsProperties =
1197                            dlFileEntry.getExtraSettingsProperties();
1198    
1199                    ExpandoBridge expandoBridge = dlFileEntry.getExpandoBridge();
1200    
1201                    convertExtraSettings(extraSettingsProperties, expandoBridge, keys);
1202    
1203                    dlFileEntry.setExtraSettingsProperties(extraSettingsProperties);
1204    
1205                    dlFileEntryPersistence.update(dlFileEntry, false);
1206    
1207                    List<DLFileVersion> dlFileVersions =
1208                            dlFileVersionLocalService.getFileVersions(
1209                                    dlFileEntry.getFileEntryId(), WorkflowConstants.STATUS_ANY);
1210    
1211                    for (DLFileVersion dlFileVersion : dlFileVersions) {
1212                            convertExtraSettings(dlFileEntry, dlFileVersion, keys);
1213                    }
1214            }
1215    
1216            protected void convertExtraSettings(
1217                    UnicodeProperties extraSettingsProperties, ExpandoBridge expandoBridge,
1218                    String[] keys) {
1219    
1220                    for (String key : keys) {
1221                            String value = extraSettingsProperties.remove(key);
1222    
1223                            if (Validator.isNull(value)) {
1224                                    continue;
1225                            }
1226    
1227                            int type = expandoBridge.getAttributeType(key);
1228    
1229                            Serializable serializable = ExpandoColumnConstants.getSerializable(
1230                                    type, value);
1231    
1232                            expandoBridge.setAttribute(key, serializable);
1233                    }
1234            }
1235    
1236            protected void deleteFileEntry(DLFileEntry dlFileEntry)
1237                    throws PortalException, SystemException {
1238    
1239                    // File entry
1240    
1241                    dlFileEntryPersistence.remove(dlFileEntry);
1242    
1243                    // Resources
1244    
1245                    resourceLocalService.deleteResource(
1246                            dlFileEntry.getCompanyId(), DLFileEntry.class.getName(),
1247                            ResourceConstants.SCOPE_INDIVIDUAL, dlFileEntry.getFileEntryId());
1248    
1249                    // WebDAVProps
1250    
1251                    webDAVPropsLocalService.deleteWebDAVProps(
1252                            DLFileEntry.class.getName(), dlFileEntry.getFileEntryId());
1253    
1254                    // File entry metadata
1255    
1256                    dlFileEntryMetadataLocalService.deleteFileEntryMetadata(
1257                            dlFileEntry.getFileEntryId());
1258    
1259                    // File versions
1260    
1261                    List<DLFileVersion> dlFileVersions =
1262                            dlFileVersionPersistence.findByFileEntryId(
1263                                    dlFileEntry.getFileEntryId());
1264    
1265                    for (DLFileVersion dlFileVersion : dlFileVersions) {
1266                            dlFileVersionPersistence.remove(dlFileVersion);
1267    
1268                            expandoValueLocalService.deleteValues(
1269                                    DLFileVersion.class.getName(),
1270                                    dlFileVersion.getFileVersionId());
1271    
1272                            workflowInstanceLinkLocalService.deleteWorkflowInstanceLinks(
1273                                    dlFileEntry.getCompanyId(), dlFileEntry.getGroupId(),
1274                                    DLFileEntry.class.getName(), dlFileVersion.getFileVersionId());
1275                    }
1276    
1277                    // Expando
1278    
1279                    expandoValueLocalService.deleteValues(
1280                            DLFileEntry.class.getName(), dlFileEntry.getFileEntryId());
1281    
1282                    // Lock
1283    
1284                    lockLocalService.unlock(
1285                            DLFileEntry.class.getName(), dlFileEntry.getFileEntryId());
1286    
1287                    // File
1288    
1289                    try {
1290                            DLStoreUtil.deleteFile(
1291                                    dlFileEntry.getCompanyId(), dlFileEntry.getDataRepositoryId(),
1292                                    dlFileEntry.getName());
1293                    }
1294                    catch (Exception e) {
1295                            if (_log.isWarnEnabled()) {
1296                                    _log.warn(e, e);
1297                            }
1298                    }
1299    
1300                    // Index
1301    
1302                    Indexer indexer = IndexerRegistryUtil.getIndexer(DLFileEntry.class);
1303    
1304                    indexer.delete(dlFileEntry);
1305            }
1306    
1307            protected String getExtension(String title, String sourceFileName) {
1308                    if (Validator.isNull(sourceFileName)) {
1309                            sourceFileName = title;
1310                    }
1311    
1312                    return FileUtil.getExtension(sourceFileName);
1313            }
1314    
1315            protected Long getFileEntryTypeId(
1316                            long[] groupIds, long folderId, long fileEntryTypeId)
1317                    throws PortalException, SystemException {
1318    
1319                    if (fileEntryTypeId == -1) {
1320                            fileEntryTypeId =
1321                                    dlFileEntryTypeLocalService.getDefaultFileEntryTypeId(folderId);
1322                    }
1323                    else {
1324                            List<DLFileEntryType> dlFileEntryTypes =
1325                                    dlFileEntryTypeLocalService.getFolderFileEntryTypes(
1326                                            groupIds, folderId, true);
1327    
1328                            boolean found = false;
1329    
1330                            for (DLFileEntryType dlFileEntryType : dlFileEntryTypes) {
1331                                    if (dlFileEntryType.getFileEntryTypeId() == fileEntryTypeId) {
1332                                            found = true;
1333    
1334                                            break;
1335                                    }
1336                            }
1337    
1338                            if (!found) {
1339                                    throw new InvalidFileEntryTypeException(
1340                                            "Invalid file entry type " + fileEntryTypeId +
1341                                                    " for folder " + folderId);
1342                            }
1343                    }
1344    
1345                    return fileEntryTypeId;
1346            }
1347    
1348            protected String getNextVersion(
1349                            DLFileEntry dlFileEntry, boolean majorVersion, int workflowAction)
1350                    throws PortalException, SystemException {
1351    
1352                    String version = dlFileEntry.getVersion();
1353    
1354                    try {
1355                            DLFileVersion dlFileVersion =
1356                                    dlFileVersionLocalService.getLatestFileVersion(
1357                                            dlFileEntry.getFileEntryId(), true);
1358    
1359                            version = dlFileVersion.getVersion();
1360                    }
1361                    catch (NoSuchFileVersionException nsfve) {
1362                    }
1363    
1364                    if (workflowAction == WorkflowConstants.ACTION_SAVE_DRAFT) {
1365                            majorVersion = false;
1366                    }
1367    
1368                    int[] versionParts = StringUtil.split(version, StringPool.PERIOD, 0);
1369    
1370                    if (majorVersion) {
1371                            versionParts[0]++;
1372                            versionParts[1] = 0;
1373                    }
1374                    else {
1375                            versionParts[1]++;
1376                    }
1377    
1378                    return versionParts[0] + StringPool.PERIOD + versionParts[1];
1379            }
1380    
1381            protected DLFileEntry moveFileEntryImpl(
1382                            long userId, long fileEntryId, long newFolderId,
1383                            ServiceContext serviceContext)
1384                    throws PortalException, SystemException {
1385    
1386                    // File entry
1387    
1388                    User user = userPersistence.findByPrimaryKey(userId);
1389                    DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
1390                            fileEntryId);
1391    
1392                    long oldDataRepositoryId = dlFileEntry.getDataRepositoryId();
1393    
1394                    validateFile(
1395                            dlFileEntry.getGroupId(), newFolderId, dlFileEntry.getFileEntryId(),
1396                            dlFileEntry.getTitle());
1397    
1398                    if (DLStoreUtil.hasFile(
1399                                    user.getCompanyId(),
1400                                    DLFolderConstants.getDataRepositoryId(
1401                                            dlFileEntry.getGroupId(), newFolderId),
1402                                    dlFileEntry.getName(), StringPool.BLANK)) {
1403    
1404                            throw new DuplicateFileException(dlFileEntry.getName());
1405                    }
1406    
1407                    dlFileEntry.setFolderId(newFolderId);
1408    
1409                    dlFileEntryPersistence.update(dlFileEntry, false);
1410    
1411                    // File version
1412    
1413                    List<DLFileVersion> dlFileVersions =
1414                            dlFileVersionPersistence.findByFileEntryId(fileEntryId);
1415    
1416                    for (DLFileVersion dlFileVersion : dlFileVersions) {
1417                            dlFileVersion.setFolderId(newFolderId);
1418    
1419                            dlFileVersionPersistence.update(dlFileVersion, false);
1420                    }
1421    
1422                    // File
1423    
1424                    DLStoreUtil.updateFile(
1425                            user.getCompanyId(), oldDataRepositoryId,
1426                            dlFileEntry.getDataRepositoryId(), dlFileEntry.getName());
1427    
1428                    // Index
1429    
1430                    reindex(dlFileEntry);
1431    
1432                    return dlFileEntry;
1433            }
1434    
1435            protected void reindex(DLFileEntry dlFileEntry) throws SearchException {
1436                    Indexer indexer = IndexerRegistryUtil.getIndexer(DLFileEntry.class);
1437    
1438                    indexer.reindex(dlFileEntry);
1439            }
1440    
1441            protected void startWorkflowInstance(
1442                            long userId, ServiceContext serviceContext,
1443                            DLFileVersion dlFileVersion, String syncEventType)
1444                    throws PortalException, SystemException {
1445    
1446                    Map<String, Serializable> workflowContext =
1447                            new HashMap<String, Serializable>();
1448    
1449                    workflowContext.put("event", syncEventType);
1450    
1451                    WorkflowHandlerRegistryUtil.startWorkflowInstance(
1452                            dlFileVersion.getCompanyId(), dlFileVersion.getGroupId(),
1453                            userId, DLFileEntry.class.getName(),
1454                            dlFileVersion.getFileVersionId(), dlFileVersion, serviceContext,
1455                            workflowContext);
1456            }
1457    
1458            protected DLFileEntry updateFileEntry(
1459                            long userId, long fileEntryId, String sourceFileName,
1460                            String extension, String mimeType, String title, String description,
1461                            String changeLog, boolean majorVersion, String extraSettings,
1462                            long fileEntryTypeId, Map<String, Fields> fieldsMap, File file,
1463                            InputStream is, long size, ServiceContext serviceContext)
1464                    throws PortalException, SystemException {
1465    
1466                    User user = userPersistence.findByPrimaryKey(userId);
1467                    DLFileEntry dlFileEntry = dlFileEntryPersistence.findByPrimaryKey(
1468                            fileEntryId);
1469    
1470                    boolean checkedOut = dlFileEntry.isCheckedOut();
1471    
1472                    DLFileVersion dlFileVersion =
1473                            dlFileVersionLocalService.getLatestFileVersion(
1474                                    fileEntryId, !checkedOut);
1475    
1476                    boolean autoCheckIn = !checkedOut && dlFileVersion.isApproved();
1477    
1478                    if (autoCheckIn) {
1479                            dlFileEntry = checkOutFileEntry(userId, fileEntryId);
1480                    }
1481                    else if (!checkedOut) {
1482                            lockFileEntry(userId, fileEntryId);
1483                    }
1484    
1485                    if (!hasFileEntryLock(userId, fileEntryId)) {
1486                            lockFileEntry(userId, fileEntryId);
1487                    }
1488    
1489                    if (checkedOut || autoCheckIn) {
1490                            dlFileVersion = dlFileVersionLocalService.getLatestFileVersion(
1491                                    fileEntryId, false);
1492                    }
1493    
1494                    try {
1495                            if (Validator.isNull(extension)) {
1496                                    extension = dlFileEntry.getExtension();
1497                            }
1498    
1499                            if (Validator.isNull(mimeType)) {
1500                                    mimeType = dlFileEntry.getMimeType();
1501                            }
1502    
1503                            if (Validator.isNull(title)) {
1504                                    title = sourceFileName;
1505    
1506                                    if (Validator.isNull(title)) {
1507                                            title = dlFileEntry.getTitle();
1508                                    }
1509                            }
1510    
1511                            Date now = new Date();
1512    
1513                            validateFile(
1514                                    dlFileEntry.getGroupId(), dlFileEntry.getFolderId(),
1515                                    dlFileEntry.getFileEntryId(), extension, title, sourceFileName,
1516                                    file, is);
1517    
1518                            // File version
1519    
1520                            String version = dlFileVersion.getVersion();
1521    
1522                            if (size == 0) {
1523                                    size = dlFileVersion.getSize();
1524                            }
1525    
1526                            updateFileVersion(
1527                                    user, dlFileVersion, sourceFileName, extension, mimeType, title,
1528                                    description, changeLog, extraSettings, fileEntryTypeId,
1529                                    fieldsMap, version, size, dlFileVersion.getStatus(),
1530                                    serviceContext.getModifiedDate(now), serviceContext);
1531    
1532                            // App helper
1533    
1534                            dlAppHelperLocalService.updateAsset(
1535                                    userId, new LiferayFileEntry(dlFileEntry),
1536                                    new LiferayFileVersion(dlFileVersion),
1537                                    serviceContext.getAssetCategoryIds(),
1538                                    serviceContext.getAssetTagNames(),
1539                                    serviceContext.getAssetLinkEntryIds());
1540    
1541                            // File
1542    
1543                            if ((file != null) || (is != null)) {
1544                                    try {
1545                                            DLStoreUtil.deleteFile(
1546                                                    user.getCompanyId(), dlFileEntry.getDataRepositoryId(),
1547                                                    dlFileEntry.getName(), version);
1548                                    }
1549                                    catch (NoSuchFileException nsfe) {
1550                                    }
1551    
1552                                    if (file != null) {
1553                                            DLStoreUtil.updateFile(
1554                                                    user.getCompanyId(), dlFileEntry.getDataRepositoryId(),
1555                                                    dlFileEntry.getName(), dlFileEntry.getExtension(),
1556                                                    false, version, sourceFileName, file);
1557                                    }
1558                                    else {
1559                                            DLStoreUtil.updateFile(
1560                                                    user.getCompanyId(), dlFileEntry.getDataRepositoryId(),
1561                                                    dlFileEntry.getName(), dlFileEntry.getExtension(),
1562                                                    false, version, sourceFileName, is);
1563                                    }
1564                            }
1565    
1566                            if (autoCheckIn) {
1567                                    checkInFileEntry(
1568                                            userId, fileEntryId, majorVersion, changeLog,
1569                                            serviceContext);
1570                            }
1571                            else if (serviceContext.getWorkflowAction() ==
1572                                                    WorkflowConstants.ACTION_PUBLISH) {
1573    
1574                                    String syncEvent = DLSyncConstants.EVENT_UPDATE;
1575    
1576                                    if (dlFileVersion.getVersion().equals(
1577                                                    DLFileEntryConstants.VERSION_DEFAULT)) {
1578    
1579                                            syncEvent = DLSyncConstants.EVENT_ADD;
1580                                    }
1581    
1582                                    startWorkflowInstance(
1583                                            userId, serviceContext, dlFileVersion, syncEvent);
1584                            }
1585                    }
1586                    catch (PortalException pe) {
1587                            if (autoCheckIn) {
1588                                    cancelCheckOut(userId, fileEntryId);
1589                            }
1590    
1591                            throw pe;
1592                    }
1593                    catch (SystemException se) {
1594                            if (autoCheckIn) {
1595                                    cancelCheckOut(userId, fileEntryId);
1596                            }
1597    
1598                            throw se;
1599                    }
1600                    finally {
1601                            if (!autoCheckIn && !checkedOut) {
1602                                    unlockFileEntry(fileEntryId);
1603                            }
1604                    }
1605    
1606                    return dlFileEntryPersistence.findByPrimaryKey(fileEntryId);
1607            }
1608    
1609            protected void updateFileVersion(
1610                            User user, DLFileVersion dlFileVersion, String sourceFileName,
1611                            String extension, String mimeType, String title, String description,
1612                            String changeLog, String extraSettings, long fileEntryTypeId,
1613                            Map<String, Fields> fieldsMap, String version, long size,
1614                            int status, Date statusDate, ServiceContext serviceContext)
1615                    throws PortalException, SystemException {
1616    
1617                    dlFileVersion.setModifiedDate(statusDate);
1618    
1619                    if (Validator.isNotNull(sourceFileName)) {
1620                            dlFileVersion.setExtension(extension);
1621                            dlFileVersion.setMimeType(mimeType);
1622                    }
1623    
1624                    dlFileVersion.setTitle(title);
1625                    dlFileVersion.setDescription(description);
1626                    dlFileVersion.setChangeLog(changeLog);
1627                    dlFileVersion.setExtraSettings(extraSettings);
1628                    dlFileVersion.setFileEntryTypeId(fileEntryTypeId);
1629                    dlFileVersion.setVersion(version);
1630                    dlFileVersion.setSize(size);
1631                    dlFileVersion.setStatus(status);
1632                    dlFileVersion.setStatusByUserId(user.getUserId());
1633                    dlFileVersion.setStatusByUserName(user.getFullName());
1634                    dlFileVersion.setStatusDate(statusDate);
1635                    dlFileVersion.setExpandoBridgeAttributes(serviceContext);
1636    
1637                    dlFileVersionPersistence.update(dlFileVersion, false);
1638    
1639                    if ((fileEntryTypeId > 0) && (fieldsMap != null)) {
1640                            dlFileEntryMetadataLocalService.updateFileEntryMetadata(
1641                                    fileEntryTypeId, dlFileVersion.getFileEntryId(),
1642                                    dlFileVersion.getFileVersionId(), fieldsMap,
1643                                    serviceContext);
1644                    }
1645            }
1646    
1647            protected void validateFile(
1648                            long groupId, long folderId, long fileEntryId, String title)
1649                    throws PortalException, SystemException {
1650    
1651                    DLFolder dlFolder = dlFolderPersistence.fetchByG_P_N(
1652                            groupId, folderId, title);
1653    
1654                    if (dlFolder != null) {
1655                            throw new DuplicateFolderNameException(title);
1656                    }
1657    
1658                    DLFileEntry dlFileEntry = dlFileEntryPersistence.fetchByG_F_T(
1659                            groupId, folderId, title);
1660    
1661                    if ((dlFileEntry != null) &&
1662                            (dlFileEntry.getFileEntryId() != fileEntryId)) {
1663    
1664                            throw new DuplicateFileException(title);
1665                    }
1666            }
1667    
1668            protected void validateFile(
1669                            long groupId, long folderId, long fileEntryId, String extension,
1670                            String title, String sourceFileName, File file, InputStream is)
1671                    throws PortalException, SystemException {
1672    
1673                    if (Validator.isNotNull(sourceFileName)) {
1674                            if (file != null) {
1675                                    DLStoreUtil.validate(
1676                                            sourceFileName, extension, sourceFileName, true, file);
1677                            }
1678                            else {
1679                                    DLStoreUtil.validate(
1680                                            sourceFileName, extension, sourceFileName, true, is);
1681                            }
1682                    }
1683    
1684                    validateFileName(title);
1685    
1686                    DLStoreUtil.validate(title, false);
1687    
1688                    validateFile(groupId, folderId, fileEntryId, title);
1689            }
1690    
1691            protected void validateFile(
1692                            long groupId, long folderId, String title, String extension,
1693                            File file, InputStream is)
1694                    throws PortalException, SystemException {
1695    
1696                    String fileName = title + StringPool.PERIOD + extension;
1697    
1698                    validateFileName(fileName);
1699    
1700                    if (file != null) {
1701                            DLStoreUtil.validate(fileName, true, file);
1702                    }
1703                    else {
1704                            DLStoreUtil.validate(fileName, true, is);
1705                    }
1706    
1707                    validateFile(groupId, folderId, 0, title);
1708            }
1709    
1710            protected void validateFileName(String fileName) throws PortalException {
1711                    if (fileName.contains(StringPool.SLASH)) {
1712                            throw new FileNameException(fileName);
1713                    }
1714            }
1715    
1716            private static final int _DELETE_INTERVAL = 100;
1717    
1718            private static Log _log = LogFactoryUtil.getLog(
1719                    DLFileEntryLocalServiceImpl.class);
1720    
1721    }