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