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                    // Indexer
176    
177                    Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
178                            DDLRecord.class);
179    
180                    indexer.delete(record);
181            }
182    
183            @Override
184            public void deleteRecord(long recordId)
185                    throws PortalException, SystemException {
186    
187                    DDLRecord record = ddlRecordPersistence.findByPrimaryKey(recordId);
188    
189                    deleteRecord(record);
190            }
191    
192            @Override
193            public DDLRecord deleteRecordLocale(
194                            long recordId, Locale locale, ServiceContext serviceContext)
195                    throws PortalException, SystemException {
196    
197                    DDLRecord record = ddlRecordPersistence.findByPrimaryKey(recordId);
198    
199                    Fields fields = StorageEngineUtil.getFields(record.getDDMStorageId());
200    
201                    for (Field field : fields) {
202                            Map<Locale, List<Serializable>> valuesMap = field.getValuesMap();
203    
204                            valuesMap.remove(locale);
205                    }
206    
207                    return ddlRecordLocalService.updateRecord(
208                            serviceContext.getUserId(), recordId, false,
209                            DDLRecordConstants.DISPLAY_INDEX_DEFAULT, fields, false,
210                            serviceContext);
211            }
212    
213            @Override
214            public void deleteRecords(long recordSetId)
215                    throws PortalException, SystemException {
216    
217                    List<DDLRecord> records = ddlRecordPersistence.findByRecordSetId(
218                            recordSetId);
219    
220                    for (DDLRecord record : records) {
221                            deleteRecord(record);
222                    }
223            }
224    
225            @Override
226            public DDLRecord fetchRecord(long recordId) throws SystemException {
227                    return ddlRecordPersistence.fetchByPrimaryKey(recordId);
228            }
229    
230            @Override
231            public List<DDLRecord> getCompanyRecords(
232                            long companyId, int status, int scope, int start, int end,
233                            OrderByComparator orderByComparator)
234                    throws SystemException {
235    
236                    return ddlRecordFinder.findByC_S_S(
237                            companyId, status, scope, start, end, orderByComparator);
238            }
239    
240            /**
241             * @deprecated As of 6.2.0, replaced by {@link #getCompanyRecords(long, int,
242             *             int, int, int, OrderByComparator)}
243             */
244            @Override
245            public List<DDLRecord> getCompanyRecords(
246                            long companyId, int scope, int start, int end,
247                            OrderByComparator orderByComparator)
248                    throws SystemException {
249    
250                    return getCompanyRecords(
251                            companyId, WorkflowConstants.STATUS_ANY, scope, start, end,
252                            orderByComparator);
253            }
254    
255            /**
256             * @deprecated As of 6.2.0, replaced by {@link #getCompanyRecordsCount(long,
257             *             int, int)}
258             */
259            @Override
260            public int getCompanyRecordsCount(long companyId, int scope)
261                    throws SystemException {
262    
263                    return getCompanyRecordsCount(
264                            companyId, WorkflowConstants.STATUS_ANY, scope);
265            }
266    
267            @Override
268            public int getCompanyRecordsCount(long companyId, int status, int scope)
269                    throws SystemException {
270    
271                    return ddlRecordFinder.countByC_S_S(companyId, status, scope);
272            }
273    
274            @Override
275            public DDLRecordVersion getLatestRecordVersion(long recordId)
276                    throws PortalException, SystemException {
277    
278                    List<DDLRecordVersion> recordVersions =
279                            ddlRecordVersionPersistence.findByRecordId(recordId);
280    
281                    if (recordVersions.isEmpty()) {
282                            throw new NoSuchRecordVersionException(
283                                    "No record versions found for recordId " + recordId);
284                    }
285    
286                    recordVersions = ListUtil.copy(recordVersions);
287    
288                    Collections.sort(
289                            recordVersions, new DDLRecordVersionVersionComparator());
290    
291                    return recordVersions.get(0);
292            }
293    
294            @Override
295            public Long[] getMinAndMaxCompanyRecordIds(
296                            long companyId, int status, int scope)
297                    throws SystemException {
298    
299                    return ddlRecordFinder.findByC_S_S_MinAndMax(companyId, status, scope);
300            }
301    
302            @Override
303            public List<DDLRecord> getMinAndMaxCompanyRecords(
304                            long companyId, int status, int scope, long minRecordId,
305                            long maxRecordId)
306                    throws SystemException {
307    
308                    return ddlRecordFinder.findByC_S_S_MinAndMax(
309                            companyId, status, scope, minRecordId, maxRecordId);
310            }
311    
312            @Override
313            public DDLRecord getRecord(long recordId)
314                    throws PortalException, SystemException {
315    
316                    return ddlRecordPersistence.findByPrimaryKey(recordId);
317            }
318    
319            @Override
320            public List<DDLRecord> getRecords(long recordSetId) throws SystemException {
321                    return ddlRecordPersistence.findByRecordSetId(recordSetId);
322            }
323    
324            @Override
325            public List<DDLRecord> getRecords(
326                            long recordSetId, int status, int start, int end,
327                            OrderByComparator orderByComparator)
328                    throws SystemException {
329    
330                    return ddlRecordFinder.findByR_S(
331                            recordSetId, status, start, end, orderByComparator);
332            }
333    
334            @Override
335            public List<DDLRecord> getRecords(long recordSetId, long userId)
336                    throws SystemException {
337    
338                    return ddlRecordPersistence.findByR_U(recordSetId, userId);
339            }
340    
341            @Override
342            public int getRecordsCount(long recordSetId, int status)
343                    throws SystemException {
344    
345                    return ddlRecordFinder.countByR_S(recordSetId, status);
346            }
347    
348            @Override
349            public DDLRecordVersion getRecordVersion(long recordVersionId)
350                    throws PortalException, SystemException {
351    
352                    return ddlRecordVersionPersistence.findByPrimaryKey(recordVersionId);
353            }
354    
355            @Override
356            public DDLRecordVersion getRecordVersion(long recordId, String version)
357                    throws PortalException, SystemException {
358    
359                    return ddlRecordVersionPersistence.findByR_V(recordId, version);
360            }
361    
362            @Override
363            public List<DDLRecordVersion> getRecordVersions(
364                            long recordId, int start, int end,
365                            OrderByComparator orderByComparator)
366                    throws SystemException {
367    
368                    return ddlRecordVersionPersistence.findByRecordId(
369                            recordId, start, end, orderByComparator);
370            }
371    
372            @Override
373            public int getRecordVersionsCount(long recordId) throws SystemException {
374                    return ddlRecordVersionPersistence.countByRecordId(recordId);
375            }
376    
377            @Override
378            public void revertRecordVersion(
379                            long userId, long recordId, String version,
380                            ServiceContext serviceContext)
381                    throws PortalException, SystemException {
382    
383                    DDLRecordVersion recordVersion = getRecordVersion(recordId, version);
384    
385                    if (!recordVersion.isApproved()) {
386                            return;
387                    }
388    
389                    Fields fields = StorageEngineUtil.getFields(
390                            recordVersion.getDDMStorageId());
391    
392                    ddlRecordLocalService.updateRecord(
393                            userId, recordId, true, recordVersion.getDisplayIndex(), fields,
394                            false, serviceContext);
395            }
396    
397            @Override
398            public Hits search(SearchContext searchContext) throws SystemException {
399                    try {
400                            Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
401                                    DDLRecord.class);
402    
403                            return indexer.search(searchContext);
404                    }
405                    catch (Exception e) {
406                            throw new SystemException(e);
407                    }
408            }
409    
410            @Override
411            public void updateAsset(
412                            long userId, DDLRecord record, DDLRecordVersion recordVersion,
413                            long[] assetCategoryIds, String[] assetTagNames, Locale locale)
414                    throws PortalException, SystemException {
415    
416                    boolean addDraftAssetEntry = false;
417    
418                    if ((recordVersion != null) && !recordVersion.isApproved()) {
419                            String version = recordVersion.getVersion();
420    
421                            if (!version.equals(DDLRecordConstants.VERSION_DEFAULT)) {
422                                    int approvedRecordVersionsCount =
423                                            ddlRecordVersionPersistence.countByR_S(
424                                                    record.getRecordId(),
425                                                    WorkflowConstants.STATUS_APPROVED);
426    
427                                    if (approvedRecordVersionsCount > 0) {
428                                            addDraftAssetEntry = true;
429                                    }
430                            }
431                    }
432    
433                    boolean visible = false;
434    
435                    if ((recordVersion != null) && !recordVersion.isApproved()) {
436                            visible = false;
437                    }
438    
439                    DDLRecordSet recordSet = record.getRecordSet();
440    
441                    DDMStructure ddmStructure = recordSet.getDDMStructure();
442    
443                    String ddmStructureName = ddmStructure.getName(locale);
444    
445                    String recordSetName = recordSet.getName(locale);
446    
447                    String title = LanguageUtil.format(
448                            locale, "new-x-for-list-x",
449                            new Object[] {ddmStructureName, recordSetName});
450    
451                    if (addDraftAssetEntry) {
452                            assetEntryLocalService.updateEntry(
453                                    userId, record.getGroupId(), record.getCreateDate(),
454                                    record.getModifiedDate(), DDLRecordConstants.getClassName(),
455                                    recordVersion.getRecordVersionId(), record.getUuid(), 0,
456                                    assetCategoryIds, assetTagNames, false, null, null, null,
457                                    ContentTypes.TEXT_HTML, title, null, StringPool.BLANK, null,
458                                    null, 0, 0, null, false);
459                    }
460                    else {
461                            assetEntryLocalService.updateEntry(
462                                    userId, record.getGroupId(), record.getCreateDate(),
463                                    record.getModifiedDate(), DDLRecordConstants.getClassName(),
464                                    record.getRecordId(), record.getUuid(), 0, assetCategoryIds,
465                                    assetTagNames, visible, null, null, null,
466                                    ContentTypes.TEXT_HTML, title, null, StringPool.BLANK, null,
467                                    null, 0, 0, null, false);
468                    }
469            }
470    
471            @Indexable(type = IndexableType.REINDEX)
472            @Override
473            public DDLRecord updateRecord(
474                            long userId, long recordId, boolean majorVersion, int displayIndex,
475                            Fields fields, boolean mergeFields, ServiceContext serviceContext)
476                    throws PortalException, SystemException {
477    
478                    // Record
479    
480                    User user = userPersistence.findByPrimaryKey(userId);
481    
482                    DDLRecord record = ddlRecordPersistence.findByPrimaryKey(recordId);
483    
484                    record.setModifiedDate(serviceContext.getModifiedDate(null));
485    
486                    ddlRecordPersistence.update(record);
487    
488                    // Record version
489    
490                    DDLRecordVersion recordVersion = record.getLatestRecordVersion();
491    
492                    if (recordVersion.isApproved()) {
493                            DDLRecordSet recordSet = record.getRecordSet();
494    
495                            if (mergeFields) {
496                                    Fields existingFields = StorageEngineUtil.getFields(
497                                            recordVersion.getDDMStorageId());
498    
499                                    fields = DDMUtil.mergeFields(fields, existingFields);
500                            }
501    
502                            long ddmStorageId = StorageEngineUtil.create(
503                                    recordSet.getCompanyId(), recordSet.getDDMStructureId(), fields,
504                                    serviceContext);
505                            String version = getNextVersion(
506                                    recordVersion.getVersion(), majorVersion,
507                                    serviceContext.getWorkflowAction());
508    
509                            recordVersion = addRecordVersion(
510                                    user, record, ddmStorageId, version, displayIndex,
511                                    WorkflowConstants.STATUS_DRAFT);
512                    }
513                    else {
514                            StorageEngineUtil.update(
515                                    recordVersion.getDDMStorageId(), fields, mergeFields,
516                                    serviceContext);
517    
518                            String version = recordVersion.getVersion();
519    
520                            updateRecordVersion(
521                                    user, recordVersion, version, displayIndex,
522                                    recordVersion.getStatus(), serviceContext);
523                    }
524    
525                    // Workflow
526    
527                    WorkflowHandlerRegistryUtil.startWorkflowInstance(
528                            user.getCompanyId(), record.getGroupId(), userId,
529                            DDLRecord.class.getName(), recordVersion.getRecordVersionId(),
530                            recordVersion, serviceContext);
531    
532                    return record;
533            }
534    
535            @Override
536            public DDLRecord updateRecord(
537                            long userId, long recordId, int displayIndex,
538                            Map<String, Serializable> fieldsMap, boolean mergeFields,
539                            ServiceContext serviceContext)
540                    throws PortalException, SystemException {
541    
542                    DDLRecord record = ddlRecordPersistence.findByPrimaryKey(recordId);
543    
544                    DDLRecordSet recordSet = record.getRecordSet();
545    
546                    DDMStructure ddmStructure = recordSet.getDDMStructure();
547    
548                    Fields fields = toFields(ddmStructure.getStructureId(), fieldsMap);
549    
550                    return ddlRecordLocalService.updateRecord(
551                            userId, recordId, false, displayIndex, fields, mergeFields,
552                            serviceContext);
553            }
554    
555            @Indexable(type = IndexableType.REINDEX)
556            @Override
557            public DDLRecord updateStatus(
558                            long userId, long recordVersionId, int status,
559                            ServiceContext serviceContext)
560                    throws PortalException, SystemException {
561    
562                    // Record version
563    
564                    User user = userPersistence.findByPrimaryKey(userId);
565    
566                    DDLRecordVersion recordVersion =
567                            ddlRecordVersionPersistence.findByPrimaryKey(recordVersionId);
568    
569                    recordVersion.setStatus(status);
570                    recordVersion.setStatusByUserId(user.getUserId());
571                    recordVersion.setStatusByUserName(user.getFullName());
572                    recordVersion.setStatusDate(new Date());
573    
574                    ddlRecordVersionPersistence.update(recordVersion);
575    
576                    // Record
577    
578                    DDLRecord record = ddlRecordPersistence.findByPrimaryKey(
579                            recordVersion.getRecordId());
580    
581                    if (status == WorkflowConstants.STATUS_APPROVED) {
582                            if (DLUtil.compareVersions(
583                                            record.getVersion(), recordVersion.getVersion()) <= 0) {
584    
585                                    record.setDDMStorageId(recordVersion.getDDMStorageId());
586                                    record.setVersion(recordVersion.getVersion());
587                                    record.setRecordSetId(recordVersion.getRecordSetId());
588                                    record.setDisplayIndex(recordVersion.getDisplayIndex());
589                                    record.setVersion(recordVersion.getVersion());
590                                    record.setVersionUserId(recordVersion.getUserId());
591                                    record.setVersionUserName(recordVersion.getUserName());
592                                    record.setModifiedDate(recordVersion.getCreateDate());
593    
594                                    ddlRecordPersistence.update(record);
595                            }
596                    }
597                    else {
598                            if (Validator.equals(
599                                            record.getVersion(), recordVersion.getVersion())) {
600    
601                                    String newVersion = DDLRecordConstants.VERSION_DEFAULT;
602    
603                                    List<DDLRecordVersion> approvedRecordVersions =
604                                            ddlRecordVersionPersistence.findByR_S(
605                                                    record.getRecordId(),
606                                                    WorkflowConstants.STATUS_APPROVED);
607    
608                                    if (!approvedRecordVersions.isEmpty()) {
609                                            newVersion = approvedRecordVersions.get(0).getVersion();
610                                    }
611    
612                                    record.setVersion(newVersion);
613    
614                                    ddlRecordPersistence.update(record);
615                            }
616                    }
617    
618                    return record;
619            }
620    
621            protected DDLRecordVersion addRecordVersion(
622                            User user, DDLRecord record, long ddmStorageId, String version,
623                            int displayIndex, int status)
624                    throws SystemException {
625    
626                    long recordVersionId = counterLocalService.increment();
627    
628                    DDLRecordVersion recordVersion = ddlRecordVersionPersistence.create(
629                            recordVersionId);
630    
631                    recordVersion.setGroupId(record.getGroupId());
632                    recordVersion.setCompanyId(record.getCompanyId());
633                    recordVersion.setUserId(user.getUserId());
634                    recordVersion.setUserName(user.getFullName());
635                    recordVersion.setCreateDate(record.getModifiedDate());
636                    recordVersion.setDDMStorageId(ddmStorageId);
637                    recordVersion.setRecordSetId(record.getRecordSetId());
638                    recordVersion.setRecordId(record.getRecordId());
639                    recordVersion.setVersion(version);
640                    recordVersion.setDisplayIndex(displayIndex);
641                    recordVersion.setStatus(status);
642                    recordVersion.setStatusByUserId(user.getUserId());
643                    recordVersion.setStatusByUserName(user.getFullName());
644                    recordVersion.setStatusDate(record.getModifiedDate());
645    
646                    ddlRecordVersionPersistence.update(recordVersion);
647    
648                    return recordVersion;
649            }
650    
651            protected String getNextVersion(
652                    String version, boolean majorVersion, int workflowAction) {
653    
654                    if (workflowAction == WorkflowConstants.ACTION_SAVE_DRAFT) {
655                            majorVersion = false;
656                    }
657    
658                    int[] versionParts = StringUtil.split(version, StringPool.PERIOD, 0);
659    
660                    if (majorVersion) {
661                            versionParts[0]++;
662                            versionParts[1] = 0;
663                    }
664                    else {
665                            versionParts[1]++;
666                    }
667    
668                    return versionParts[0] + StringPool.PERIOD + versionParts[1];
669            }
670    
671            protected Fields toFields(
672                    long ddmStructureId, Map<String, Serializable> fieldsMap) {
673    
674                    Fields fields = new Fields();
675    
676                    for (String name : fieldsMap.keySet()) {
677                            String value = String.valueOf(fieldsMap.get(name));
678    
679                            Field field = new Field(ddmStructureId, name, value);
680    
681                            fields.put(field);
682                    }
683    
684                    return fields;
685            }
686    
687            protected void updateRecordVersion(
688                            User user, DDLRecordVersion recordVersion, String version,
689                            int displayIndex, int status, ServiceContext serviceContext)
690                    throws SystemException {
691    
692                    recordVersion.setUserId(user.getUserId());
693                    recordVersion.setUserName(user.getFullName());
694                    recordVersion.setVersion(version);
695                    recordVersion.setDisplayIndex(displayIndex);
696                    recordVersion.setStatus(status);
697                    recordVersion.setStatusByUserId(user.getUserId());
698                    recordVersion.setStatusByUserName(user.getFullName());
699                    recordVersion.setStatusDate(serviceContext.getModifiedDate(null));
700    
701                    ddlRecordVersionPersistence.update(recordVersion);
702            }
703    
704    }