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