001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.dynamicdatalists.service.impl;
016    
017    import com.liferay.portal.kernel.exception.PortalException;
018    import com.liferay.portal.kernel.exception.SystemException;
019    import com.liferay.portal.kernel.language.LanguageUtil;
020    import com.liferay.portal.kernel.search.BaseModelSearchResult;
021    import com.liferay.portal.kernel.search.Hits;
022    import com.liferay.portal.kernel.search.Indexable;
023    import com.liferay.portal.kernel.search.IndexableType;
024    import com.liferay.portal.kernel.search.Indexer;
025    import com.liferay.portal.kernel.search.IndexerRegistryUtil;
026    import com.liferay.portal.kernel.search.SearchContext;
027    import com.liferay.portal.kernel.systemevent.SystemEvent;
028    import com.liferay.portal.kernel.util.Constants;
029    import com.liferay.portal.kernel.util.ContentTypes;
030    import com.liferay.portal.kernel.util.ListUtil;
031    import com.liferay.portal.kernel.util.LocaleUtil;
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.SystemEventConstants;
039    import com.liferay.portal.model.User;
040    import com.liferay.portal.service.ServiceContext;
041    import com.liferay.portlet.documentlibrary.util.DLUtil;
042    import com.liferay.portlet.dynamicdatalists.NoSuchRecordVersionException;
043    import com.liferay.portlet.dynamicdatalists.model.DDLRecord;
044    import com.liferay.portlet.dynamicdatalists.model.DDLRecordConstants;
045    import com.liferay.portlet.dynamicdatalists.model.DDLRecordSet;
046    import com.liferay.portlet.dynamicdatalists.model.DDLRecordVersion;
047    import com.liferay.portlet.dynamicdatalists.service.base.DDLRecordLocalServiceBaseImpl;
048    import com.liferay.portlet.dynamicdatalists.util.DDL;
049    import com.liferay.portlet.dynamicdatalists.util.DDLUtil;
050    import com.liferay.portlet.dynamicdatalists.util.comparator.DDLRecordVersionVersionComparator;
051    import com.liferay.portlet.dynamicdatamapping.model.DDMStructure;
052    import com.liferay.portlet.dynamicdatamapping.storage.Field;
053    import com.liferay.portlet.dynamicdatamapping.storage.Fields;
054    import com.liferay.portlet.dynamicdatamapping.storage.StorageEngineUtil;
055    import com.liferay.portlet.dynamicdatamapping.util.DDMUtil;
056    import com.liferay.portlet.expando.model.ExpandoBridge;
057    
058    import java.io.Serializable;
059    
060    import java.util.Collections;
061    import java.util.Date;
062    import java.util.List;
063    import java.util.Locale;
064    import java.util.Map;
065    
066    /**
067     * Provides the local service for accessing, adding, deleting, and updating
068     * dynamic data list (DDL) records.
069     *
070     * @author Marcellus Tavares
071     * @author Eduardo Lundgren
072     */
073    public class DDLRecordLocalServiceImpl extends DDLRecordLocalServiceBaseImpl {
074    
075            @Indexable(type = IndexableType.REINDEX)
076            @Override
077            public DDLRecord addRecord(
078                            long userId, long groupId, long recordSetId, int displayIndex,
079                            Fields fields, ServiceContext serviceContext)
080                    throws PortalException {
081    
082                    // Record
083    
084                    User user = userPersistence.findByPrimaryKey(userId);
085                    Date now = new Date();
086    
087                    DDLRecordSet recordSet = ddlRecordSetPersistence.findByPrimaryKey(
088                            recordSetId);
089    
090                    long recordId = counterLocalService.increment();
091    
092                    DDLRecord record = ddlRecordPersistence.create(recordId);
093    
094                    record.setUuid(serviceContext.getUuid());
095                    record.setGroupId(groupId);
096                    record.setCompanyId(user.getCompanyId());
097                    record.setUserId(user.getUserId());
098                    record.setUserName(user.getFullName());
099                    record.setVersionUserId(user.getUserId());
100                    record.setVersionUserName(user.getFullName());
101                    record.setCreateDate(serviceContext.getCreateDate(now));
102                    record.setModifiedDate(serviceContext.getModifiedDate(now));
103    
104                    long ddmStorageId = StorageEngineUtil.create(
105                            recordSet.getCompanyId(), recordSet.getDDMStructureId(), fields,
106                            serviceContext);
107    
108                    record.setDDMStorageId(ddmStorageId);
109    
110                    record.setRecordSetId(recordSetId);
111                    record.setVersion(DDLRecordConstants.VERSION_DEFAULT);
112                    record.setDisplayIndex(displayIndex);
113    
114                    ddlRecordPersistence.update(record);
115    
116                    // Record version
117    
118                    DDLRecordVersion recordVersion = addRecordVersion(
119                            user, record, ddmStorageId, DDLRecordConstants.VERSION_DEFAULT,
120                            displayIndex, WorkflowConstants.STATUS_DRAFT);
121    
122                    // Asset
123    
124                    Locale locale = serviceContext.getLocale();
125    
126                    updateAsset(
127                            userId, record, recordVersion, serviceContext.getAssetCategoryIds(),
128                            serviceContext.getAssetTagNames(), locale);
129    
130                    // Workflow
131    
132                    WorkflowHandlerRegistryUtil.startWorkflowInstance(
133                            user.getCompanyId(), groupId, userId, DDLRecord.class.getName(),
134                            recordVersion.getRecordVersionId(), recordVersion, serviceContext);
135    
136                    return record;
137            }
138    
139            @Override
140            public DDLRecord addRecord(
141                            long userId, long groupId, long recordSetId, int displayIndex,
142                            Map<String, Serializable> fieldsMap, ServiceContext serviceContext)
143                    throws PortalException {
144    
145                    DDLRecordSet recordSet = ddlRecordSetPersistence.findByPrimaryKey(
146                            recordSetId);
147    
148                    DDMStructure ddmStructure = recordSet.getDDMStructure();
149    
150                    Fields fields = toFields(
151                            ddmStructure.getStructureId(), fieldsMap,
152                            serviceContext.getLocale(), LocaleUtil.getSiteDefault(), true);
153    
154                    return ddlRecordLocalService.addRecord(
155                            userId, groupId, recordSetId, displayIndex, fields, serviceContext);
156            }
157    
158            @Indexable(type = IndexableType.DELETE)
159            @Override
160            @SystemEvent(
161                    action = SystemEventConstants.ACTION_SKIP,
162                    type = SystemEventConstants.TYPE_DELETE)
163            public DDLRecord deleteRecord(DDLRecord record) throws PortalException {
164    
165                    // Record
166    
167                    ddlRecordPersistence.remove(record);
168    
169                    // Record Versions
170    
171                    List<DDLRecordVersion> recordVersions =
172                            ddlRecordVersionPersistence.findByRecordId(record.getRecordId());
173    
174                    for (DDLRecordVersion recordVersion : recordVersions) {
175                            ddlRecordVersionPersistence.remove(recordVersion);
176    
177                            // Dynamic data mapping storage
178    
179                            StorageEngineUtil.deleteByClass(recordVersion.getDDMStorageId());
180    
181                            // Workflow
182    
183                            workflowInstanceLinkLocalService.deleteWorkflowInstanceLinks(
184                                    record.getCompanyId(), record.getGroupId(),
185                                    DDLRecord.class.getName(), recordVersion.getPrimaryKey());
186                    }
187    
188                    // Asset
189    
190                    assetEntryLocalService.deleteEntry(
191                            DDLRecord.class.getName(), record.getRecordId());
192    
193                    return record;
194            }
195    
196            @Override
197            public void deleteRecord(long recordId) throws PortalException {
198                    DDLRecord record = ddlRecordPersistence.findByPrimaryKey(recordId);
199    
200                    ddlRecordLocalService.deleteRecord(record);
201            }
202    
203            @Override
204            public DDLRecord deleteRecordLocale(
205                            long recordId, Locale locale, ServiceContext serviceContext)
206                    throws PortalException {
207    
208                    DDLRecord record = ddlRecordPersistence.findByPrimaryKey(recordId);
209    
210                    Fields fields = StorageEngineUtil.getFields(record.getDDMStorageId());
211    
212                    for (Field field : fields) {
213                            Map<Locale, List<Serializable>> valuesMap = field.getValuesMap();
214    
215                            valuesMap.remove(locale);
216                    }
217    
218                    return ddlRecordLocalService.updateRecord(
219                            serviceContext.getUserId(), recordId, false,
220                            DDLRecordConstants.DISPLAY_INDEX_DEFAULT, fields, false,
221                            serviceContext);
222            }
223    
224            @Override
225            public void deleteRecords(long recordSetId) throws PortalException {
226                    List<DDLRecord> records = ddlRecordPersistence.findByRecordSetId(
227                            recordSetId);
228    
229                    for (DDLRecord record : records) {
230                            ddlRecordLocalService.deleteRecord(record);
231                    }
232            }
233    
234            @Override
235            public DDLRecord fetchRecord(long recordId) {
236                    return ddlRecordPersistence.fetchByPrimaryKey(recordId);
237            }
238    
239            @Override
240            public List<DDLRecord> getCompanyRecords(
241                    long companyId, int status, int scope, int start, int end,
242                    OrderByComparator<DDLRecord> orderByComparator) {
243    
244                    return ddlRecordFinder.findByC_S_S(
245                            companyId, status, scope, start, end, orderByComparator);
246            }
247    
248            /**
249             * @deprecated As of 6.2.0, replaced by {@link #getCompanyRecords(long, int,
250             *             int, int, int, OrderByComparator)}
251             */
252            @Deprecated
253            @Override
254            public List<DDLRecord> getCompanyRecords(
255                    long companyId, int scope, int start, int end,
256                    OrderByComparator<DDLRecord> orderByComparator) {
257    
258                    return getCompanyRecords(
259                            companyId, WorkflowConstants.STATUS_ANY, scope, start, end,
260                            orderByComparator);
261            }
262    
263            /**
264             * @deprecated As of 6.2.0, replaced by {@link #getCompanyRecordsCount(long,
265             *             int, int)}
266             */
267            @Deprecated
268            @Override
269            public int getCompanyRecordsCount(long companyId, int scope) {
270                    return getCompanyRecordsCount(
271                            companyId, WorkflowConstants.STATUS_ANY, scope);
272            }
273    
274            @Override
275            public int getCompanyRecordsCount(long companyId, int status, int scope) {
276                    return ddlRecordFinder.countByC_S_S(companyId, status, scope);
277            }
278    
279            @Override
280            public DDLRecordVersion getLatestRecordVersion(long recordId)
281                    throws PortalException {
282    
283                    List<DDLRecordVersion> recordVersions =
284                            ddlRecordVersionPersistence.findByRecordId(recordId);
285    
286                    if (recordVersions.isEmpty()) {
287                            throw new NoSuchRecordVersionException(
288                                    "No record versions found for recordId " + recordId);
289                    }
290    
291                    recordVersions = ListUtil.copy(recordVersions);
292    
293                    Collections.sort(
294                            recordVersions, new DDLRecordVersionVersionComparator());
295    
296                    return recordVersions.get(0);
297            }
298    
299            @Override
300            public Long[] getMinAndMaxCompanyRecordIds(
301                    long companyId, int status, int scope) {
302    
303                    return ddlRecordFinder.findByC_S_S_MinAndMax(companyId, status, scope);
304            }
305    
306            @Override
307            public List<DDLRecord> getMinAndMaxCompanyRecords(
308                    long companyId, int status, int scope, long minRecordId,
309                    long maxRecordId) {
310    
311                    return ddlRecordFinder.findByC_S_S_MinAndMax(
312                            companyId, status, scope, minRecordId, maxRecordId);
313            }
314    
315            @Override
316            public DDLRecord getRecord(long recordId) throws PortalException {
317                    return ddlRecordPersistence.findByPrimaryKey(recordId);
318            }
319    
320            @Override
321            public List<DDLRecord> getRecords(long recordSetId) {
322                    return ddlRecordPersistence.findByRecordSetId(recordSetId);
323            }
324    
325            @Override
326            public List<DDLRecord> getRecords(
327                    long recordSetId, int status, int start, int end,
328                    OrderByComparator<DDLRecord> orderByComparator) {
329    
330                    return ddlRecordFinder.findByR_S(
331                            recordSetId, status, start, end, orderByComparator);
332            }
333    
334            @Override
335            public List<DDLRecord> getRecords(long recordSetId, long userId) {
336                    return ddlRecordPersistence.findByR_U(recordSetId, userId);
337            }
338    
339            @Override
340            public int getRecordsCount(long recordSetId, int status) {
341                    return ddlRecordFinder.countByR_S(recordSetId, status);
342            }
343    
344            /**
345             * @deprecated As of 7.0.0, replaced by {@link
346             *             DDLRecordVersionLocalServiceImpl#getRecordVersion(long)}
347             */
348            @Deprecated
349            @Override
350            public DDLRecordVersion getRecordVersion(long recordVersionId)
351                    throws PortalException {
352    
353                    return ddlRecordVersionPersistence.findByPrimaryKey(recordVersionId);
354            }
355    
356            /**
357             * @deprecated As of 7.0.0, replaced by {@link
358             *             DDLRecordVersionLocalServiceImpl#getRecordVersion(long,
359             *             String)}
360             */
361            @Deprecated
362            @Override
363            public DDLRecordVersion getRecordVersion(long recordId, String version)
364                    throws PortalException {
365    
366                    return ddlRecordVersionPersistence.findByR_V(recordId, version);
367            }
368    
369            /**
370             * @deprecated As of 7.0.0, replaced by {@link
371             *             DDLRecordVersionLocalServiceImpl#getRecordVersions(long, int,
372             *             int, OrderByComparator)}
373             */
374            @Deprecated
375            @Override
376            public List<DDLRecordVersion> getRecordVersions(
377                    long recordId, int start, int end,
378                    OrderByComparator<DDLRecordVersion> orderByComparator) {
379    
380                    return ddlRecordVersionPersistence.findByRecordId(
381                            recordId, start, end, orderByComparator);
382            }
383    
384            /**
385             * @deprecated As of 7.0.0, replaced by {@link
386             *             DDLRecordVersionLocalServiceImpl#getRecordVersionsCount(
387             *             long)}
388             */
389            @Deprecated
390            @Override
391            public int getRecordVersionsCount(long recordId) {
392                    return ddlRecordVersionPersistence.countByRecordId(recordId);
393            }
394    
395            @Override
396            public void revertRecord(
397                            long userId, long recordId, String version,
398                            ServiceContext serviceContext)
399                    throws PortalException {
400    
401                    DDLRecordVersion recordVersion =
402                            ddlRecordVersionLocalService.getRecordVersion(recordId, version);
403    
404                    if (!recordVersion.isApproved()) {
405                            return;
406                    }
407    
408                    Fields fields = StorageEngineUtil.getFields(
409                            recordVersion.getDDMStorageId());
410    
411                    serviceContext.setCommand(Constants.REVERT);
412    
413                    ddlRecordLocalService.updateRecord(
414                            userId, recordId, true, recordVersion.getDisplayIndex(), fields,
415                            false, serviceContext);
416            }
417    
418            /**
419             * @deprecated As of 7.0.0, replaced by {@link #revertRecord(long, long,
420             *             String, ServiceContext)}
421             */
422            @Deprecated
423            @Override
424            public void revertRecordVersion(
425                            long userId, long recordId, String version,
426                            ServiceContext serviceContext)
427                    throws PortalException {
428    
429                    revertRecord(userId, recordId, version, serviceContext);
430            }
431    
432            @Override
433            public Hits search(SearchContext searchContext) {
434                    try {
435                            Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
436                                    DDLRecord.class);
437    
438                            return indexer.search(searchContext);
439                    }
440                    catch (Exception e) {
441                            throw new SystemException(e);
442                    }
443            }
444    
445            @Override
446            public BaseModelSearchResult<DDLRecord> searchDDLRecords(
447                    SearchContext searchContext) {
448    
449                    try {
450                            Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
451                                    DDLRecord.class);
452    
453                            Hits hits = indexer.search(searchContext, DDL.SELECTED_FIELD_NAMES);
454    
455                            List<DDLRecord> ddlRecords = DDLUtil.getRecords(hits);
456    
457                            return new BaseModelSearchResult<DDLRecord>(
458                                    ddlRecords, hits.getLength());
459                    }
460                    catch (Exception e) {
461                            throw new SystemException(e);
462                    }
463            }
464    
465            @Override
466            public void updateAsset(
467                            long userId, DDLRecord record, DDLRecordVersion recordVersion,
468                            long[] assetCategoryIds, String[] assetTagNames, Locale locale)
469                    throws PortalException {
470    
471                    boolean addDraftAssetEntry = false;
472    
473                    if ((recordVersion != null) && !recordVersion.isApproved()) {
474                            String version = recordVersion.getVersion();
475    
476                            if (!version.equals(DDLRecordConstants.VERSION_DEFAULT)) {
477                                    int approvedRecordVersionsCount =
478                                            ddlRecordVersionPersistence.countByR_S(
479                                                    record.getRecordId(),
480                                                    WorkflowConstants.STATUS_APPROVED);
481    
482                                    if (approvedRecordVersionsCount > 0) {
483                                            addDraftAssetEntry = true;
484                                    }
485                            }
486                    }
487    
488                    boolean visible = false;
489    
490                    if ((recordVersion != null) && !recordVersion.isApproved()) {
491                            visible = false;
492                    }
493    
494                    DDLRecordSet recordSet = record.getRecordSet();
495    
496                    DDMStructure ddmStructure = recordSet.getDDMStructure();
497    
498                    String ddmStructureName = ddmStructure.getName(locale);
499    
500                    String recordSetName = recordSet.getName(locale);
501    
502                    String title = LanguageUtil.format(
503                            locale, "new-x-for-list-x",
504                            new Object[] {ddmStructureName, recordSetName}, false);
505    
506                    if (addDraftAssetEntry) {
507                            assetEntryLocalService.updateEntry(
508                                    userId, record.getGroupId(), record.getCreateDate(),
509                                    record.getModifiedDate(), DDLRecordConstants.getClassName(),
510                                    recordVersion.getRecordVersionId(), record.getUuid(), 0,
511                                    assetCategoryIds, assetTagNames, false, null, null, null,
512                                    ContentTypes.TEXT_HTML, title, null, StringPool.BLANK, null,
513                                    null, 0, 0, null, false);
514                    }
515                    else {
516                            assetEntryLocalService.updateEntry(
517                                    userId, record.getGroupId(), record.getCreateDate(),
518                                    record.getModifiedDate(), DDLRecordConstants.getClassName(),
519                                    record.getRecordId(), record.getUuid(), 0, assetCategoryIds,
520                                    assetTagNames, visible, null, null, null,
521                                    ContentTypes.TEXT_HTML, title, null, StringPool.BLANK, null,
522                                    null, 0, 0, null, false);
523                    }
524            }
525    
526            @Indexable(type = IndexableType.REINDEX)
527            @Override
528            public DDLRecord updateRecord(
529                            long userId, long recordId, boolean majorVersion, int displayIndex,
530                            Fields fields, boolean mergeFields, ServiceContext serviceContext)
531                    throws PortalException {
532    
533                    // Record
534    
535                    User user = userPersistence.findByPrimaryKey(userId);
536    
537                    DDLRecord record = ddlRecordPersistence.findByPrimaryKey(recordId);
538    
539                    record.setModifiedDate(serviceContext.getModifiedDate(null));
540    
541                    ddlRecordPersistence.update(record);
542    
543                    // Record version
544    
545                    DDLRecordVersion recordVersion = record.getLatestRecordVersion();
546    
547                    if (recordVersion.isApproved()) {
548                            DDLRecordSet recordSet = record.getRecordSet();
549    
550                            if (mergeFields) {
551                                    Fields existingFields = StorageEngineUtil.getFields(
552                                            recordVersion.getDDMStorageId());
553    
554                                    fields = DDMUtil.mergeFields(fields, existingFields);
555                            }
556    
557                            long ddmStorageId = StorageEngineUtil.create(
558                                    recordSet.getCompanyId(), recordSet.getDDMStructureId(), fields,
559                                    serviceContext);
560                            String version = getNextVersion(
561                                    recordVersion.getVersion(), majorVersion,
562                                    serviceContext.getWorkflowAction());
563    
564                            recordVersion = addRecordVersion(
565                                    user, record, ddmStorageId, version, displayIndex,
566                                    WorkflowConstants.STATUS_DRAFT);
567                    }
568                    else {
569                            StorageEngineUtil.update(
570                                    recordVersion.getDDMStorageId(), fields, mergeFields,
571                                    serviceContext);
572    
573                            String version = recordVersion.getVersion();
574    
575                            updateRecordVersion(
576                                    user, recordVersion, version, displayIndex,
577                                    recordVersion.getStatus(), serviceContext);
578                    }
579    
580                    if (isKeepRecordVersionLabel(
581                                    record.getRecordVersion(), recordVersion, serviceContext)) {
582    
583                            ddlRecordVersionPersistence.remove(recordVersion);
584    
585                            // Dynamic data mapping storage
586    
587                            StorageEngineUtil.deleteByClass(recordVersion.getDDMStorageId());
588    
589                            return record;
590                    }
591    
592                    // Workflow
593    
594                    WorkflowHandlerRegistryUtil.startWorkflowInstance(
595                            user.getCompanyId(), record.getGroupId(), userId,
596                            DDLRecord.class.getName(), recordVersion.getRecordVersionId(),
597                            recordVersion, serviceContext);
598    
599                    return record;
600            }
601    
602            @Override
603            public DDLRecord updateRecord(
604                            long userId, long recordId, int displayIndex,
605                            Map<String, Serializable> fieldsMap, boolean mergeFields,
606                            ServiceContext serviceContext)
607                    throws PortalException {
608    
609                    DDLRecord record = ddlRecordPersistence.findByPrimaryKey(recordId);
610    
611                    Fields oldFields = record.getFields();
612    
613                    DDLRecordSet recordSet = record.getRecordSet();
614    
615                    DDMStructure ddmStructure = recordSet.getDDMStructure();
616    
617                    Fields fields = toFields(
618                            ddmStructure.getStructureId(), fieldsMap,
619                            serviceContext.getLocale(), oldFields.getDefaultLocale(), false);
620    
621                    return ddlRecordLocalService.updateRecord(
622                            userId, recordId, false, displayIndex, fields, mergeFields,
623                            serviceContext);
624            }
625    
626            @Indexable(type = IndexableType.REINDEX)
627            @Override
628            public DDLRecord updateStatus(
629                            long userId, long recordVersionId, int status,
630                            ServiceContext serviceContext)
631                    throws PortalException {
632    
633                    // Record version
634    
635                    User user = userPersistence.findByPrimaryKey(userId);
636    
637                    DDLRecordVersion recordVersion =
638                            ddlRecordVersionPersistence.findByPrimaryKey(recordVersionId);
639    
640                    recordVersion.setStatus(status);
641                    recordVersion.setStatusByUserId(user.getUserId());
642                    recordVersion.setStatusByUserName(user.getFullName());
643                    recordVersion.setStatusDate(new Date());
644    
645                    ddlRecordVersionPersistence.update(recordVersion);
646    
647                    // Record
648    
649                    DDLRecord record = ddlRecordPersistence.findByPrimaryKey(
650                            recordVersion.getRecordId());
651    
652                    if (status == WorkflowConstants.STATUS_APPROVED) {
653                            if (DLUtil.compareVersions(
654                                            record.getVersion(), recordVersion.getVersion()) <= 0) {
655    
656                                    record.setDDMStorageId(recordVersion.getDDMStorageId());
657                                    record.setVersion(recordVersion.getVersion());
658                                    record.setRecordSetId(recordVersion.getRecordSetId());
659                                    record.setDisplayIndex(recordVersion.getDisplayIndex());
660                                    record.setVersion(recordVersion.getVersion());
661                                    record.setVersionUserId(recordVersion.getUserId());
662                                    record.setVersionUserName(recordVersion.getUserName());
663                                    record.setModifiedDate(recordVersion.getCreateDate());
664    
665                                    ddlRecordPersistence.update(record);
666                            }
667                    }
668                    else {
669                            if (Validator.equals(
670                                            record.getVersion(), recordVersion.getVersion())) {
671    
672                                    String newVersion = DDLRecordConstants.VERSION_DEFAULT;
673    
674                                    List<DDLRecordVersion> approvedRecordVersions =
675                                            ddlRecordVersionPersistence.findByR_S(
676                                                    record.getRecordId(),
677                                                    WorkflowConstants.STATUS_APPROVED);
678    
679                                    if (!approvedRecordVersions.isEmpty()) {
680                                            newVersion = approvedRecordVersions.get(0).getVersion();
681                                    }
682    
683                                    record.setVersion(newVersion);
684    
685                                    ddlRecordPersistence.update(record);
686                            }
687                    }
688    
689                    return record;
690            }
691    
692            protected DDLRecordVersion addRecordVersion(
693                    User user, DDLRecord record, long ddmStorageId, String version,
694                    int displayIndex, int status) {
695    
696                    long recordVersionId = counterLocalService.increment();
697    
698                    DDLRecordVersion recordVersion = ddlRecordVersionPersistence.create(
699                            recordVersionId);
700    
701                    recordVersion.setGroupId(record.getGroupId());
702                    recordVersion.setCompanyId(record.getCompanyId());
703                    recordVersion.setUserId(user.getUserId());
704                    recordVersion.setUserName(user.getFullName());
705                    recordVersion.setCreateDate(record.getModifiedDate());
706                    recordVersion.setDDMStorageId(ddmStorageId);
707                    recordVersion.setRecordSetId(record.getRecordSetId());
708                    recordVersion.setRecordId(record.getRecordId());
709                    recordVersion.setVersion(version);
710                    recordVersion.setDisplayIndex(displayIndex);
711                    recordVersion.setStatus(status);
712                    recordVersion.setStatusByUserId(user.getUserId());
713                    recordVersion.setStatusByUserName(user.getFullName());
714                    recordVersion.setStatusDate(record.getModifiedDate());
715    
716                    ddlRecordVersionPersistence.update(recordVersion);
717    
718                    return recordVersion;
719            }
720    
721            protected String getNextVersion(
722                    String version, boolean majorVersion, int workflowAction) {
723    
724                    if (workflowAction == WorkflowConstants.ACTION_SAVE_DRAFT) {
725                            majorVersion = false;
726                    }
727    
728                    int[] versionParts = StringUtil.split(version, StringPool.PERIOD, 0);
729    
730                    if (majorVersion) {
731                            versionParts[0]++;
732                            versionParts[1] = 0;
733                    }
734                    else {
735                            versionParts[1]++;
736                    }
737    
738                    return versionParts[0] + StringPool.PERIOD + versionParts[1];
739            }
740    
741            /**
742             * @see com.liferay.portlet.documentlibrary.service.impl.DLFileEntryLocalServiceImpl#isKeepFileVersionLabel(
743             *      DLFileEntry, DLFileVersion, DLFileVersion, ServiceContext)
744             */
745            protected boolean isKeepRecordVersionLabel(
746                            DDLRecordVersion lastRecordVersion,
747                            DDLRecordVersion latestRecordVersion, ServiceContext serviceContext)
748                    throws PortalException {
749    
750                    if (Validator.equals(serviceContext.getCommand(), Constants.REVERT)) {
751                            return false;
752                    }
753    
754                    if (serviceContext.getWorkflowAction() ==
755                                    WorkflowConstants.ACTION_SAVE_DRAFT) {
756    
757                            return false;
758                    }
759    
760                    if (Validator.equals(
761                                    lastRecordVersion.getVersion(),
762                                    latestRecordVersion.getVersion())) {
763    
764                            return false;
765                    }
766    
767                    Fields lastFields = StorageEngineUtil.getFields(
768                            lastRecordVersion.getDDMStorageId());
769                    Fields latestFields = StorageEngineUtil.getFields(
770                            latestRecordVersion.getDDMStorageId());
771    
772                    if (!lastFields.equals(latestFields, false)) {
773                            return false;
774                    }
775    
776                    ExpandoBridge lastExpandoBridge = lastRecordVersion.getExpandoBridge();
777                    ExpandoBridge latestExpandoBridge =
778                            latestRecordVersion.getExpandoBridge();
779    
780                    Map<String, Serializable> lastAttributes =
781                            lastExpandoBridge.getAttributes();
782                    Map<String, Serializable> latestAttributes =
783                            latestExpandoBridge.getAttributes();
784    
785                    if (!lastAttributes.equals(latestAttributes)) {
786                            return false;
787                    }
788    
789                    return true;
790            }
791    
792            protected Fields toFields(
793                    long ddmStructureId, Map<String, Serializable> fieldsMap,
794                    Locale locale, Locale defaultLocale, boolean create) {
795    
796                    Fields fields = new Fields();
797    
798                    for (Map.Entry<String, Serializable> entry : fieldsMap.entrySet()) {
799                            Field field = new Field();
800    
801                            field.setDDMStructureId(ddmStructureId);
802                            field.setName(entry.getKey());
803                            field.addValue(locale, String.valueOf(entry.getValue()));
804    
805                            if (create && !locale.equals(defaultLocale)) {
806                                    field.addValue(defaultLocale, String.valueOf(entry.getValue()));
807                            }
808    
809                            field.setDefaultLocale(defaultLocale);
810    
811                            fields.put(field);
812                    }
813    
814                    return fields;
815            }
816    
817            protected void updateRecordVersion(
818                    User user, DDLRecordVersion recordVersion, String version,
819                    int displayIndex, int status, ServiceContext serviceContext) {
820    
821                    recordVersion.setUserId(user.getUserId());
822                    recordVersion.setUserName(user.getFullName());
823                    recordVersion.setVersion(version);
824                    recordVersion.setDisplayIndex(displayIndex);
825                    recordVersion.setStatus(status);
826                    recordVersion.setStatusByUserId(user.getUserId());
827                    recordVersion.setStatusByUserName(user.getFullName());
828                    recordVersion.setStatusDate(serviceContext.getModifiedDate(null));
829    
830                    ddlRecordVersionPersistence.update(recordVersion);
831            }
832    
833    }