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.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            @Indexable(type = IndexableType.REINDEX)
474            @Override
475            public DDLRecord updateRecord(
476                            long userId, long recordId, boolean majorVersion, int displayIndex,
477                            Fields fields, boolean mergeFields, ServiceContext serviceContext)
478                    throws PortalException, SystemException {
479    
480                    // Record
481    
482                    User user = userPersistence.findByPrimaryKey(userId);
483    
484                    DDLRecord record = ddlRecordPersistence.findByPrimaryKey(recordId);
485    
486                    record.setModifiedDate(serviceContext.getModifiedDate(null));
487    
488                    ddlRecordPersistence.update(record);
489    
490                    // Record version
491    
492                    DDLRecordVersion recordVersion = record.getLatestRecordVersion();
493    
494                    if (recordVersion.isApproved()) {
495                            DDLRecordSet recordSet = record.getRecordSet();
496    
497                            if (mergeFields) {
498                                    Fields existingFields = StorageEngineUtil.getFields(
499                                            recordVersion.getDDMStorageId());
500    
501                                    fields = DDMUtil.mergeFields(fields, existingFields);
502                            }
503    
504                            long ddmStorageId = StorageEngineUtil.create(
505                                    recordSet.getCompanyId(), recordSet.getDDMStructureId(), fields,
506                                    serviceContext);
507                            String version = getNextVersion(
508                                    recordVersion.getVersion(), majorVersion,
509                                    serviceContext.getWorkflowAction());
510    
511                            recordVersion = addRecordVersion(
512                                    user, record, ddmStorageId, version, displayIndex,
513                                    WorkflowConstants.STATUS_DRAFT);
514                    }
515                    else {
516                            StorageEngineUtil.update(
517                                    recordVersion.getDDMStorageId(), fields, mergeFields,
518                                    serviceContext);
519    
520                            String version = recordVersion.getVersion();
521    
522                            updateRecordVersion(
523                                    user, recordVersion, version, displayIndex,
524                                    recordVersion.getStatus(), serviceContext);
525                    }
526    
527                    // Workflow
528    
529                    WorkflowHandlerRegistryUtil.startWorkflowInstance(
530                            user.getCompanyId(), record.getGroupId(), userId,
531                            DDLRecord.class.getName(), recordVersion.getRecordVersionId(),
532                            recordVersion, serviceContext);
533    
534                    return record;
535            }
536    
537            @Override
538            public DDLRecord updateRecord(
539                            long userId, long recordId, int displayIndex,
540                            Map<String, Serializable> fieldsMap, boolean mergeFields,
541                            ServiceContext serviceContext)
542                    throws PortalException, SystemException {
543    
544                    DDLRecord record = ddlRecordPersistence.findByPrimaryKey(recordId);
545    
546                    DDLRecordSet recordSet = record.getRecordSet();
547    
548                    DDMStructure ddmStructure = recordSet.getDDMStructure();
549    
550                    Fields fields = toFields(ddmStructure.getStructureId(), fieldsMap);
551    
552                    return ddlRecordLocalService.updateRecord(
553                            userId, recordId, false, displayIndex, fields, mergeFields,
554                            serviceContext);
555            }
556    
557            @Indexable(type = IndexableType.REINDEX)
558            @Override
559            public DDLRecord updateStatus(
560                            long userId, long recordVersionId, int status,
561                            ServiceContext serviceContext)
562                    throws PortalException, SystemException {
563    
564                    // Record version
565    
566                    User user = userPersistence.findByPrimaryKey(userId);
567    
568                    DDLRecordVersion recordVersion =
569                            ddlRecordVersionPersistence.findByPrimaryKey(recordVersionId);
570    
571                    recordVersion.setStatus(status);
572                    recordVersion.setStatusByUserId(user.getUserId());
573                    recordVersion.setStatusByUserName(user.getFullName());
574                    recordVersion.setStatusDate(new Date());
575    
576                    ddlRecordVersionPersistence.update(recordVersion);
577    
578                    // Record
579    
580                    DDLRecord record = ddlRecordPersistence.findByPrimaryKey(
581                            recordVersion.getRecordId());
582    
583                    if (status == WorkflowConstants.STATUS_APPROVED) {
584                            if (DLUtil.compareVersions(
585                                            record.getVersion(), recordVersion.getVersion()) <= 0) {
586    
587                                    record.setDDMStorageId(recordVersion.getDDMStorageId());
588                                    record.setVersion(recordVersion.getVersion());
589                                    record.setRecordSetId(recordVersion.getRecordSetId());
590                                    record.setDisplayIndex(recordVersion.getDisplayIndex());
591                                    record.setVersion(recordVersion.getVersion());
592                                    record.setVersionUserId(recordVersion.getUserId());
593                                    record.setVersionUserName(recordVersion.getUserName());
594                                    record.setModifiedDate(recordVersion.getCreateDate());
595    
596                                    ddlRecordPersistence.update(record);
597                            }
598                    }
599                    else {
600                            if (Validator.equals(
601                                            record.getVersion(), recordVersion.getVersion())) {
602    
603                                    String newVersion = DDLRecordConstants.VERSION_DEFAULT;
604    
605                                    List<DDLRecordVersion> approvedRecordVersions =
606                                            ddlRecordVersionPersistence.findByR_S(
607                                                    record.getRecordId(),
608                                                    WorkflowConstants.STATUS_APPROVED);
609    
610                                    if (!approvedRecordVersions.isEmpty()) {
611                                            newVersion = approvedRecordVersions.get(0).getVersion();
612                                    }
613    
614                                    record.setVersion(newVersion);
615    
616                                    ddlRecordPersistence.update(record);
617                            }
618                    }
619    
620                    return record;
621            }
622    
623            protected DDLRecordVersion addRecordVersion(
624                            User user, DDLRecord record, long ddmStorageId, String version,
625                            int displayIndex, int status)
626                    throws SystemException {
627    
628                    long recordVersionId = counterLocalService.increment();
629    
630                    DDLRecordVersion recordVersion = ddlRecordVersionPersistence.create(
631                            recordVersionId);
632    
633                    recordVersion.setGroupId(record.getGroupId());
634                    recordVersion.setCompanyId(record.getCompanyId());
635                    recordVersion.setUserId(user.getUserId());
636                    recordVersion.setUserName(user.getFullName());
637                    recordVersion.setCreateDate(record.getModifiedDate());
638                    recordVersion.setDDMStorageId(ddmStorageId);
639                    recordVersion.setRecordSetId(record.getRecordSetId());
640                    recordVersion.setRecordId(record.getRecordId());
641                    recordVersion.setVersion(version);
642                    recordVersion.setDisplayIndex(displayIndex);
643                    recordVersion.setStatus(status);
644                    recordVersion.setStatusByUserId(user.getUserId());
645                    recordVersion.setStatusByUserName(user.getFullName());
646                    recordVersion.setStatusDate(record.getModifiedDate());
647    
648                    ddlRecordVersionPersistence.update(recordVersion);
649    
650                    return recordVersion;
651            }
652    
653            protected String getNextVersion(
654                    String version, boolean majorVersion, int workflowAction) {
655    
656                    if (workflowAction == WorkflowConstants.ACTION_SAVE_DRAFT) {
657                            majorVersion = false;
658                    }
659    
660                    int[] versionParts = StringUtil.split(version, StringPool.PERIOD, 0);
661    
662                    if (majorVersion) {
663                            versionParts[0]++;
664                            versionParts[1] = 0;
665                    }
666                    else {
667                            versionParts[1]++;
668                    }
669    
670                    return versionParts[0] + StringPool.PERIOD + versionParts[1];
671            }
672    
673            protected Fields toFields(
674                    long ddmStructureId, Map<String, Serializable> fieldsMap) {
675    
676                    Fields fields = new Fields();
677    
678                    for (String name : fieldsMap.keySet()) {
679                            String value = String.valueOf(fieldsMap.get(name));
680    
681                            Field field = new Field(ddmStructureId, name, value);
682    
683                            fields.put(field);
684                    }
685    
686                    return fields;
687            }
688    
689            protected void updateRecordVersion(
690                            User user, DDLRecordVersion recordVersion, String version,
691                            int displayIndex, int status, ServiceContext serviceContext)
692                    throws SystemException {
693    
694                    recordVersion.setUserId(user.getUserId());
695                    recordVersion.setUserName(user.getFullName());
696                    recordVersion.setVersion(version);
697                    recordVersion.setDisplayIndex(displayIndex);
698                    recordVersion.setStatus(status);
699                    recordVersion.setStatusByUserId(user.getUserId());
700                    recordVersion.setStatusByUserName(user.getFullName());
701                    recordVersion.setStatusDate(serviceContext.getModifiedDate(null));
702    
703                    ddlRecordVersionPersistence.update(recordVersion);
704            }
705    
706    }