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