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