001    /**
002     * Copyright (c) 2000-2013 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.Hits;
021    import com.liferay.portal.kernel.search.Indexer;
022    import com.liferay.portal.kernel.search.IndexerRegistryUtil;
023    import com.liferay.portal.kernel.search.SearchContext;
024    import com.liferay.portal.kernel.util.ContentTypes;
025    import com.liferay.portal.kernel.util.GetterUtil;
026    import com.liferay.portal.kernel.util.ListUtil;
027    import com.liferay.portal.kernel.util.OrderByComparator;
028    import com.liferay.portal.kernel.util.StringPool;
029    import com.liferay.portal.kernel.util.StringUtil;
030    import com.liferay.portal.kernel.util.Validator;
031    import com.liferay.portal.kernel.workflow.WorkflowConstants;
032    import com.liferay.portal.kernel.workflow.WorkflowHandlerRegistryUtil;
033    import com.liferay.portal.model.User;
034    import com.liferay.portal.service.ServiceContext;
035    import com.liferay.portlet.documentlibrary.util.DLUtil;
036    import com.liferay.portlet.dynamicdatalists.NoSuchRecordVersionException;
037    import com.liferay.portlet.dynamicdatalists.model.DDLRecord;
038    import com.liferay.portlet.dynamicdatalists.model.DDLRecordConstants;
039    import com.liferay.portlet.dynamicdatalists.model.DDLRecordSet;
040    import com.liferay.portlet.dynamicdatalists.model.DDLRecordVersion;
041    import com.liferay.portlet.dynamicdatalists.service.base.DDLRecordLocalServiceBaseImpl;
042    import com.liferay.portlet.dynamicdatalists.util.comparator.DDLRecordVersionVersionComparator;
043    import com.liferay.portlet.dynamicdatamapping.model.DDMStructure;
044    import com.liferay.portlet.dynamicdatamapping.storage.Field;
045    import com.liferay.portlet.dynamicdatamapping.storage.Fields;
046    import com.liferay.portlet.dynamicdatamapping.storage.StorageEngineUtil;
047    import com.liferay.portlet.dynamicdatamapping.util.DDMUtil;
048    
049    import java.io.Serializable;
050    
051    import java.util.Collections;
052    import java.util.Date;
053    import java.util.List;
054    import java.util.Locale;
055    import java.util.Map;
056    
057    /**
058     * Provides the local service for accessing, adding, deleting, and updating
059     * dynamic data list (DDL) records.
060     *
061     * @author Marcellus Tavares
062     * @author Eduardo Lundgren
063     */
064    public class DDLRecordLocalServiceImpl extends DDLRecordLocalServiceBaseImpl {
065    
066            @Override
067            public DDLRecord addRecord(
068                            long userId, long groupId, long recordSetId, int displayIndex,
069                            Fields fields, ServiceContext serviceContext)
070                    throws PortalException, SystemException {
071    
072                    // Record
073    
074                    User user = userPersistence.findByPrimaryKey(userId);
075                    Date now = new Date();
076    
077                    DDLRecordSet recordSet = ddlRecordSetPersistence.findByPrimaryKey(
078                            recordSetId);
079    
080                    long recordId = counterLocalService.increment();
081    
082                    DDLRecord record = ddlRecordPersistence.create(recordId);
083    
084                    record.setUuid(serviceContext.getUuid());
085                    record.setGroupId(groupId);
086                    record.setCompanyId(user.getCompanyId());
087                    record.setUserId(user.getUserId());
088                    record.setUserName(user.getFullName());
089                    record.setVersionUserId(user.getUserId());
090                    record.setVersionUserName(user.getFullName());
091                    record.setCreateDate(serviceContext.getCreateDate(now));
092                    record.setModifiedDate(serviceContext.getModifiedDate(now));
093    
094                    long ddmStorageId = StorageEngineUtil.create(
095                            recordSet.getCompanyId(), recordSet.getDDMStructureId(), fields,
096                            serviceContext);
097    
098                    record.setDDMStorageId(ddmStorageId);
099    
100                    record.setRecordSetId(recordSetId);
101                    record.setVersion(DDLRecordConstants.VERSION_DEFAULT);
102                    record.setDisplayIndex(displayIndex);
103    
104                    ddlRecordPersistence.update(record);
105    
106                    // Record version
107    
108                    DDLRecordVersion recordVersion = addRecordVersion(
109                            user, record, ddmStorageId, DDLRecordConstants.VERSION_DEFAULT,
110                            displayIndex, WorkflowConstants.STATUS_DRAFT);
111    
112                    // Asset
113    
114                    Locale locale = serviceContext.getLocale();
115    
116                    updateAsset(
117                            userId, record, recordVersion, serviceContext.getAssetCategoryIds(),
118                            serviceContext.getAssetTagNames(), locale);
119    
120                    // Workflow
121    
122                    WorkflowHandlerRegistryUtil.startWorkflowInstance(
123                            user.getCompanyId(), groupId, userId, DDLRecord.class.getName(),
124                            recordVersion.getRecordVersionId(), recordVersion, serviceContext);
125    
126                    return record;
127            }
128    
129            @Override
130            public DDLRecord addRecord(
131                            long userId, long groupId, long recordSetId, int displayIndex,
132                            Map<String, Serializable> fieldsMap, ServiceContext serviceContext)
133                    throws PortalException, SystemException {
134    
135                    DDLRecordSet recordSet = ddlRecordSetPersistence.findByPrimaryKey(
136                            recordSetId);
137    
138                    DDMStructure ddmStructure = recordSet.getDDMStructure();
139    
140                    Fields fields = toFields(ddmStructure.getStructureId(), fieldsMap);
141    
142                    return addRecord(
143                            userId, groupId, recordSetId, displayIndex, fields, serviceContext);
144            }
145    
146            @Override
147            public void deleteRecord(DDLRecord record)
148                    throws PortalException, SystemException {
149    
150                    // Record
151    
152                    ddlRecordPersistence.remove(record);
153    
154                    // Record Versions
155    
156                    List<DDLRecordVersion> recordVersions =
157                            ddlRecordVersionPersistence.findByRecordId(record.getRecordId());
158    
159                    for (DDLRecordVersion recordVersion : recordVersions) {
160                            ddlRecordVersionPersistence.remove(recordVersion);
161    
162                            // Dynamic data mapping storage
163    
164                            StorageEngineUtil.deleteByClass(recordVersion.getDDMStorageId());
165    
166                            // Workflow
167    
168                            workflowInstanceLinkLocalService.deleteWorkflowInstanceLinks(
169                                    record.getCompanyId(), record.getGroupId(),
170                                    DDLRecord.class.getName(), recordVersion.getPrimaryKey());
171                    }
172    
173                    // Indexer
174    
175                    Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
176                            DDLRecord.class);
177    
178                    indexer.delete(record);
179            }
180    
181            @Override
182            public void deleteRecord(long recordId)
183                    throws PortalException, SystemException {
184    
185                    DDLRecord record = ddlRecordPersistence.findByPrimaryKey(recordId);
186    
187                    deleteRecord(record);
188            }
189    
190            @Override
191            public DDLRecord deleteRecordLocale(
192                            long recordId, Locale locale, ServiceContext serviceContext)
193                    throws PortalException, SystemException {
194    
195                    DDLRecord record = ddlRecordPersistence.findByPrimaryKey(recordId);
196    
197                    Fields fields = StorageEngineUtil.getFields(record.getDDMStorageId());
198    
199                    for (Field field : fields) {
200                            Map<Locale, List<Serializable>> valuesMap = field.getValuesMap();
201    
202                            valuesMap.remove(locale);
203                    }
204    
205                    return updateRecord(
206                            serviceContext.getUserId(), recordId, false,
207                            DDLRecordConstants.DISPLAY_INDEX_DEFAULT, fields, false,
208                            serviceContext);
209            }
210    
211            @Override
212            public void deleteRecords(long recordSetId)
213                    throws PortalException, SystemException {
214    
215                    List<DDLRecord> records = ddlRecordPersistence.findByRecordSetId(
216                            recordSetId);
217    
218                    for (DDLRecord record : records) {
219                            deleteRecord(record);
220                    }
221            }
222    
223            @Override
224            public DDLRecord fetchRecord(long recordId) throws SystemException {
225                    return ddlRecordPersistence.fetchByPrimaryKey(recordId);
226            }
227    
228            @Override
229            public List<DDLRecord> getCompanyRecords(
230                            long companyId, int status, int scope, int start, int end,
231                            OrderByComparator orderByComparator)
232                    throws SystemException {
233    
234                    return ddlRecordFinder.findByC_S_S(
235                            companyId, status, scope, start, end, orderByComparator);
236            }
237    
238            /**
239             * @deprecated As of 6.2.0, replaced by {@link #getCompanyRecords(long, int,
240             *             int, int, int, OrderByComparator)}
241             */
242            @Override
243            public List<DDLRecord> getCompanyRecords(
244                            long companyId, int scope, int start, int end,
245                            OrderByComparator orderByComparator)
246                    throws SystemException {
247    
248                    return getCompanyRecords(
249                            companyId, WorkflowConstants.STATUS_ANY, scope, start, end,
250                            orderByComparator);
251            }
252    
253            /**
254             * @deprecated As of 6.2.0, replaced by {@link #getCompanyRecordsCount(long,
255             *             int, int)}
256             */
257            @Override
258            public int getCompanyRecordsCount(long companyId, int scope)
259                    throws SystemException {
260    
261                    return getCompanyRecordsCount(
262                            companyId, WorkflowConstants.STATUS_ANY, scope);
263            }
264    
265            @Override
266            public int getCompanyRecordsCount(long companyId, int status, int scope)
267                    throws SystemException {
268    
269                    return ddlRecordFinder.countByC_S_S(companyId, status, scope);
270            }
271    
272            @Override
273            public DDLRecordVersion getLatestRecordVersion(long recordId)
274                    throws PortalException, SystemException {
275    
276                    List<DDLRecordVersion> recordVersions =
277                            ddlRecordVersionPersistence.findByRecordId(recordId);
278    
279                    if (recordVersions.isEmpty()) {
280                            throw new NoSuchRecordVersionException(
281                                    "No record versions found for recordId " + recordId);
282                    }
283    
284                    recordVersions = ListUtil.copy(recordVersions);
285    
286                    Collections.sort(
287                            recordVersions, new DDLRecordVersionVersionComparator());
288    
289                    return recordVersions.get(0);
290            }
291    
292            @Override
293            public Long[] getMinAndMaxCompanyRecordIds(
294                            long companyId, int status, int scope)
295                    throws SystemException {
296    
297                    return ddlRecordFinder.findByC_S_S_MinAndMax(companyId, status, scope);
298            }
299    
300            @Override
301            public List<DDLRecord> getMinAndMaxCompanyRecords(
302                            long companyId, int status, int scope, long minRecordId,
303                            long maxRecordId)
304                    throws SystemException {
305    
306                    return ddlRecordFinder.findByC_S_S_MinAndMax(
307                            companyId, status, scope, minRecordId, maxRecordId);
308            }
309    
310            @Override
311            public DDLRecord getRecord(long recordId)
312                    throws PortalException, SystemException {
313    
314                    return ddlRecordPersistence.findByPrimaryKey(recordId);
315            }
316    
317            @Override
318            public List<DDLRecord> getRecords(long recordSetId) throws SystemException {
319                    return ddlRecordPersistence.findByRecordSetId(recordSetId);
320            }
321    
322            @Override
323            public List<DDLRecord> getRecords(
324                            long recordSetId, int status, int start, int end,
325                            OrderByComparator orderByComparator)
326                    throws SystemException {
327    
328                    return ddlRecordFinder.findByR_S(
329                            recordSetId, status, start, end, orderByComparator);
330            }
331    
332            @Override
333            public List<DDLRecord> getRecords(long recordSetId, long userId)
334                    throws SystemException {
335    
336                    return ddlRecordPersistence.findByR_U(recordSetId, userId);
337            }
338    
339            @Override
340            public int getRecordsCount(long recordSetId, int status)
341                    throws SystemException {
342    
343                    return ddlRecordFinder.countByR_S(recordSetId, status);
344            }
345    
346            @Override
347            public DDLRecordVersion getRecordVersion(long recordVersionId)
348                    throws PortalException, SystemException {
349    
350                    return ddlRecordVersionPersistence.findByPrimaryKey(recordVersionId);
351            }
352    
353            @Override
354            public DDLRecordVersion getRecordVersion(long recordId, String version)
355                    throws PortalException, SystemException {
356    
357                    return ddlRecordVersionPersistence.findByR_V(recordId, version);
358            }
359    
360            @Override
361            public List<DDLRecordVersion> getRecordVersions(
362                            long recordId, int start, int end,
363                            OrderByComparator orderByComparator)
364                    throws SystemException {
365    
366                    return ddlRecordVersionPersistence.findByRecordId(
367                            recordId, start, end, orderByComparator);
368            }
369    
370            @Override
371            public int getRecordVersionsCount(long recordId) throws SystemException {
372                    return ddlRecordVersionPersistence.countByRecordId(recordId);
373            }
374    
375            @Override
376            public void revertRecordVersion(
377                            long userId, long recordId, String version,
378                            ServiceContext serviceContext)
379                    throws PortalException, SystemException {
380    
381                    DDLRecordVersion recordVersion = getRecordVersion(recordId, version);
382    
383                    if (!recordVersion.isApproved()) {
384                            return;
385                    }
386    
387                    Fields fields = StorageEngineUtil.getFields(
388                            recordVersion.getDDMStorageId());
389    
390                    updateRecord(
391                            userId, recordId, true, recordVersion.getDisplayIndex(), fields,
392                            false, serviceContext);
393            }
394    
395            @Override
396            public Hits search(SearchContext searchContext) throws SystemException {
397                    try {
398                            Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
399                                    DDLRecord.class);
400    
401                            return indexer.search(searchContext);
402                    }
403                    catch (Exception e) {
404                            throw new SystemException(e);
405                    }
406            }
407    
408            @Override
409            public void updateAsset(
410                            long userId, DDLRecord record, DDLRecordVersion recordVersion,
411                            long[] assetCategoryIds, String[] assetTagNames, Locale locale)
412                    throws PortalException, SystemException {
413    
414                    boolean addDraftAssetEntry = false;
415    
416                    if ((recordVersion != null) && !recordVersion.isApproved()) {
417                            String version = recordVersion.getVersion();
418    
419                            if (!version.equals(DDLRecordConstants.VERSION_DEFAULT)) {
420                                    int approvedRecordVersionsCount =
421                                            ddlRecordVersionPersistence.countByR_S(
422                                                    record.getRecordId(),
423                                                    WorkflowConstants.STATUS_APPROVED);
424    
425                                    if (approvedRecordVersionsCount > 0) {
426                                            addDraftAssetEntry = true;
427                                    }
428                            }
429                    }
430    
431                    boolean visible = false;
432    
433                    if ((recordVersion != null) && !recordVersion.isApproved()) {
434                            visible = false;
435                    }
436    
437                    DDLRecordSet recordSet = record.getRecordSet();
438    
439                    DDMStructure ddmStructure = recordSet.getDDMStructure();
440    
441                    String ddmStructureName = ddmStructure.getName(locale);
442    
443                    String recordSetName = recordSet.getName(locale);
444    
445                    String title = LanguageUtil.format(
446                            locale, "new-x-for-list-x",
447                            new Object[] {ddmStructureName, recordSetName});
448    
449                    if (addDraftAssetEntry) {
450                            assetEntryLocalService.updateEntry(
451                                    userId, record.getGroupId(), record.getCreateDate(),
452                                    record.getModifiedDate(), DDLRecordConstants.getClassName(),
453                                    recordVersion.getRecordVersionId(), record.getUuid(), 0,
454                                    assetCategoryIds, assetTagNames, false, null, null, null,
455                                    ContentTypes.TEXT_HTML, title, null, StringPool.BLANK, null,
456                                    null, 0, 0, null, false);
457                    }
458                    else {
459                            assetEntryLocalService.updateEntry(
460                                    userId, record.getGroupId(), record.getCreateDate(),
461                                    record.getModifiedDate(), DDLRecordConstants.getClassName(),
462                                    record.getRecordId(), record.getUuid(), 0, assetCategoryIds,
463                                    assetTagNames, visible, null, null, null,
464                                    ContentTypes.TEXT_HTML, title, null, StringPool.BLANK, null,
465                                    null, 0, 0, null, false);
466                    }
467            }
468    
469            @Override
470            public DDLRecord updateRecord(
471                            long userId, long recordId, boolean majorVersion, int displayIndex,
472                            Fields fields, boolean mergeFields, ServiceContext serviceContext)
473                    throws PortalException, SystemException {
474    
475                    // Record
476    
477                    User user = userPersistence.findByPrimaryKey(userId);
478    
479                    DDLRecord record = ddlRecordPersistence.findByPrimaryKey(recordId);
480    
481                    record.setModifiedDate(serviceContext.getModifiedDate(null));
482    
483                    ddlRecordPersistence.update(record);
484    
485                    // Record version
486    
487                    DDLRecordVersion recordVersion = record.getLatestRecordVersion();
488    
489                    if (recordVersion.isApproved()) {
490                            DDLRecordSet recordSet = record.getRecordSet();
491    
492                            if (mergeFields) {
493                                    Fields existingFields = StorageEngineUtil.getFields(
494                                            recordVersion.getDDMStorageId());
495    
496                                    fields = DDMUtil.mergeFields(fields, existingFields);
497                            }
498    
499                            long ddmStorageId = StorageEngineUtil.create(
500                                    recordSet.getCompanyId(), recordSet.getDDMStructureId(), fields,
501                                    serviceContext);
502                            String version = getNextVersion(
503                                    recordVersion.getVersion(), majorVersion,
504                                    serviceContext.getWorkflowAction());
505    
506                            recordVersion = addRecordVersion(
507                                    user, record, ddmStorageId, version, displayIndex,
508                                    WorkflowConstants.STATUS_DRAFT);
509                    }
510                    else {
511                            StorageEngineUtil.update(
512                                    recordVersion.getDDMStorageId(), fields, mergeFields,
513                                    serviceContext);
514    
515                            String version = recordVersion.getVersion();
516    
517                            updateRecordVersion(
518                                    user, recordVersion, version, displayIndex,
519                                    recordVersion.getStatus(), serviceContext);
520                    }
521    
522                    // Workflow
523    
524                    WorkflowHandlerRegistryUtil.startWorkflowInstance(
525                            user.getCompanyId(), record.getGroupId(), userId,
526                            DDLRecord.class.getName(), recordVersion.getRecordVersionId(),
527                            recordVersion, serviceContext);
528    
529                    return record;
530            }
531    
532            @Override
533            public DDLRecord updateRecord(
534                            long userId, long recordId, int displayIndex,
535                            Map<String, Serializable> fieldsMap, boolean mergeFields,
536                            ServiceContext serviceContext)
537                    throws PortalException, SystemException {
538    
539                    DDLRecord record = ddlRecordPersistence.findByPrimaryKey(recordId);
540    
541                    DDLRecordSet recordSet = record.getRecordSet();
542    
543                    DDMStructure ddmStructure = recordSet.getDDMStructure();
544    
545                    Fields fields = toFields(ddmStructure.getStructureId(), fieldsMap);
546    
547                    return updateRecord(
548                            userId, recordId, false, displayIndex, fields, mergeFields,
549                            serviceContext);
550            }
551    
552            @Override
553            public DDLRecord updateStatus(
554                            long userId, long recordVersionId, int status,
555                            ServiceContext serviceContext)
556                    throws PortalException, SystemException {
557    
558                    // Record version
559    
560                    User user = userPersistence.findByPrimaryKey(userId);
561    
562                    DDLRecordVersion recordVersion =
563                            ddlRecordVersionPersistence.findByPrimaryKey(recordVersionId);
564    
565                    recordVersion.setStatus(status);
566                    recordVersion.setStatusByUserId(user.getUserId());
567                    recordVersion.setStatusByUserName(user.getFullName());
568                    recordVersion.setStatusDate(new Date());
569    
570                    ddlRecordVersionPersistence.update(recordVersion);
571    
572                    // Record
573    
574                    DDLRecord record = ddlRecordPersistence.findByPrimaryKey(
575                            recordVersion.getRecordId());
576    
577                    if (status == WorkflowConstants.STATUS_APPROVED) {
578                            if (DLUtil.compareVersions(
579                                            record.getVersion(), recordVersion.getVersion()) <= 0) {
580    
581                                    record.setDDMStorageId(recordVersion.getDDMStorageId());
582                                    record.setVersion(recordVersion.getVersion());
583                                    record.setRecordSetId(recordVersion.getRecordSetId());
584                                    record.setDisplayIndex(recordVersion.getDisplayIndex());
585                                    record.setVersion(recordVersion.getVersion());
586                                    record.setVersionUserId(recordVersion.getUserId());
587                                    record.setVersionUserName(recordVersion.getUserName());
588                                    record.setModifiedDate(recordVersion.getCreateDate());
589    
590                                    ddlRecordPersistence.update(record);
591                            }
592                    }
593                    else {
594                            if (Validator.equals(
595                                            record.getVersion(), recordVersion.getVersion())) {
596    
597                                    String newVersion = DDLRecordConstants.VERSION_DEFAULT;
598    
599                                    List<DDLRecordVersion> approvedRecordVersions =
600                                            ddlRecordVersionPersistence.findByR_S(
601                                                    record.getRecordId(),
602                                                    WorkflowConstants.STATUS_APPROVED);
603    
604                                    if (!approvedRecordVersions.isEmpty()) {
605                                            newVersion = approvedRecordVersions.get(0).getVersion();
606                                    }
607    
608                                    record.setVersion(newVersion);
609    
610                                    ddlRecordPersistence.update(record);
611                            }
612    
613                            // Indexer
614    
615                            if (Validator.equals(
616                                            recordVersion.getVersion(),
617                                            DDLRecordConstants.VERSION_DEFAULT)) {
618    
619                                    Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
620                                            DDLRecord.class);
621    
622                                    indexer.delete(record);
623                            }
624                    }
625    
626                    // Indexer
627    
628                    if (status == WorkflowConstants.STATUS_APPROVED) {
629                            Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
630                                    DDLRecord.class);
631    
632                            indexer.reindex(record);
633                    }
634    
635                    return record;
636            }
637    
638            protected DDLRecordVersion addRecordVersion(
639                            User user, DDLRecord record, long ddmStorageId, String version,
640                            int displayIndex, int status)
641                    throws SystemException {
642    
643                    long recordVersionId = counterLocalService.increment();
644    
645                    DDLRecordVersion recordVersion = ddlRecordVersionPersistence.create(
646                            recordVersionId);
647    
648                    recordVersion.setGroupId(record.getGroupId());
649                    recordVersion.setCompanyId(record.getCompanyId());
650    
651                    long versionUserId = record.getVersionUserId();
652    
653                    if (versionUserId <= 0) {
654                            versionUserId = record.getUserId();
655                    }
656    
657                    recordVersion.setUserId(versionUserId);
658    
659                    String versionUserName = GetterUtil.getString(
660                            record.getVersionUserName(), record.getUserName());
661    
662                    recordVersion.setUserName(versionUserName);
663    
664                    recordVersion.setCreateDate(record.getModifiedDate());
665                    recordVersion.setDDMStorageId(ddmStorageId);
666                    recordVersion.setRecordSetId(record.getRecordSetId());
667                    recordVersion.setRecordId(record.getRecordId());
668                    recordVersion.setVersion(version);
669                    recordVersion.setDisplayIndex(displayIndex);
670                    recordVersion.setStatus(status);
671                    recordVersion.setStatusByUserId(user.getUserId());
672                    recordVersion.setStatusByUserName(user.getFullName());
673                    recordVersion.setStatusDate(record.getModifiedDate());
674    
675                    ddlRecordVersionPersistence.update(recordVersion);
676    
677                    return recordVersion;
678            }
679    
680            protected String getNextVersion(
681                    String version, boolean majorVersion, int workflowAction) {
682    
683                    if (workflowAction == WorkflowConstants.ACTION_SAVE_DRAFT) {
684                            majorVersion = false;
685                    }
686    
687                    int[] versionParts = StringUtil.split(version, StringPool.PERIOD, 0);
688    
689                    if (majorVersion) {
690                            versionParts[0]++;
691                            versionParts[1] = 0;
692                    }
693                    else {
694                            versionParts[1]++;
695                    }
696    
697                    return versionParts[0] + StringPool.PERIOD + versionParts[1];
698            }
699    
700            protected Fields toFields(
701                    long ddmStructureId, Map<String, Serializable> fieldsMap) {
702    
703                    Fields fields = new Fields();
704    
705                    for (String name : fieldsMap.keySet()) {
706                            String value = String.valueOf(fieldsMap.get(name));
707    
708                            Field field = new Field(ddmStructureId, name, value);
709    
710                            fields.put(field);
711                    }
712    
713                    return fields;
714            }
715    
716            protected void updateRecordVersion(
717                            User user, DDLRecordVersion recordVersion, String version,
718                            int displayIndex, int status, ServiceContext serviceContext)
719                    throws SystemException {
720    
721                    recordVersion.setVersion(version);
722                    recordVersion.setDisplayIndex(displayIndex);
723                    recordVersion.setStatus(status);
724                    recordVersion.setStatusByUserId(user.getUserId());
725                    recordVersion.setStatusByUserName(user.getFullName());
726                    recordVersion.setStatusDate(serviceContext.getModifiedDate(null));
727    
728                    ddlRecordVersionPersistence.update(recordVersion);
729            }
730    
731    }