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