Adding Prettier and fixing up eslint version

[sdc.git] / openecomp-ui / src / sdc-app / onboarding / licenseModel / featureGroups / FeatureGroupsActionHelper.js

diff --git a/openecomp-ui/src/sdc-app/onboarding/licenseModel/featureGroups/FeatureGroupsActionHelper.js b/openecomp-ui/src/sdc-app/onboarding/licenseModel/featureGroups/FeatureGroupsActionHelper.js
index aadf8e0..22e21a6 100644 (file)
--- a/openecomp-ui/src/sdc-app/onboarding/licenseModel/featureGroups/FeatureGroupsActionHelper.js
+++ b/openecomp-ui/src/sdc-app/onboarding/licenseModel/featureGroups/FeatureGroupsActionHelper.js
@@ -15,132 +15,202 @@
  */
 import RestAPIUtil from 'nfvo-utils/RestAPIUtil.js';
 import Configuration from 'sdc-app/config/Configuration.js';
-import {actionTypes as featureGroupsActionConstants} from './FeatureGroupsConstants.js';
+import { actionTypes as featureGroupsActionConstants } from './FeatureGroupsConstants.js';
 import EntitlementPoolsActionHelper from 'sdc-app/onboarding/licenseModel/entitlementPools/EntitlementPoolsActionHelper.js';
 import LicenseKeyGroupsActionHelper from 'sdc-app/onboarding/licenseModel/licenseKeyGroups/LicenseKeyGroupsActionHelper.js';
 import ItemsHelper from 'sdc-app/common/helpers/ItemsHelper.js';
 
 function baseUrl(licenseModelId, version) {
-       const restPrefix = Configuration.get('restPrefix');
-       const {id: versionId} = version;
-       return `${restPrefix}/v1.0/vendor-license-models/${licenseModelId}/versions/${versionId}/feature-groups`;
+    const restPrefix = Configuration.get('restPrefix');
+    const { id: versionId } = version;
+    return `${restPrefix}/v1.0/vendor-license-models/${licenseModelId}/versions/${versionId}/feature-groups`;
 }
 
 function fetchFeatureGroup(licenseModelId, featureGroupId, version) {
-       return RestAPIUtil.fetch(`${baseUrl(licenseModelId, version)}/${featureGroupId}`);
+    return RestAPIUtil.fetch(
+        `${baseUrl(licenseModelId, version)}/${featureGroupId}`
+    );
 }
 
 function fetchFeatureGroupsList(licenseModelId, version) {
-       return RestAPIUtil.fetch(`${baseUrl(licenseModelId, version)}`);
+    return RestAPIUtil.fetch(`${baseUrl(licenseModelId, version)}`);
 }
 
 function deleteFeatureGroup(licenseModelId, featureGroupId, version) {
-       return RestAPIUtil.destroy(`${baseUrl(licenseModelId, version)}/${featureGroupId}`);
+    return RestAPIUtil.destroy(
+        `${baseUrl(licenseModelId, version)}/${featureGroupId}`
+    );
 }
 
 function addFeatureGroup(licenseModelId, featureGroup, version) {
-       return RestAPIUtil.post(baseUrl(licenseModelId, version), {
-               name: featureGroup.name,
-               description: featureGroup.description,
-               partNumber: featureGroup.partNumber,
-               manufacturerReferenceNumber: featureGroup.manufacturerReferenceNumber,
-               addedLicenseKeyGroupsIds: featureGroup.licenseKeyGroupsIds,
-               addedEntitlementPoolsIds: featureGroup.entitlementPoolsIds
-       });
+    return RestAPIUtil.post(baseUrl(licenseModelId, version), {
+        name: featureGroup.name,
+        description: featureGroup.description,
+        partNumber: featureGroup.partNumber,
+        manufacturerReferenceNumber: featureGroup.manufacturerReferenceNumber,
+        addedLicenseKeyGroupsIds: featureGroup.licenseKeyGroupsIds,
+        addedEntitlementPoolsIds: featureGroup.entitlementPoolsIds
+    });
 }
 
