cps-ncmp-service/src/main/java/org/onap/cps/ncmp/api/impl/events/lcm/LcmEventsCreatorHelper.java

   1 /*
   2  * ============LICENSE_START=======================================================
   3  * Copyright (C) 2022-2023 Nordix Foundation
   4  * ================================================================================
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *       http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  * SPDX-License-Identifier: Apache-2.0
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.cps.ncmp.api.impl.events.lcm;
  22
  23 import static org.onap.cps.ncmp.api.impl.events.lcm.LcmEventType.CREATE;
  24 import static org.onap.cps.ncmp.api.impl.events.lcm.LcmEventType.DELETE;
  25 import static org.onap.cps.ncmp.api.impl.events.lcm.LcmEventType.UPDATE;
  26 import static org.onap.cps.ncmp.api.inventory.CmHandleState.DELETED;
  27
  28 import com.google.common.collect.MapDifference;
  29 import com.google.common.collect.Maps;
  30 import java.util.HashMap;
  31 import java.util.List;
  32 import java.util.Map;
  33 import lombok.AccessLevel;
  34 import lombok.NoArgsConstructor;
  35 import lombok.extern.slf4j.Slf4j;
  36 import org.onap.cps.ncmp.api.models.NcmpServiceCmHandle;
  37 import org.onap.cps.ncmp.events.lcm.v1.Values;
  38
  39 /**
  40  * LcmEventsCreatorHelper has helper methods to create LcmEvent.
  41  * Determine the lcm event type i.e create,update and delete.
  42  * Based on lcm event type create the LcmEvent payload.
  43  */
  44 @Slf4j
  45 @NoArgsConstructor(access = AccessLevel.PRIVATE)
  46 public class LcmEventsCreatorHelper {
  47
  48     /**
  49      * Determining the event type based on the composite state.
  50      *
  51      * @param targetNcmpServiceCmHandle   target ncmpServiceCmHandle
  52      * @param existingNcmpServiceCmHandle existing ncmpServiceCmHandle
  53      * @return Event Type
  54      */
  55     public static LcmEventType determineEventType(final NcmpServiceCmHandle targetNcmpServiceCmHandle,
  56             final NcmpServiceCmHandle existingNcmpServiceCmHandle) {
  57
  58         if (existingNcmpServiceCmHandle.getCompositeState() == null) {
  59             return CREATE;
  60         } else if (targetNcmpServiceCmHandle.getCompositeState().getCmHandleState() == DELETED) {
  61             return DELETE;
  62         }
  63         return UPDATE;
  64     }
  65
  66     /**
  67      * Determine the cmhandle value difference pair.Contains the difference in the form of oldValues and newValues.
  68      *
  69      * @param targetNcmpServiceCmHandle   target ncmpServiceCmHandle
  70      * @param existingNcmpServiceCmHandle existing ncmpServiceCmHandle
  71      * @param lcmEventType                lcm event type
  72      * @return Lcm Event Value difference pair
  73      */
  74     public static LcmEventsCreator.CmHandleValuesHolder determineEventValues(
  75             final NcmpServiceCmHandle targetNcmpServiceCmHandle, final NcmpServiceCmHandle existingNcmpServiceCmHandle,
  76             final LcmEventType lcmEventType) {
  77
  78         if (CREATE == lcmEventType) {
  79             return determineCreateEventValues(targetNcmpServiceCmHandle);
  80         } else if (UPDATE == lcmEventType) {
  81             return determineUpdateEventValues(targetNcmpServiceCmHandle, existingNcmpServiceCmHandle);
  82         }
  83         return new LcmEventsCreator.CmHandleValuesHolder();
  84
  85     }
  86
  87     private static LcmEventsCreator.CmHandleValuesHolder determineCreateEventValues(
  88             final NcmpServiceCmHandle ncmpServiceCmHandle) {
  89         final LcmEventsCreator.CmHandleValuesHolder cmHandleValuesHolder = new LcmEventsCreator.CmHandleValuesHolder();
  90         cmHandleValuesHolder.setNewValues(new Values());
  91         cmHandleValuesHolder.getNewValues().setDataSyncEnabled(getDataSyncEnabledFlag(ncmpServiceCmHandle));
  92         cmHandleValuesHolder.getNewValues()
  93                 .setCmHandleState(mapCmHandleStateToLcmEventCmHandleState(ncmpServiceCmHandle));
  94         cmHandleValuesHolder.getNewValues().setCmHandleProperties(List.of(ncmpServiceCmHandle.getPublicProperties()));
  95         return cmHandleValuesHolder;
  96     }
  97
  98     private static LcmEventsCreator.CmHandleValuesHolder determineUpdateEventValues(
  99             final NcmpServiceCmHandle targetNcmpServiceCmHandle,
 100             final NcmpServiceCmHandle existingNcmpServiceCmHandle) {
 101
 102         final boolean hasDataSyncFlagEnabledChanged =
 103                 hasDataSyncEnabledFlagChanged(targetNcmpServiceCmHandle, existingNcmpServiceCmHandle);
 104         final boolean hasCmHandleStateChanged =
 105                 hasCmHandleStateChanged(targetNcmpServiceCmHandle, existingNcmpServiceCmHandle);
 106         final boolean arePublicCmHandlePropertiesEqual =
 107                 arePublicCmHandlePropertiesEqual(targetNcmpServiceCmHandle.getPublicProperties(),
 108                         existingNcmpServiceCmHandle.getPublicProperties());
 109
 110         final LcmEventsCreator.CmHandleValuesHolder cmHandleValuesHolder = new LcmEventsCreator.CmHandleValuesHolder();
 111
 112         if (hasDataSyncFlagEnabledChanged || hasCmHandleStateChanged || (!arePublicCmHandlePropertiesEqual)) {
 113             cmHandleValuesHolder.setOldValues(new Values());
 114             cmHandleValuesHolder.setNewValues(new Values());
 115         } else {
 116             return cmHandleValuesHolder;
 117         }
 118
 119         if (hasDataSyncFlagEnabledChanged) {
 120             setDataSyncEnabledFlag(targetNcmpServiceCmHandle, existingNcmpServiceCmHandle, cmHandleValuesHolder);
 121         }
 122
 123         if (hasCmHandleStateChanged) {
 124             setCmHandleStateChange(targetNcmpServiceCmHandle, existingNcmpServiceCmHandle, cmHandleValuesHolder);
 125         }
 126
 127         if (!arePublicCmHandlePropertiesEqual) {
 128             setPublicCmHandlePropertiesChange(targetNcmpServiceCmHandle, existingNcmpServiceCmHandle,
 129                     cmHandleValuesHolder);
 130         }
 131
 132         return cmHandleValuesHolder;
 133
 134     }
 135
 136     private static void setDataSyncEnabledFlag(final NcmpServiceCmHandle targetNcmpServiceCmHandle,
 137             final NcmpServiceCmHandle existingNcmpServiceCmHandle,
 138             final LcmEventsCreator.CmHandleValuesHolder cmHandleValuesHolder) {
 139
 140         cmHandleValuesHolder.getOldValues().setDataSyncEnabled(getDataSyncEnabledFlag(existingNcmpServiceCmHandle));
 141         cmHandleValuesHolder.getNewValues().setDataSyncEnabled(getDataSyncEnabledFlag(targetNcmpServiceCmHandle));
 142
 143     }
 144
 145     private static void setCmHandleStateChange(final NcmpServiceCmHandle targetNcmpServiceCmHandle,
 146             final NcmpServiceCmHandle existingNcmpServiceCmHandle,
 147             final LcmEventsCreator.CmHandleValuesHolder cmHandleValuesHolder) {
 148         cmHandleValuesHolder.getOldValues()
 149                 .setCmHandleState(mapCmHandleStateToLcmEventCmHandleState(existingNcmpServiceCmHandle));
 150         cmHandleValuesHolder.getNewValues()
 151                 .setCmHandleState(mapCmHandleStateToLcmEventCmHandleState(targetNcmpServiceCmHandle));
 152     }
 153
 154     private static void setPublicCmHandlePropertiesChange(final NcmpServiceCmHandle targetNcmpServiceCmHandle,
 155             final NcmpServiceCmHandle existingNcmpServiceCmHandle,
 156             final LcmEventsCreator.CmHandleValuesHolder cmHandleValuesHolder) {
 157
 158         final Map<String, Map<String, String>> publicCmHandlePropertiesDifference =
 159                 getPublicCmHandlePropertiesDifference(targetNcmpServiceCmHandle.getPublicProperties(),
 160                         existingNcmpServiceCmHandle.getPublicProperties());
 161         cmHandleValuesHolder.getOldValues()
 162                 .setCmHandleProperties(List.of(publicCmHandlePropertiesDifference.get("oldValues")));
 163         cmHandleValuesHolder.getNewValues()
 164                 .setCmHandleProperties(List.of(publicCmHandlePropertiesDifference.get("newValues")));
 165
 166     }
 167
 168     private static Values.CmHandleState mapCmHandleStateToLcmEventCmHandleState(
 169             final NcmpServiceCmHandle ncmpServiceCmHandle) {
 170         return Values.CmHandleState.fromValue(ncmpServiceCmHandle.getCompositeState().getCmHandleState().name());
 171     }
 172
 173     private static Boolean getDataSyncEnabledFlag(final NcmpServiceCmHandle ncmpServiceCmHandle) {
 174         return ncmpServiceCmHandle.getCompositeState().getDataSyncEnabled();
 175     }
 176
 177     private static boolean hasDataSyncEnabledFlagChanged(final NcmpServiceCmHandle targetNcmpServiceCmHandle,
 178             final NcmpServiceCmHandle existingNcmpServiceCmHandle) {
 179
 180         final Boolean targetDataSyncFlag = targetNcmpServiceCmHandle.getCompositeState().getDataSyncEnabled();
 181         final Boolean existingDataSyncFlag = existingNcmpServiceCmHandle.getCompositeState().getDataSyncEnabled();
 182
 183         if (targetDataSyncFlag == null) {
 184             return existingDataSyncFlag != null;
 185         }
 186
 187         return !targetDataSyncFlag.equals(existingDataSyncFlag);
 188     }
 189
 190     private static boolean hasCmHandleStateChanged(final NcmpServiceCmHandle targetNcmpServiceCmHandle,
 191             final NcmpServiceCmHandle existingNcmpServiceCmHandle) {
 192
 193         return targetNcmpServiceCmHandle.getCompositeState().getCmHandleState()
 194                        != existingNcmpServiceCmHandle.getCompositeState().getCmHandleState();
 195     }
 196
 197     private static boolean arePublicCmHandlePropertiesEqual(final Map<String, String> targetCmHandleProperties,
 198             final Map<String, String> existingCmHandleProperties) {
 199         if (targetCmHandleProperties.size() != existingCmHandleProperties.size()) {
 200             return false;
 201         }
 202
 203         return targetCmHandleProperties.equals(existingCmHandleProperties);
 204     }
 205
 206     private static Map<String, Map<String, String>> getPublicCmHandlePropertiesDifference(
 207             final Map<String, String> targetCmHandleProperties, final Map<String, String> existingCmHandleProperties) {
 208         final Map<String, Map<String, String>> oldAndNewPropertiesDifferenceMap = new HashMap<>(2);
 209
 210         final MapDifference<String, String> cmHandlePropertiesDifference =
 211                 Maps.difference(targetCmHandleProperties, existingCmHandleProperties);
 212
 213         final Map<String, String> newValues = new HashMap<>(cmHandlePropertiesDifference.entriesOnlyOnLeft());
 214         final Map<String, String> oldValues = new HashMap<>(cmHandlePropertiesDifference.entriesOnlyOnRight());
 215
 216         cmHandlePropertiesDifference.entriesDiffering().keySet().forEach(cmHandlePropertyName -> {
 217             oldValues.put(cmHandlePropertyName, existingCmHandleProperties.get(cmHandlePropertyName));
 218             newValues.put(cmHandlePropertyName, targetCmHandleProperties.get(cmHandlePropertyName));
 219         });
 220
 221         oldAndNewPropertiesDifferenceMap.put("oldValues", oldValues);
 222         oldAndNewPropertiesDifferenceMap.put("newValues", newValues);
 223
 224         return oldAndNewPropertiesDifferenceMap;
 225     }
 226
 227 }