001    /**
002     * Copyright (c) 2000-2010 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.documentlibrary.DuplicateFileException;
018    import com.liferay.documentlibrary.FileSizeException;
019    import com.liferay.documentlibrary.NoSuchFileException;
020    import com.liferay.documentlibrary.util.JCRHook;
021    import com.liferay.portal.kernel.exception.PortalException;
022    import com.liferay.portal.kernel.exception.SystemException;
023    import com.liferay.portal.kernel.io.unsync.UnsyncBufferedInputStream;
024    import com.liferay.portal.kernel.io.unsync.UnsyncByteArrayInputStream;
025    import com.liferay.portal.kernel.log.Log;
026    import com.liferay.portal.kernel.log.LogFactoryUtil;
027    import com.liferay.portal.kernel.search.Indexer;
028    import com.liferay.portal.kernel.search.IndexerRegistryUtil;
029    import com.liferay.portal.kernel.util.FileUtil;
030    import com.liferay.portal.kernel.util.GetterUtil;
031    import com.liferay.portal.kernel.util.MimeTypesUtil;
032    import com.liferay.portal.kernel.util.OrderByComparator;
033    import com.liferay.portal.kernel.util.StringPool;
034    import com.liferay.portal.kernel.util.StringUtil;
035    import com.liferay.portal.kernel.util.Validator;
036    import com.liferay.portal.kernel.workflow.WorkflowConstants;
037    import com.liferay.portal.kernel.workflow.WorkflowHandlerRegistryUtil;
038    import com.liferay.portal.model.ResourceConstants;
039    import com.liferay.portal.model.User;
040    import com.liferay.portal.service.ServiceContext;
041    import com.liferay.portal.util.PortalUtil;
042    import com.liferay.portal.util.PortletKeys;
043    import com.liferay.portal.util.PropsValues;
044    import com.liferay.portlet.asset.NoSuchEntryException;
045    import com.liferay.portlet.asset.model.AssetEntry;
046    import com.liferay.portlet.documentlibrary.DuplicateFolderNameException;
047    import com.liferay.portlet.documentlibrary.NoSuchFileEntryException;
048    import com.liferay.portlet.documentlibrary.NoSuchFileVersionException;
049    import com.liferay.portlet.documentlibrary.NoSuchFolderException;
050    import com.liferay.portlet.documentlibrary.model.DLFileEntry;
051    import com.liferay.portlet.documentlibrary.model.DLFileEntryConstants;
052    import com.liferay.portlet.documentlibrary.model.DLFileShortcut;
053    import com.liferay.portlet.documentlibrary.model.DLFileVersion;
054    import com.liferay.portlet.documentlibrary.model.DLFolder;
055    import com.liferay.portlet.documentlibrary.model.DLFolderConstants;
056    import com.liferay.portlet.documentlibrary.model.impl.DLFileEntryImpl;
057    import com.liferay.portlet.documentlibrary.service.base.DLFileEntryLocalServiceBaseImpl;
058    import com.liferay.portlet.documentlibrary.social.DLActivityKeys;
059    import com.liferay.portlet.documentlibrary.util.DLUtil;
060    import com.liferay.portlet.documentlibrary.util.comparator.FileEntryModifiedDateComparator;
061    import com.liferay.portlet.messageboards.model.MBDiscussion;
062    import com.liferay.portlet.ratings.model.RatingsEntry;
063    import com.liferay.portlet.ratings.model.RatingsStats;
064    
065    import java.io.File;
066    import java.io.FileInputStream;
067    import java.io.FileNotFoundException;
068    import java.io.InputStream;
069    
070    import java.util.Date;
071    import java.util.List;
072    
073    /**
074     * <p>
075     * For DLFileEntries, the naming convention for some of the variables is not
076     * very informative, due to legacy code. Each DLFileEntry has a corresponding
077     * name and title. The "name" is a unique identifier for a given file and
078     * usually follows the format "1234" whereas the "title" is the actual name
079     * specified by the user (e.g., "Budget.xls").
080     * </p>
081     *
082     * @author Brian Wing Shun Chan
083     * @author Harry Mark
084     */
085    public class DLFileEntryLocalServiceImpl
086            extends DLFileEntryLocalServiceBaseImpl {
087    
088            public DLFileEntry addFileEntry(
089                            long userId, long groupId, long folderId, String name, String title,
090                            String description, String changeLog, String extraSettings,
091                            byte[] bytes, ServiceContext serviceContext)
092                    throws PortalException, SystemException {
093    
094                    if (bytes == null) {
095                            throw new FileSizeException();
096                    }
097    
098                    InputStream is = new UnsyncByteArrayInputStream(bytes);
099    
100                    return addFileEntry(
101                            userId, groupId, folderId, name, title, description,
102                            changeLog, extraSettings, is, bytes.length, serviceContext);
103            }
104    
105            public DLFileEntry addFileEntry(
106                            long userId, long groupId, long folderId, String name, String title,
107                            String description, String changeLog, String extraSettings,
108                            File file, ServiceContext serviceContext)
109                    throws PortalException, SystemException {
110    
111                    if (file == null) {
112                            throw new FileSizeException();
113                    }
114    
115                    try {
116                            InputStream is = new UnsyncBufferedInputStream(
117                                    new FileInputStream(file));
118    
119                            return addFileEntry(
120                                    userId, groupId, folderId, name, title, description,
121                                    changeLog, extraSettings, is, file.length(), serviceContext);
122                    }
123                    catch (FileNotFoundException fnfe) {
124                            throw new FileSizeException();
125                    }
126            }
127    
128            public DLFileEntry addFileEntry(
129                            long userId, long groupId, long folderId, String name, String title,
130                            String description, String changeLog, String extraSettings,
131                            InputStream is, long size, ServiceContext serviceContext)
132                    throws PortalException, SystemException {
133    
134                    // File entry
135    
136                    User user = userPersistence.findByPrimaryKey(userId);
137                    folderId = getFolderId(user.getCompanyId(), folderId);
138    
139                    String extension = FileUtil.getExtension(name);
140    
141                    if (Validator.isNull(title)) {
142                            title = name;
143                    }
144    
145                    name = String.valueOf(
146                            counterLocalService.increment(DLFileEntry.class.getName()));
147    
148                    Date now = new Date();
149    
150                    validate(groupId, folderId, title, is);
151    
152                    long fileEntryId = counterLocalService.increment();
153    
154                    DLFileEntry fileEntry = dlFileEntryPersistence.create(fileEntryId);
155    
156                    fileEntry.setUuid(serviceContext.getUuid());
157                    fileEntry.setGroupId(groupId);
158                    fileEntry.setCompanyId(user.getCompanyId());
159                    fileEntry.setUserId(user.getUserId());
160                    fileEntry.setUserName(user.getFullName());
161                    fileEntry.setVersionUserId(user.getUserId());
162                    fileEntry.setVersionUserName(user.getFullName());
163                    fileEntry.setCreateDate(serviceContext.getCreateDate(now));
164                    fileEntry.setModifiedDate(serviceContext.getModifiedDate(now));
165                    fileEntry.setFolderId(folderId);
166                    fileEntry.setName(name);
167                    fileEntry.setExtension(extension);
168                    fileEntry.setTitle(title);
169                    fileEntry.setDescription(description);
170                    fileEntry.setExtraSettings(extraSettings);
171                    fileEntry.setVersion(DLFileEntryConstants.DEFAULT_VERSION);
172                    fileEntry.setSize(size);
173                    fileEntry.setReadCount(DLFileEntryConstants.DEFAULT_READ_COUNT);
174    
175                    dlFileEntryPersistence.update(fileEntry, false);
176    
177                    // Resources
178    
179                    if (serviceContext.getAddCommunityPermissions() ||
180                            serviceContext.getAddGuestPermissions()) {
181    
182                            addFileEntryResources(
183                                    fileEntry, serviceContext.getAddCommunityPermissions(),
184                                    serviceContext.getAddGuestPermissions());
185                    }
186                    else {
187                            addFileEntryResources(
188                                    fileEntry, serviceContext.getCommunityPermissions(),
189                                    serviceContext.getGuestPermissions());
190                    }
191    
192                    // File version
193    
194                    DLFileVersion fileVersion = addFileVersion(
195                            user, fileEntry, serviceContext.getModifiedDate(now),
196                            extension, title, description, null, extraSettings,
197                            DLFileEntryConstants.DEFAULT_VERSION, size,
198                            WorkflowConstants.STATUS_DRAFT, serviceContext);
199    
200                    // Folder
201    
202                    if (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
203                            DLFolder folder = dlFolderPersistence.findByPrimaryKey(folderId);
204    
205                            folder.setLastPostDate(fileEntry.getModifiedDate());
206    
207                            dlFolderPersistence.update(folder, false);
208                    }
209    
210                    // Asset
211    
212                    updateAsset(
213                            userId, fileEntry, fileVersion,
214                            serviceContext.getAssetCategoryIds(),
215                            serviceContext.getAssetTagNames());
216    
217                    // Message boards
218    
219                    if (PropsValues.DL_FILE_ENTRY_COMMENTS_ENABLED) {
220                            mbMessageLocalService.addDiscussionMessage(
221                                    userId, fileEntry.getUserName(), groupId,
222                                    DLFileEntry.class.getName(), fileEntryId,
223                                    WorkflowConstants.ACTION_PUBLISH);
224                    }
225    
226                    // File
227    
228                    dlLocalService.addFile(
229                            user.getCompanyId(), PortletKeys.DOCUMENT_LIBRARY,
230                            fileEntry.getGroupId(), fileEntry.getRepositoryId(), name, false,
231                            fileEntryId, fileEntry.getLuceneProperties(),
232                            fileEntry.getModifiedDate(), serviceContext, is);
233    
234                    // Workflow
235    
236                    WorkflowHandlerRegistryUtil.startWorkflowInstance(
237                            user.getCompanyId(), groupId, userId, DLFileEntry.class.getName(),
238                            fileEntryId, fileEntry, serviceContext);
239    
240                    return fileEntry;
241            }
242    
243            public void addFileEntryResources(
244                            DLFileEntry fileEntry, boolean addCommunityPermissions,
245                            boolean addGuestPermissions)
246                    throws PortalException, SystemException {
247    
248                    resourceLocalService.addResources(
249                            fileEntry.getCompanyId(), fileEntry.getGroupId(),
250                            fileEntry.getUserId(), DLFileEntry.class.getName(),
251                            fileEntry.getFileEntryId(), false, addCommunityPermissions,
252                            addGuestPermissions);
253            }
254    
255            public void addFileEntryResources(
256                            DLFileEntry fileEntry, String[] communityPermissions,
257                            String[] guestPermissions)
258                    throws PortalException, SystemException {
259    
260                    resourceLocalService.addModelResources(
261                            fileEntry.getCompanyId(), fileEntry.getGroupId(),
262                            fileEntry.getUserId(), DLFileEntry.class.getName(),
263                            fileEntry.getFileEntryId(), communityPermissions, guestPermissions);
264            }
265    
266            public void addFileEntryResources(
267                            long fileEntryId, boolean addCommunityPermissions,
268                            boolean addGuestPermissions)
269                    throws PortalException, SystemException {
270    
271                    DLFileEntry fileEntry = dlFileEntryPersistence.findByPrimaryKey(
272                            fileEntryId);
273    
274                    addFileEntryResources(
275                            fileEntry, addCommunityPermissions, addGuestPermissions);
276            }
277    
278            public void addFileEntryResources(
279                            long fileEntryId, String[] communityPermissions,
280                            String[] guestPermissions)
281                    throws PortalException, SystemException {
282    
283                    DLFileEntry fileEntry = dlFileEntryPersistence.findByPrimaryKey(
284                            fileEntryId);
285    
286                    addFileEntryResources(
287                            fileEntry, communityPermissions, guestPermissions);
288            }
289    
290            public DLFileEntry addOrOverwriteFileEntry(
291                            long userId, long groupId, long folderId, String name,
292                            String sourceName, String title, String description,
293                            String changeLog, String extraSettings, File file,
294                            ServiceContext serviceContext)
295                    throws PortalException, SystemException {
296    
297                    try {
298                            dlFileEntryPersistence.findByG_F_T(groupId, folderId, title);
299    
300                            return updateFileEntry(
301                                    userId, groupId, folderId, name, sourceName, title, description,
302                                    changeLog, false, extraSettings, file, serviceContext);
303                    }
304                    catch (NoSuchFileEntryException nsfee) {
305                            return addFileEntry(
306                                    userId, groupId, folderId, name, title, description, changeLog,
307                                    extraSettings, file, serviceContext);
308                    }
309            }
310    
311            public void deleteFileEntries(long groupId, long folderId)
312                    throws PortalException, SystemException {
313    
314                    List<DLFileEntry> fileEntries = dlFileEntryPersistence.findByG_F(
315                            groupId, folderId);
316    
317                    for (DLFileEntry fileEntry : fileEntries) {
318                            deleteFileEntry(fileEntry);
319                    }
320            }
321    
322            public void deleteFileEntry(DLFileEntry fileEntry)
323                    throws PortalException, SystemException {
324    
325                    // File entry
326    
327                    dlFileEntryPersistence.remove(fileEntry);
328    
329                    // Resources
330    
331                    resourceLocalService.deleteResource(
332                            fileEntry.getCompanyId(), DLFileEntry.class.getName(),
333                            ResourceConstants.SCOPE_INDIVIDUAL, fileEntry.getFileEntryId());
334    
335                    // WebDAVProps
336    
337                    webDAVPropsLocalService.deleteWebDAVProps(
338                            DLFileEntry.class.getName(), fileEntry.getFileEntryId());
339    
340                    // Workflow
341    
342                    workflowInstanceLinkLocalService.deleteWorkflowInstanceLinks(
343                            fileEntry.getCompanyId(), fileEntry.getGroupId(),
344                            DLFileEntry.class.getName(), fileEntry.getFileEntryId());
345    
346                    // File ranks
347    
348                    dlFileRankLocalService.deleteFileRanks(
349                            fileEntry.getFolderId(), fileEntry.getName());
350    
351                    // File shortcuts
352    
353                    dlFileShortcutLocalService.deleteFileShortcuts(
354                            fileEntry.getGroupId(), fileEntry.getFolderId(),
355                            fileEntry.getName());
356    
357                    // File versions
358    
359                    List<DLFileVersion> fileVersions = dlFileVersionPersistence.findByG_F_N(
360                            fileEntry.getGroupId(), fileEntry.getFolderId(),
361                            fileEntry.getName());
362    
363                    for (DLFileVersion fileVersion : fileVersions) {
364                            dlFileVersionPersistence.remove(fileVersion);
365                    }
366    
367                    // Asset
368    
369                    assetEntryLocalService.deleteEntry(
370                            DLFileEntry.class.getName(), fileEntry.getFileEntryId());
371    
372                    // Expando
373    
374                    expandoValueLocalService.deleteValues(
375                            DLFileEntry.class.getName(), fileEntry.getFileEntryId());
376    
377                    // Lock
378    
379                    String lockId = DLUtil.getLockId(
380                            fileEntry.getGroupId(), fileEntry.getFolderId(),
381                            fileEntry.getName());
382    
383                    lockLocalService.unlock(DLFileEntry.class.getName(), lockId);
384    
385                    // Message boards
386    
387                    mbMessageLocalService.deleteDiscussionMessages(
388                            DLFileEntry.class.getName(), fileEntry.getFileEntryId());
389    
390                    // Ratings
391    
392                    ratingsStatsLocalService.deleteStats(
393                            DLFileEntry.class.getName(), fileEntry.getFileEntryId());
394    
395                    // Social
396    
397                    socialActivityLocalService.deleteActivities(
398                            DLFileEntry.class.getName(), fileEntry.getFileEntryId());
399    
400                    // File
401    
402                    try {
403                            dlService.deleteFile(
404                                    fileEntry.getCompanyId(), PortletKeys.DOCUMENT_LIBRARY,
405                                    fileEntry.getRepositoryId(), fileEntry.getName());
406                    }
407                    catch (Exception e) {
408                            if (_log.isWarnEnabled()) {
409                                    _log.warn(e, e);
410                            }
411                    }
412            }
413    
414            public void deleteFileEntry(long groupId, long folderId, String name)
415                    throws PortalException, SystemException {
416    
417                    deleteFileEntry(groupId, folderId, name, null);
418            }
419    
420            public void deleteFileEntry(
421                            long groupId, long folderId, String name, String version)
422                    throws PortalException, SystemException {
423    
424                    DLFileEntry fileEntry = dlFileEntryPersistence.findByG_F_N(
425                            groupId, folderId, name);
426    
427                    if (Validator.isNotNull(version)) {
428                            try {
429                                    dlService.deleteFile(
430                                            fileEntry.getCompanyId(), PortletKeys.DOCUMENT_LIBRARY,
431                                            fileEntry.getRepositoryId(), fileEntry.getName(), version);
432                            }
433                            catch (Exception e) {
434                                    if (_log.isWarnEnabled()) {
435                                            _log.warn(e, e);
436                                    }
437                            }
438    
439                            long fileVersionsCount = dlFileVersionPersistence.countByG_F_N(
440                                    groupId, folderId, name);
441    
442                            dlFileVersionPersistence.removeByG_F_N_V(
443                                    groupId, folderId, name, version);
444    
445                            if (fileVersionsCount == 1) {
446                                    dlFileEntryPersistence.remove(fileEntry);
447                            }
448                            else {
449                                    if (version.equals(fileEntry.getVersion())) {
450                                            try {
451                                                    DLFileVersion fileVersion =
452                                                            dlFileVersionLocalService.getLatestFileVersion(
453                                                                    groupId, folderId, name);
454    
455                                                    fileEntry.setVersion(fileVersion.getVersion());
456                                                    fileEntry.setSize(fileVersion.getSize());
457                                            }
458                                            catch (NoSuchFileVersionException nsfve) {
459                                            }
460                                    }
461    
462                                    dlFileEntryPersistence.update(fileEntry, false);
463                            }
464                    }
465                    else {
466                            deleteFileEntry(fileEntry);
467                    }
468            }
469    
470            public List<DLFileEntry> getCompanyFileEntries(
471                            long companyId, int start, int end)
472                    throws SystemException {
473    
474                    return dlFileEntryPersistence.findByCompanyId(companyId, start, end);
475            }
476    
477            public List<DLFileEntry> getCompanyFileEntries(
478                            long companyId, int start, int end, OrderByComparator obc)
479                    throws SystemException {
480    
481                    return dlFileEntryPersistence.findByCompanyId(
482                            companyId, start, end, obc);
483            }
484    
485            public int getCompanyFileEntriesCount(long companyId)
486                    throws SystemException {
487    
488                    return dlFileEntryPersistence.countByCompanyId(companyId);
489            }
490    
491            public InputStream getFileAsStream(
492                            long companyId, long userId, long groupId, long folderId,
493                            String name)
494                    throws PortalException, SystemException {
495    
496                    return getFileAsStream(
497                            companyId, userId, groupId, folderId, name, StringPool.BLANK);
498            }
499    
500            public InputStream getFileAsStream(
501                            long companyId, long userId, long groupId, long folderId,
502                            String name, String version)
503                    throws PortalException, SystemException {
504    
505                    DLFileEntry fileEntry = dlFileEntryPersistence.findByG_F_N(
506                            groupId, folderId, name);
507    
508                    if (userId > 0) {
509                            dlFileRankLocalService.updateFileRank(
510                                    groupId, companyId, userId, folderId, name,
511                                    new ServiceContext());
512                    }
513    
514                    if (PropsValues.DL_FILE_ENTRY_READ_COUNT_ENABLED) {
515                            fileEntry.setReadCount(fileEntry.getReadCount() + 1);
516    
517                            dlFileEntryPersistence.update(fileEntry, false);
518    
519                            assetEntryLocalService.incrementViewCounter(
520                                    userId, DLFileEntry.class.getName(),
521                                    fileEntry.getFileEntryId());
522    
523                            List<DLFileShortcut> fileShortcuts =
524                                    dlFileShortcutPersistence.findByG_TF_TN(
525                                            groupId, folderId, name);
526    
527                            for (DLFileShortcut fileShortcut : fileShortcuts) {
528                                    assetEntryLocalService.incrementViewCounter(
529                                            userId, DLFileShortcut.class.getName(),
530                                            fileShortcut.getFileShortcutId());
531                            }
532                    }
533    
534                    if (Validator.isNotNull(version)) {
535                            return dlLocalService.getFileAsStream(
536                                    companyId, fileEntry.getRepositoryId(), name, version);
537                    }
538                    else {
539                            return dlLocalService.getFileAsStream(
540                                    companyId, fileEntry.getRepositoryId(), name,
541                                    fileEntry.getVersion());
542                    }
543            }
544    
545            public List<DLFileEntry> getFileEntries(long groupId, long folderId)
546                    throws SystemException {
547    
548                    return dlFileEntryPersistence.findByG_F(groupId, folderId);
549            }
550    
551            public List<DLFileEntry> getFileEntries(
552                            long groupId, long folderId, int start, int end)
553                    throws SystemException {
554    
555                    return dlFileEntryPersistence.findByG_F(groupId, folderId, start, end);
556            }
557    
558            public List<DLFileEntry> getFileEntries(
559                            long groupId, long folderId, int start, int end,
560                            OrderByComparator obc)
561                    throws SystemException {
562    
563                    return dlFileEntryPersistence.findByG_F(
564                            groupId, folderId, start, end, obc);
565            }
566    
567            public int getFileEntriesCount(long groupId, long folderId)
568                    throws SystemException {
569    
570                    return dlFileEntryPersistence.countByG_F(groupId, folderId);
571            }
572    
573            public DLFileEntry getFileEntry(long fileEntryId)
574                    throws PortalException, SystemException {
575    
576                    return dlFileEntryPersistence.findByPrimaryKey(fileEntryId);
577            }
578    
579            public DLFileEntry getFileEntry(long groupId, long folderId, String name)
580                    throws PortalException, SystemException {
581    
582                    return dlFileEntryPersistence.findByG_F_N(groupId, folderId, name);
583            }
584    
585            public DLFileEntry getFileEntryByTitle(
586                            long groupId, long folderId, String title)
587                    throws PortalException, SystemException {
588    
589                    return dlFileEntryPersistence.findByG_F_T(groupId, folderId, title);
590            }
591    
592            public DLFileEntry getFileEntryByUuidAndGroupId(String uuid, long groupId)
593                    throws PortalException, SystemException {
594    
595                    return dlFileEntryPersistence.findByUUID_G(uuid, groupId);
596            }
597    
598            public int getFoldersFileEntriesCount(
599                            long groupId, List<Long> folderIds, int status)
600                    throws SystemException {
601    
602                    if (folderIds.size() <= PropsValues.SQL_DATA_MAX_PARAMETERS) {
603                            return dlFileEntryFinder.countByG_F_S(groupId, folderIds, status);
604                    }
605                    else {
606                            int start = 0;
607                            int end = PropsValues.SQL_DATA_MAX_PARAMETERS;
608    
609                            int filesCount = dlFileEntryFinder.countByG_F_S(
610                                    groupId, folderIds.subList(start, end), status);
611    
612                            folderIds.subList(start, end).clear();
613    
614                            filesCount += getFoldersFileEntriesCount(
615                                    groupId, folderIds, status);
616    
617                            return filesCount;
618                    }
619            }
620    
621            public List<DLFileEntry> getGroupFileEntries(
622                            long groupId, int start, int end)
623                    throws SystemException {
624    
625                    return getGroupFileEntries(
626                            groupId, start, end, new FileEntryModifiedDateComparator());
627            }
628    
629            public List<DLFileEntry> getGroupFileEntries(
630                            long groupId, int start, int end, OrderByComparator obc)
631                    throws SystemException {
632    
633                    return dlFileEntryPersistence.findByGroupId(groupId, start, end, obc);
634            }
635    
636            public List<DLFileEntry> getGroupFileEntries(
637                            long groupId, long userId, int start, int end)
638                    throws SystemException {
639    
640                    return getGroupFileEntries(
641                            groupId, userId, start, end, new FileEntryModifiedDateComparator());
642            }
643    
644            public List<DLFileEntry> getGroupFileEntries(
645                            long groupId, long userId, int start, int end,
646                            OrderByComparator obc)
647                    throws SystemException {
648    
649                    if (userId <= 0) {
650                            return dlFileEntryPersistence.findByGroupId(
651                                    groupId, start, end, obc);
652                    }
653                    else {
654                            return dlFileEntryPersistence.findByG_U(
655                                    groupId, userId, start, end, obc);
656                    }
657            }
658    
659            public int getGroupFileEntriesCount(long groupId) throws SystemException {
660                    return dlFileEntryPersistence.countByGroupId(groupId);
661            }
662    
663            public int getGroupFileEntriesCount(long groupId, long userId)
664                    throws SystemException {
665    
666                    if (userId <= 0) {
667                            return dlFileEntryPersistence.countByGroupId(groupId);
668                    }
669                    else {
670                            return dlFileEntryPersistence.countByG_U(groupId, userId);
671                    }
672            }
673    
674            public List<DLFileEntry> getNoAssetFileEntries() throws SystemException {
675                    return dlFileEntryFinder.findByNoAssets();
676            }
677    
678            public DLFileEntry moveFileEntry(
679                            long userId, long groupId, long folderId, long newFolderId,
680                            String name, ServiceContext serviceContext)
681                    throws PortalException, SystemException {
682    
683                    User user = userPersistence.findByPrimaryKey(userId);
684    
685                    Date now = new Date();
686    
687                    DLFileEntry fileEntry = dlFileEntryPersistence.findByG_F_N(
688                            groupId, folderId, name);
689    
690                    long oldFileEntryId = fileEntry.getFileEntryId();
691    
692                    if (dlLocalService.hasFile(
693                                    user.getCompanyId(),
694                                    DLFileEntryImpl.getRepositoryId(groupId, newFolderId), name,
695                                    StringPool.BLANK)) {
696    
697                            throw new DuplicateFileException(name);
698                    }
699    
700                    long newFileEntryId = counterLocalService.increment();
701    
702                    DLFileEntry newFileEntry = dlFileEntryPersistence.create(
703                            newFileEntryId);
704    
705                    newFileEntry.setGroupId(fileEntry.getGroupId());
706                    newFileEntry.setCompanyId(fileEntry.getCompanyId());
707                    newFileEntry.setUserId(fileEntry.getUserId());
708                    newFileEntry.setUserName(fileEntry.getUserName());
709                    newFileEntry.setVersionUserId(fileEntry.getVersionUserId());
710                    newFileEntry.setVersionUserName(fileEntry.getVersionUserName());
711                    newFileEntry.setCreateDate(fileEntry.getCreateDate());
712                    newFileEntry.setModifiedDate(fileEntry.getModifiedDate());
713                    newFileEntry.setFolderId(newFolderId);
714                    newFileEntry.setName(name);
715                    newFileEntry.setExtension(fileEntry.getExtension());
716                    newFileEntry.setTitle(fileEntry.getTitle());
717                    newFileEntry.setDescription(fileEntry.getDescription());
718                    newFileEntry.setExtraSettings(fileEntry.getExtraSettings());
719                    newFileEntry.setVersion(fileEntry.getVersion());
720                    newFileEntry.setSize(fileEntry.getSize());
721                    newFileEntry.setReadCount(fileEntry.getReadCount());
722    
723                    dlFileEntryPersistence.update(newFileEntry, false);
724    
725                    dlFileEntryPersistence.remove(fileEntry);
726    
727                    workflowInstanceLinkLocalService.updateClassPK(
728                            fileEntry.getCompanyId(), fileEntry.getGroupId(),
729                            DLFileEntry.class.getName(), oldFileEntryId, newFileEntryId);
730    
731                    List<DLFileVersion> fileVersions = dlFileVersionPersistence.findByG_F_N(
732                            groupId, folderId, name);
733    
734                    for (DLFileVersion fileVersion : fileVersions) {
735                            long newFileVersionId = counterLocalService.increment();
736    
737                            DLFileVersion newFileVersion = dlFileVersionPersistence.create(
738                                    newFileVersionId);
739    
740                            newFileVersion.setGroupId(fileVersion.getGroupId());
741                            newFileVersion.setCompanyId(fileVersion.getCompanyId());
742                            newFileVersion.setUserId(fileVersion.getUserId());
743                            newFileVersion.setUserName(fileVersion.getUserName());
744                            newFileVersion.setCreateDate(fileVersion.getCreateDate());
745                            newFileVersion.setFolderId(newFolderId);
746                            newFileVersion.setName(name);
747                            newFileVersion.setExtension(fileVersion.getExtension());
748                            newFileVersion.setTitle(fileVersion.getTitle());
749                            newFileVersion.setDescription(fileVersion.getDescription());
750                            newFileVersion.setChangeLog(fileVersion.getChangeLog());
751                            newFileVersion.setExtraSettings(fileVersion.getExtraSettings());
752                            newFileVersion.setVersion(fileVersion.getVersion());
753                            newFileVersion.setSize(fileVersion.getSize());
754                            newFileVersion.setStatus(fileVersion.getStatus());
755                            newFileVersion.setStatusByUserId(userId);
756                            newFileVersion.setStatusByUserName(user.getFullName());
757                            newFileVersion.setStatusDate(serviceContext.getModifiedDate(now));
758    
759                            dlFileVersionPersistence.update(newFileVersion, false);
760    
761                            dlFileVersionPersistence.remove(fileVersion);
762                    }
763    
764                    dlFileShortcutLocalService.updateFileShortcuts(
765                            groupId, folderId, name, newFolderId, name);
766    
767                    // Resources
768    
769                    resourceLocalService.updateResources(
770                            fileEntry.getCompanyId(), DLFileEntry.class.getName(),
771                            ResourceConstants.SCOPE_INDIVIDUAL,
772                            String.valueOf(fileEntry.getFileEntryId()),
773                            String.valueOf(newFileEntryId));
774    
775                    // Asset
776    
777                    assetEntryLocalService.deleteEntry(
778                            DLFileEntry.class.getName(), fileEntry.getFileEntryId());
779    
780                    List<DLFileShortcut> fileShortcuts =
781                            dlFileShortcutPersistence.findByG_TF_TN(
782                                    groupId, folderId, name);
783    
784                    for (DLFileShortcut fileShortcut : fileShortcuts) {
785                            assetEntryLocalService.deleteEntry(
786                                    DLFileShortcut.class.getName(),
787                                    fileShortcut.getFileShortcutId());
788                    }
789    
790                    // Expando
791    
792                    expandoValueLocalService.deleteValues(
793                            DLFileEntry.class.getName(), fileEntry.getFileEntryId());
794    
795                    // Ratings
796    
797                    RatingsStats stats = ratingsStatsLocalService.getStats(
798                            DLFileEntry.class.getName(), oldFileEntryId);
799    
800                    stats.setClassPK(newFileEntryId);
801    
802                    ratingsStatsPersistence.update(stats, false);
803    
804                    long classNameId = PortalUtil.getClassNameId(
805                            DLFileEntry.class.getName());
806    
807                    List<RatingsEntry> entries = ratingsEntryPersistence.findByC_C(
808                            classNameId, oldFileEntryId);
809    
810                    for (RatingsEntry entry : entries) {
811                            entry.setClassPK(newFileEntryId);
812    
813                            ratingsEntryPersistence.update(entry, false);
814                    }
815    
816                    // Message boards
817    
818                    MBDiscussion discussion = mbDiscussionPersistence.fetchByC_C(
819                            classNameId, oldFileEntryId);
820    
821                    if (discussion != null) {
822                            discussion.setClassPK(newFileEntryId);
823    
824                            mbDiscussionPersistence.update(discussion, false);
825                    }
826    
827                    // Social
828    
829                    socialActivityLocalService.deleteActivities(
830                            DLFileEntry.class.getName(), fileEntry.getFileEntryId());
831    
832                    // File
833    
834                    dlService.updateFile(
835                            user.getCompanyId(), PortletKeys.DOCUMENT_LIBRARY,
836                            newFileEntry.getGroupId(), fileEntry.getRepositoryId(),
837                            newFileEntry.getRepositoryId(), name, newFileEntryId);
838    
839                    return newFileEntry;
840            }
841    
842            public void updateAsset(
843                            long userId, DLFileEntry fileEntry, DLFileVersion fileVersion,
844                            long[] assetCategoryIds, String[] assetTagNames)
845                    throws PortalException, SystemException {
846    
847                    String mimeType = MimeTypesUtil.getContentType(fileEntry.getTitle());
848    
849                    boolean addDraftAssetEntry = false;
850    
851                    if ((fileVersion != null) && !fileVersion.isApproved() &&
852                            (fileVersion.getVersion() !=
853                                    DLFileEntryConstants.DEFAULT_VERSION)) {
854    
855                            int approvedArticlesCount =
856                                    dlFileVersionPersistence.countByG_F_N_S(
857                                            fileEntry.getGroupId(), fileEntry.getFolderId(),
858                                            fileEntry.getName(), WorkflowConstants.STATUS_APPROVED);
859    
860                            if (approvedArticlesCount > 0) {
861                                    addDraftAssetEntry = true;
862                            }
863                    }
864    
865                    if (addDraftAssetEntry) {
866                            assetEntryLocalService.updateEntry(
867                                    userId, fileEntry.getGroupId(), DLFileEntry.class.getName(),
868                                    fileVersion.getFileVersionId(), fileEntry.getUuid(),
869                                    assetCategoryIds, assetTagNames, false, null, null, null, null,
870                                    mimeType, fileEntry.getTitle(), fileEntry.getDescription(),
871                                    null, null, 0, 0, null, false);
872                    }
873                    else {
874                            boolean visible = true;
875    
876                            if ((fileVersion != null) && !fileVersion.isApproved()) {
877                                    visible = false;
878                            }
879    
880                            assetEntryLocalService.updateEntry(
881                                    userId, fileEntry.getGroupId(), DLFileEntry.class.getName(),
882                                    fileEntry.getFileEntryId(), fileEntry.getUuid(),
883                                    assetCategoryIds, assetTagNames, visible, null, null, null,
884                                    null, mimeType, fileEntry.getTitle(),
885                                    fileEntry.getDescription(), null, null, 0, 0, null, false);
886    
887                            List<DLFileShortcut> fileShortcuts =
888                                    dlFileShortcutPersistence.findByG_TF_TN(
889                                            fileEntry.getGroupId(), fileEntry.getFolderId(),
890                                            fileEntry.getName());
891    
892                            for (DLFileShortcut fileShortcut : fileShortcuts) {
893                                    assetEntryLocalService.updateEntry(
894                                            userId, fileShortcut.getGroupId(),
895                                            DLFileShortcut.class.getName(),
896                                            fileShortcut.getFileShortcutId(), fileShortcut.getUuid(),
897                                            assetCategoryIds, assetTagNames, true, null, null, null,
898                                            null, mimeType, fileEntry.getTitle(),
899                                            fileEntry.getDescription(), null, null, 0, 0, null, false);
900                            }
901                    }
902            }
903    
904            public DLFileEntry updateFileEntry(
905                            long userId, long groupId, long folderId, String name,
906                            String sourceFileName, String title, String description,
907                            String changeLog, boolean majorVersion, String extraSettings,
908                            byte[] bytes, ServiceContext serviceContext)
909                    throws PortalException, SystemException {
910    
911                    InputStream is = null;
912                    long size = 0;
913    
914                    if (bytes != null) {
915                            is = new UnsyncByteArrayInputStream(bytes);
916                            size = bytes.length;
917                    }
918    
919                    return updateFileEntry(
920                            userId, groupId, folderId, name, sourceFileName, title, description,
921                            changeLog, majorVersion, extraSettings, is, size, serviceContext);
922            }
923    
924            public DLFileEntry updateFileEntry(
925                            long userId, long groupId, long folderId, String name,
926                            String sourceFileName, String title, String description,
927                            String changeLog, boolean majorVersion, String extraSettings,
928                            File file, ServiceContext serviceContext)
929                    throws PortalException, SystemException {
930    
931                    try {
932                            InputStream is = null;
933                            long size = 0;
934    
935                            if ((file != null) && file.exists()) {
936                                    is = new UnsyncBufferedInputStream(new FileInputStream(file));
937                                    size = file.length();
938                            }
939    
940                            return updateFileEntry(
941                                    userId, groupId, folderId, name, sourceFileName, title,
942                                    description, changeLog, majorVersion, extraSettings, is, size,
943                                    serviceContext);
944                    }
945                    catch (FileNotFoundException fnfe) {
946                            throw new NoSuchFileException();
947                    }
948            }
949    
950            public DLFileEntry updateFileEntry(
951                            long userId, long groupId, long folderId, String name,
952                            String sourceFileName, String title, String description,
953                            String changeLog, boolean majorVersion, String extraSettings,
954                            InputStream is, long size, ServiceContext serviceContext)
955                    throws PortalException, SystemException {
956    
957                    // File entry
958    
959                    User user = userPersistence.findByPrimaryKey(userId);
960    
961                    if (Validator.isNull(title)) {
962                            title = sourceFileName;
963    
964                            if (Validator.isNull(title)) {
965                                    title = name;
966                            }
967                    }
968    
969                    Date now = new Date();
970    
971                    DLFileEntry fileEntry = dlFileEntryPersistence.findByG_F_N(
972                            groupId, folderId, name);
973    
974                    validate(
975                            groupId, folderId, name, fileEntry.getExtension(), title,
976                            sourceFileName, is);
977    
978                    // File version
979    
980                    String version = getNextVersion(
981                            fileEntry, majorVersion, serviceContext.getWorkflowAction());
982    
983                    DLFileVersion fileVersion = null;
984    
985                    String extension = null;
986    
987                    if (Validator.isNotNull(sourceFileName)) {
988                            extension = FileUtil.getExtension(sourceFileName);
989                    }
990                    else {
991                            extension = fileEntry.getExtension();
992                    }
993    
994                    try {
995                            DLFileVersion latestFileVersion =
996                                    dlFileVersionLocalService.getLatestFileVersion(
997                                            groupId, folderId, name);
998    
999                            if (size == 0) {
1000                                    size = latestFileVersion.getSize();
1001                            }
1002    
1003                            if (latestFileVersion.getStatus() !=
1004                                            WorkflowConstants.STATUS_APPROVED) {
1005    
1006                                    serviceContext.setWorkflowAction(
1007                                            WorkflowConstants.ACTION_SAVE_DRAFT);
1008    
1009                                    version = latestFileVersion.getVersion();
1010    
1011                                    updateFileVersion(
1012                                            user, latestFileVersion, sourceFileName, extension, title,
1013                                            description, changeLog, extraSettings, version, size,
1014                                            latestFileVersion.getStatus(),
1015                                            serviceContext.getModifiedDate(now), serviceContext);
1016                            }
1017                            else {
1018                                    fileVersion = addFileVersion(
1019                                            user, fileEntry, serviceContext.getModifiedDate(now),
1020                                            extension, title, description, changeLog, extraSettings,
1021                                            version, size, WorkflowConstants.STATUS_DRAFT,
1022                                            serviceContext);
1023                            }
1024    
1025                            if (fileVersion == null) {
1026                                    fileVersion = latestFileVersion;
1027                            }
1028                    }
1029                    catch (NoSuchFileVersionException nsfve) {
1030                            fileVersion = addFileVersion(
1031                                    user, fileEntry, serviceContext.getModifiedDate(now),
1032                                    extension, title, description, changeLog, extraSettings,
1033                                    version, size, WorkflowConstants.STATUS_DRAFT, serviceContext);
1034                    }
1035    
1036                    if ((is == null) && !version.equals(fileEntry.getVersion())) {
1037                            int fetchFailures = 0;
1038    
1039                            while (is == null) {
1040                                    try {
1041                                            is = dlLocalService.getFileAsStream(
1042                                                    user.getCompanyId(), fileEntry.getRepositoryId(), name);
1043                                    }
1044                                    catch (NoSuchFileException nsfe) {
1045                                            fetchFailures++;
1046    
1047                                            if (PropsValues.DL_HOOK_IMPL.equals(
1048                                                            JCRHook.class.getName()) &&
1049                                                    (fetchFailures <
1050                                                            PropsValues.DL_HOOK_JCR_FETCH_MAX_FAILURES)) {
1051    
1052                                                    try {
1053                                                            Thread.sleep(PropsValues.DL_HOOK_JCR_FETCH_DELAY);
1054                                                    }
1055                                                    catch (InterruptedException ie) {
1056                                                    }
1057                                            }
1058                                            else {
1059                                                    throw nsfe;
1060                                            }
1061                                    }
1062                            }
1063                    }
1064    
1065                    // Asset
1066    
1067                    updateAsset(
1068                            userId, fileEntry, fileVersion,
1069                            serviceContext.getAssetCategoryIds(),
1070                            serviceContext.getAssetTagNames());
1071    
1072                    // Folder
1073    
1074                    if (fileEntry.getFolderId() !=
1075                                    DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
1076    
1077                            DLFolder folder = dlFolderPersistence.findByPrimaryKey(
1078                                    fileEntry.getFolderId());
1079    
1080                            folder.setLastPostDate(fileEntry.getModifiedDate());
1081    
1082                            dlFolderPersistence.update(folder, false);
1083                    }
1084    
1085                    // File
1086    
1087                    if (is != null) {
1088                            try {
1089                                    dlService.deleteFile(
1090                                            user.getCompanyId(), PortletKeys.DOCUMENT_LIBRARY,
1091                                            fileEntry.getRepositoryId(), fileEntry.getName(), version);
1092                            }
1093                            catch (NoSuchFileException nsfe) {
1094                            }
1095    
1096                            dlLocalService.updateFile(
1097                                    user.getCompanyId(), PortletKeys.DOCUMENT_LIBRARY,
1098                                    fileEntry.getGroupId(), fileEntry.getRepositoryId(), name,
1099                                    fileEntry.getExtension(), false, version, sourceFileName,
1100                                    fileEntry.getFileEntryId(),     fileEntry.getLuceneProperties(),
1101                                    fileEntry.getModifiedDate(), serviceContext, is);
1102                    }
1103    
1104                    // Workflow
1105    
1106                    WorkflowHandlerRegistryUtil.startWorkflowInstance(
1107                            user.getCompanyId(), groupId, userId, DLFileEntry.class.getName(),
1108                            fileEntry.getFileEntryId(), fileEntry, serviceContext);
1109    
1110                    return fileEntry;
1111            }
1112    
1113            public DLFileEntry updateStatus(
1114                            long userId, long fileEntryId, int status,
1115                            ServiceContext serviceContext)
1116                    throws PortalException, SystemException {
1117    
1118                    // File entry
1119    
1120                    User user = userPersistence.findByPrimaryKey(userId);
1121    
1122                    DLFileEntry fileEntry = dlFileEntryPersistence.findByPrimaryKey(
1123                            fileEntryId);
1124    
1125                    // File version
1126    
1127                    DLFileVersion latestFileVersion =
1128                            dlFileVersionLocalService.getLatestFileVersion(
1129                                    fileEntry.getGroupId(), fileEntry.getFolderId(),
1130                                    fileEntry.getName());
1131    
1132                    latestFileVersion.setStatus(status);
1133                    latestFileVersion.setStatusByUserId(user.getUserId());
1134                    latestFileVersion.setStatusByUserName(user.getFullName());
1135                    latestFileVersion.setStatusDate(new Date());
1136    
1137                    dlFileVersionPersistence.update(latestFileVersion, false);
1138    
1139                    if (status == WorkflowConstants.STATUS_APPROVED) {
1140    
1141                            // File entry
1142    
1143                            if (DLUtil.compareVersions(
1144                                            fileEntry.getVersion(),
1145                                            latestFileVersion.getVersion()) < 0) {
1146    
1147                                    fileEntry.setTitle(latestFileVersion.getTitle());
1148                                    fileEntry.setDescription(latestFileVersion.getDescription());
1149                                    fileEntry.setExtraSettings(
1150                                            latestFileVersion.getExtraSettings());
1151                                    fileEntry.setVersion(latestFileVersion.getVersion());
1152                                    fileEntry.setVersionUserId(latestFileVersion.getUserId());
1153                                    fileEntry.setVersionUserName(latestFileVersion.getUserName());
1154                                    fileEntry.setModifiedDate(latestFileVersion.getCreateDate());
1155                                    fileEntry.setSize(latestFileVersion.getSize());
1156    
1157                                    dlFileEntryPersistence.update(fileEntry, false);
1158                            }
1159    
1160                            // Asset
1161    
1162                            if (fileEntry.getVersion().equals(latestFileVersion.getVersion())) {
1163                                    if ((latestFileVersion.getVersion() !=
1164                                                    DLFileEntryConstants.DEFAULT_VERSION)) {
1165    
1166                                            AssetEntry draftAssetEntry = null;
1167    
1168                                            try {
1169                                                    draftAssetEntry = assetEntryLocalService.getEntry(
1170                                                            DLFileEntry.class.getName(),
1171                                                            latestFileVersion.getPrimaryKey());
1172    
1173                                                    long[] assetCategoryIds =
1174                                                            draftAssetEntry.getCategoryIds();
1175                                                    String[] assetTagNames = draftAssetEntry.getTagNames();
1176    
1177                                                    assetEntryLocalService.updateEntry(
1178                                                            userId, fileEntry.getGroupId(),
1179                                                            DLFileEntry.class.getName(),
1180                                                            fileEntry.getFileEntryId(), fileEntry.getUuid(),
1181                                                            assetCategoryIds, assetTagNames, true, null, null,
1182                                                            null, null, draftAssetEntry.getMimeType(),
1183                                                            fileEntry.getTitle(), fileEntry.getDescription(),
1184                                                            null, null, 0, 0, null, false);
1185    
1186                                                    assetEntryLocalService.deleteEntry(
1187                                                            draftAssetEntry.getEntryId());
1188                                            }
1189                                            catch (NoSuchEntryException nsee) {
1190                                            }
1191                                    }
1192    
1193                                    assetEntryLocalService.updateVisible(
1194                                            DLFileEntry.class.getName(), fileEntry.getFileEntryId(),
1195                                            true);
1196                            }
1197    
1198                            // Social
1199    
1200                            socialActivityLocalService.addUniqueActivity(
1201                                    latestFileVersion.getUserId(), latestFileVersion.getGroupId(),
1202                                    latestFileVersion.getCreateDate(), DLFileEntry.class.getName(),
1203                                    fileEntryId, DLActivityKeys.ADD_FILE_ENTRY,
1204                                    StringPool.BLANK, 0);
1205    
1206                            // Indexer
1207    
1208                            Indexer indexer = IndexerRegistryUtil.getIndexer(DLFileEntry.class);
1209    
1210                            indexer.reindex(fileEntry);
1211                    }
1212                    else {
1213    
1214                            // File entry
1215    
1216                            if (fileEntry.getVersion().equals(latestFileVersion.getVersion())) {
1217                                    String newVersion = DLFileEntryConstants.DEFAULT_VERSION;
1218    
1219                                    List<DLFileVersion> approvedFileVersions =
1220                                            dlFileVersionPersistence.findByG_F_N_S(
1221                                                    fileEntry.getGroupId(), fileEntry.getFolderId(),
1222                                                    fileEntry.getName(), WorkflowConstants.STATUS_APPROVED);
1223    
1224                                    if (!approvedFileVersions.isEmpty()) {
1225                                            newVersion = approvedFileVersions.get(0).getVersion();
1226                                    }
1227    
1228                                    fileEntry.setVersion(newVersion);
1229    
1230                                    dlFileEntryPersistence.update(fileEntry, false);
1231                            }
1232    
1233                            // Asset
1234    
1235                            if (Validator.isNull(fileEntry.getVersion())) {
1236                                    assetEntryLocalService.updateVisible(
1237                                            DLFileEntry.class.getName(), fileEntry.getFileEntryId(),
1238                                            false);
1239                            }
1240    
1241                            // Indexer
1242    
1243                            if (latestFileVersion.getVersion().equals(
1244                                            DLFileEntryConstants.DEFAULT_VERSION)) {
1245    
1246                                    Indexer indexer = IndexerRegistryUtil.getIndexer(
1247                                            DLFileEntry.class);
1248    
1249                                    indexer.delete(fileEntry);
1250                            }
1251                    }
1252    
1253                    return fileEntry;
1254            }
1255    
1256            protected DLFileVersion addFileVersion(
1257                            User user, DLFileEntry fileEntry, Date modifiedDate,
1258                            String extension, String title, String description,
1259                            String changeLog, String extraSettings, String version, long size,
1260                            int status, ServiceContext serviceContext)
1261                    throws SystemException {
1262    
1263                    long fileVersionId = counterLocalService.increment();
1264    
1265                    DLFileVersion fileVersion = dlFileVersionPersistence.create(
1266                            fileVersionId);
1267    
1268                    long versionUserId = fileEntry.getVersionUserId();
1269    
1270                    if (versionUserId <= 0) {
1271                            versionUserId = fileEntry.getUserId();
1272                    }
1273    
1274                    String versionUserName = GetterUtil.getString(
1275                            fileEntry.getVersionUserName(), fileEntry.getUserName());
1276    
1277                    fileVersion.setGroupId(fileEntry.getGroupId());
1278                    fileVersion.setCompanyId(fileEntry.getCompanyId());
1279                    fileVersion.setUserId(versionUserId);
1280                    fileVersion.setUserName(versionUserName);
1281                    fileVersion.setCreateDate(modifiedDate);
1282                    fileVersion.setFolderId(fileEntry.getFolderId());
1283                    fileVersion.setName(fileEntry.getName());
1284                    fileVersion.setExtension(extension);
1285                    fileVersion.setTitle(title);
1286                    fileVersion.setDescription(description);
1287                    fileVersion.setChangeLog(changeLog);
1288                    fileVersion.setExtraSettings(extraSettings);
1289                    fileVersion.setVersion(version);
1290                    fileVersion.setSize(size);
1291                    fileVersion.setStatus(status);
1292                    fileVersion.setStatusByUserId(user.getUserId());
1293                    fileVersion.setStatusByUserName(user.getFullName());
1294                    fileVersion.setStatusDate(fileEntry.getModifiedDate());
1295                    fileVersion.setExpandoBridgeAttributes(serviceContext);
1296    
1297                    dlFileVersionPersistence.update(fileVersion, false);
1298    
1299                    return fileVersion;
1300            }
1301    
1302            protected long getFolderId(long companyId, long folderId)
1303                    throws SystemException {
1304    
1305                    if (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
1306    
1307                            // Ensure folder exists and belongs to the proper company
1308    
1309                            DLFolder folder = dlFolderPersistence.fetchByPrimaryKey(folderId);
1310    
1311                            if ((folder == null) || (companyId != folder.getCompanyId())) {
1312                                    folderId = DLFolderConstants.DEFAULT_PARENT_FOLDER_ID;
1313                            }
1314                    }
1315    
1316                    return folderId;
1317            }
1318    
1319            protected String getNextVersion(
1320                    DLFileEntry fileEntry, boolean majorVersion, int workflowAction) {
1321    
1322                    if (Validator.isNull(fileEntry.getVersion())) {
1323                            return DLFileEntryConstants.DEFAULT_VERSION;
1324                    }
1325    
1326                    if (workflowAction == WorkflowConstants.ACTION_SAVE_DRAFT) {
1327                            majorVersion = false;
1328                    }
1329    
1330                    int[] versionParts = StringUtil.split(
1331                            fileEntry.getVersion(), StringPool.PERIOD, 0);
1332    
1333                    if (majorVersion) {
1334                            versionParts[0]++;
1335                            versionParts[1] = 0;
1336                    }
1337                    else {
1338                            versionParts[1]++;
1339                    }
1340    
1341                    return versionParts[0] + StringPool.PERIOD + versionParts[1];
1342            }
1343    
1344            protected void updateFileVersion(
1345                            User user, DLFileVersion fileVersion, String sourceFileName,
1346                            String extension, String title, String description,
1347                            String changeLog, String extraSettings, String version, long size,
1348                            int status, Date statusDate, ServiceContext serviceContext)
1349                    throws SystemException {
1350    
1351                    if (Validator.isNotNull(sourceFileName)) {
1352                            fileVersion.setExtension(extension);
1353                    }
1354    
1355                    fileVersion.setTitle(title);
1356                    fileVersion.setDescription(description);
1357                    fileVersion.setChangeLog(changeLog);
1358                    fileVersion.setExtraSettings(extraSettings);
1359                    fileVersion.setVersion(version);
1360                    fileVersion.setSize(size);
1361                    fileVersion.setStatus(status);
1362                    fileVersion.setStatusByUserId(user.getUserId());
1363                    fileVersion.setStatusByUserName(user.getFullName());
1364                    fileVersion.setStatusDate(statusDate);
1365                    fileVersion.setExpandoBridgeAttributes(serviceContext);
1366    
1367                    dlFileVersionPersistence.update(fileVersion, false);
1368            }
1369    
1370            protected void validate(
1371                            long groupId, long folderId, String title, InputStream is)
1372                    throws PortalException, SystemException {
1373    
1374                    dlLocalService.validate(title, true, is);
1375    
1376                    validate(groupId, folderId, null, title);
1377            }
1378    
1379            protected void validate(
1380                            long groupId, long folderId, String name, String title)
1381                    throws PortalException, SystemException {
1382    
1383                    try {
1384                            dlFolderLocalService.getFolder(groupId, folderId, title);
1385    
1386                            throw new DuplicateFolderNameException();
1387                    }
1388                    catch (NoSuchFolderException nsfe) {
1389                    }
1390    
1391                    try {
1392                            DLFileEntry fileEntry =
1393                                    dlFileEntryPersistence.findByG_F_T(groupId, folderId, title);
1394    
1395                            if (!fileEntry.getName().equals(name)) {
1396                                    throw new DuplicateFileException(title);
1397                            }
1398                    }
1399                    catch (NoSuchFileEntryException nsfee) {
1400                    }
1401            }
1402    
1403            protected void validate(
1404                            long groupId, long folderId, String name, String extension,
1405                            String title, String sourceFileName, InputStream is)
1406                    throws PortalException, SystemException {
1407    
1408                    if (Validator.isNotNull(sourceFileName)) {
1409                            dlLocalService.validate(
1410                                    sourceFileName, extension, sourceFileName, true, is);
1411                    }
1412    
1413                    validate(groupId, folderId, name, title);
1414            }
1415    
1416            private static Log _log = LogFactoryUtil.getLog(
1417                    DLFileEntryLocalServiceImpl.class);
1418    
1419    }