-function updateFeatureGroup(licenseModelId, previousFeatureGroup, featureGroup, version) {
-
-       const {licenseKeyGroupsIds = []} = featureGroup;
-       const {licenseKeyGroupsIds: prevLicenseKeyGroupsIds = []} = previousFeatureGroup;
-       const {entitlementPoolsIds = []} = featureGroup;
-       const {entitlementPoolsIds: prevEntitlementPoolsIds = []} = previousFeatureGroup;
-       return RestAPIUtil.put(`${baseUrl(licenseModelId, version)}/${featureGroup.id}`, {
-               name: featureGroup.name,
-               description: featureGroup.description,
-               partNumber: featureGroup.partNumber,
-               manufacturerReferenceNumber: featureGroup.manufacturerReferenceNumber,
-               addedLicenseKeyGroupsIds: licenseKeyGroupsIds.filter(licenseKeyGroupId => prevLicenseKeyGroupsIds.indexOf(licenseKeyGroupId) === -1),
-               removedLicenseKeyGroupsIds: prevLicenseKeyGroupsIds.filter(prevLicenseKeyGroupId => licenseKeyGroupsIds.indexOf(prevLicenseKeyGroupId) === -1),
-               addedEntitlementPoolsIds: entitlementPoolsIds.filter(entitlementPoolId => prevEntitlementPoolsIds.indexOf(entitlementPoolId) === -1),
-               removedEntitlementPoolsIds: prevEntitlementPoolsIds.filter(prevEntitlementPoolId => entitlementPoolsIds.indexOf(prevEntitlementPoolId) === -1)
-
-       });
+function updateFeatureGroup(
+    licenseModelId,
+    previousFeatureGroup,
+    featureGroup,
+    version
+) {
+    const { licenseKeyGroupsIds = [] } = featureGroup;
+    const {
+        licenseKeyGroupsIds: prevLicenseKeyGroupsIds = []
+    } = previousFeatureGroup;
+    const { entitlementPoolsIds = [] } = featureGroup;
+    const {
+        entitlementPoolsIds: prevEntitlementPoolsIds = []
+    } = previousFeatureGroup;
+    return RestAPIUtil.put(
+        `${baseUrl(licenseModelId, version)}/${featureGroup.id}`,
+        {
+            name: featureGroup.name,
+            description: featureGroup.description,
+            partNumber: featureGroup.partNumber,
+            manufacturerReferenceNumber:
+                featureGroup.manufacturerReferenceNumber,
+            addedLicenseKeyGroupsIds: licenseKeyGroupsIds.filter(
+                licenseKeyGroupId =>
+                    prevLicenseKeyGroupsIds.indexOf(licenseKeyGroupId) === -1
+            ),
+            removedLicenseKeyGroupsIds: prevLicenseKeyGroupsIds.filter(
+                prevLicenseKeyGroupId =>
+                    licenseKeyGroupsIds.indexOf(prevLicenseKeyGroupId) === -1
+            ),
+            addedEntitlementPoolsIds: entitlementPoolsIds.filter(
+                entitlementPoolId =>
+                    prevEntitlementPoolsIds.indexOf(entitlementPoolId) === -1
+            ),
+            removedEntitlementPoolsIds: prevEntitlementPoolsIds.filter(
+                prevEntitlementPoolId =>
+                    entitlementPoolsIds.indexOf(prevEntitlementPoolId) === -1
+            )
+        }
+    );
 }
 
 export default {
-       fetchFeatureGroup(dispatch, {licenseModelId, featureGroupId, version}) {
-               return fetchFeatureGroup(licenseModelId, featureGroupId, version);
-       },
+    fetchFeatureGroup(dispatch, { licenseModelId, featureGroupId, version }) {
+        return fetchFeatureGroup(licenseModelId, featureGroupId, version);
+    },
 
-       fetchFeatureGroupsList(dispatch, {licenseModelId, version}) {
-               return fetchFeatureGroupsList(licenseModelId, version).then(response => dispatch({
-                       type: featureGroupsActionConstants.FEATURE_GROUPS_LIST_LOADED,
-                       response
-               }));
-       },
+    fetchFeatureGroupsList(dispatch, { licenseModelId, version }) {
+        return fetchFeatureGroupsList(licenseModelId, version).then(response =>
+            dispatch({
+                type: featureGroupsActionConstants.FEATURE_GROUPS_LIST_LOADED,
+                response
+            })
+        );
+    },
 
-       deleteFeatureGroup(dispatch, {licenseModelId, featureGroupId, version}) {
-               return deleteFeatureGroup(licenseModelId, featureGroupId, version).then(() => {
-                       dispatch({
-                               type: featureGroupsActionConstants.DELETE_FEATURE_GROUPS,
-                               featureGroupId
-                       });
-                       ItemsHelper.checkItemStatus(dispatch, {itemId: licenseModelId, versionId: version.id});
-               });
-       },
+    deleteFeatureGroup(dispatch, { licenseModelId, featureGroupId, version }) {
+        return deleteFeatureGroup(licenseModelId, featureGroupId, version).then(
+            () => {
+                dispatch({
+                    type: featureGroupsActionConstants.DELETE_FEATURE_GROUPS,
+                    featureGroupId
+                });
+                return ItemsHelper.checkItemStatus(dispatch, {
+                    itemId: licenseModelId,
+                    versionId: version.id
+                });
+            }
+        );
+    },
 
-       saveFeatureGroup(dispatch, {licenseModelId, previousFeatureGroup, featureGroup, version}) {
-               if (previousFeatureGroup) {
-                       return updateFeatureGroup(licenseModelId, previousFeatureGroup, featureGroup, version).then(() =>{
-                               dispatch({
-                                       type: featureGroupsActionConstants.EDIT_FEATURE_GROUPS,
-                                       featureGroup
-                               });
-                               EntitlementPoolsActionHelper.fetchEntitlementPoolsList(dispatch, {licenseModelId, version});
-                               LicenseKeyGroupsActionHelper.fetchLicenseKeyGroupsList(dispatch, {licenseModelId, version});
-                               ItemsHelper.checkItemStatus(dispatch, {itemId: licenseModelId, versionId: version.id});
-                       });
-               }
-               else {
-                       return addFeatureGroup(licenseModelId, featureGroup, version).then(response => {
-                               dispatch({
-                                       type: featureGroupsActionConstants.ADD_FEATURE_GROUPS,
-                                       featureGroup: {
-                                               ...featureGroup,
-                                               id: response.value,
-                                               referencingLicenseAgreements: []
-                                       }
-                               });
-                               EntitlementPoolsActionHelper.fetchEntitlementPoolsList(dispatch, {licenseModelId, version});
-                               LicenseKeyGroupsActionHelper.fetchLicenseKeyGroupsList(dispatch, {licenseModelId, version});
-                               ItemsHelper.checkItemStatus(dispatch, {itemId: licenseModelId, versionId: version.id});
-                       });
-               }
-       },
+    saveFeatureGroup(
+        dispatch,
+        { licenseModelId, previousFeatureGroup, featureGroup, version }
+    ) {
+        if (previousFeatureGroup) {
+            return updateFeatureGroup(
+                licenseModelId,
+                previousFeatureGroup,
+                featureGroup,
+                version
+            ).then(() => {
+                dispatch({
+                    type: featureGroupsActionConstants.EDIT_FEATURE_GROUPS,
+                    featureGroup
+                });
+                EntitlementPoolsActionHelper.fetchEntitlementPoolsList(
+                    dispatch,
+                    { licenseModelId, version }
+                );
+                LicenseKeyGroupsActionHelper.fetchLicenseKeyGroupsList(
+                    dispatch,
+                    { licenseModelId, version }
+                );
+                return ItemsHelper.checkItemStatus(dispatch, {
+                    itemId: licenseModelId,
+                    versionId: version.id
+                });
+            });
+        } else {
+            return addFeatureGroup(licenseModelId, featureGroup, version).then(
+                response => {
+                    dispatch({
+                        type: featureGroupsActionConstants.ADD_FEATURE_GROUPS,
+                        featureGroup: {
+                            ...featureGroup,
+                            id: response.value,
+                            referencingLicenseAgreements: []
+                        }
+                    });
+                    EntitlementPoolsActionHelper.fetchEntitlementPoolsList(
+                        dispatch,
+                        { licenseModelId, version }
+                    );
+                    LicenseKeyGroupsActionHelper.fetchLicenseKeyGroupsList(
+                        dispatch,
+                        { licenseModelId, version }
+                    );
+                    return ItemsHelper.checkItemStatus(dispatch, {
+                        itemId: licenseModelId,
+                        versionId: version.id
+                    });
+                }
+            );
+        }
+    },
 
-       selectEntitlementPoolsEditorTab(dispatch, {tab}) {
-               dispatch({
-                       type: featureGroupsActionConstants.featureGroupsEditor.SELECT_TAB,
-                       tab
-               });
-       },
+    selectEntitlementPoolsEditorTab(dispatch, { tab }) {
+        dispatch({
+            type: featureGroupsActionConstants.featureGroupsEditor.SELECT_TAB,
+            tab
+        });
+    },
 
-       openFeatureGroupsEditor(dispatch, {featureGroup, licenseModelId, version}) {
-               return Promise.all([
-                       EntitlementPoolsActionHelper.fetchEntitlementPoolsList(dispatch, {licenseModelId, version}),
-                       LicenseKeyGroupsActionHelper.fetchLicenseKeyGroupsList(dispatch, {licenseModelId, version})
-               ]).then(() => {
-                       dispatch({
-                               type: featureGroupsActionConstants.featureGroupsEditor.OPEN,
-                               featureGroup
-                       });
-               });
-       },
+    openFeatureGroupsEditor(
+        dispatch,
+        { featureGroup, licenseModelId, version }
+    ) {
+        return Promise.all([
+            EntitlementPoolsActionHelper.fetchEntitlementPoolsList(dispatch, {
+                licenseModelId,
+                version
+            }),
+            LicenseKeyGroupsActionHelper.fetchLicenseKeyGroupsList(dispatch, {
+                licenseModelId,
+                version
+            })
+        ]).then(() => {
+            dispatch({
+                type: featureGroupsActionConstants.featureGroupsEditor.OPEN,
+                featureGroup
+            });
+        });
+    },
 
-       closeFeatureGroupsEditor(dispatch) {
-               dispatch({
-                       type: featureGroupsActionConstants.featureGroupsEditor.CLOSE
-               });
-       }
+    closeFeatureGroupsEditor(dispatch) {
+        dispatch({
+            type: featureGroupsActionConstants.featureGroupsEditor.CLOSE
+        });
+    }
 };