openecomp-ui/src/sdc-app/onboarding/userNotifications/UserNotificationsActionHelper.js

import { actionTypes } from './UserNotificationsConstants.js';
import i18n from 'nfvo-utils/i18n/i18n.js';
import Configuration from 'sdc-app/config/Configuration.js';
import RestAPIUtil from 'nfvo-utils/RestAPIUtil.js';
import WebSocketUtil, { websocketUrl } from 'nfvo-utils/WebSocketUtil.js';
import { actionsEnum as VersionControllerActionsEnum } from 'nfvo-components/panel/versionController/VersionControllerConstants.js';
import ItemsHelper from 'sdc-app/common/helpers/ItemsHelper.js';
import ScreensHelper from 'sdc-app/common/helpers/ScreensHelper.js';
import MergeEditorActionHelper from 'sdc-app/common/merge/MergeEditorActionHelper.js';
import { actionTypes as modalActionTypes } from 'nfvo-components/modal/GlobalModalConstants.js';
import { SyncStates } from 'sdc-app/common/merge/MergeEditorConstants.js';

function baseUrl() {
    const restPrefix = Configuration.get('restPrefix');
    return `${restPrefix}/v1.0/notifications`;
}

function fetch() {
    return RestAPIUtil.fetch(baseUrl());
}

function updateNotification(notificationId) {
    return RestAPIUtil.put(`${baseUrl()}/${notificationId}`);
}

function updateLastSeenNotification(notificationId) {
    return RestAPIUtil.put(`${baseUrl()}/last-seen/${notificationId}`);
}

function loadPrevNotifications(lastScanned, endOfPage) {
    return RestAPIUtil.fetch(
        `${baseUrl()}?LAST_DELIVERED_EVENT_ID=${lastScanned}&END_OF_PAGE_EVENT_ID=${endOfPage}`
    );
}

const INITIAL_LAST_SCANNED = '00000000-0000-1000-8080-808080808080';

const UserNotificationsActionHelper = {
    notificationsFirstHandling(dispatch) {
        console.log('Websocket Url: ', websocketUrl);
        UserNotificationsActionHelper.fetchUserNotificationsList(dispatch).then(
            ({ lastScanned }) => {
                WebSocketUtil.open(websocketUrl, {
                    lastScanned: lastScanned || INITIAL_LAST_SCANNED
                });
            }
        );
    },

    fetchUserNotificationsList(dispatch) {
        return fetch().then(result => {
            dispatch({
                type: actionTypes.LOAD_NOTIFICATIONS,
                result
            });
            return Promise.resolve({ lastScanned: result.lastScanned });
        });
    },

    loadPreviousNotifications(dispatch, { lastScanned, endOfPage }) {
        loadPrevNotifications(lastScanned, endOfPage).then(result =>
            dispatch({
                type: actionTypes.LOAD_PREV_NOTIFICATIONS,
                result
            })
        );
    },

    notifyAboutConflicts(
        dispatch,
        { itemId, itemName, version, currentScreen }
    ) {
        let { props } = currentScreen;
        let currentItemId = props.softwareProductId || props.licenseModelId;
        let currentVersion = props.version;
        if (currentItemId === itemId && currentVersion.id === version.id) {
            MergeEditorActionHelper.analyzeSyncResult(dispatch, {
                itemId,
                version
            }).then(() => ScreensHelper.loadScreen(dispatch, currentScreen));
        } else {
            dispatch({
                type: modalActionTypes.GLOBAL_MODAL_WARNING,
                data: {
                    title: i18n('Conflicts'),
                    msg: i18n(
                        'There are conflicts in {itemName} version {versionName} that you have to resolve',
                        {
                            itemName: itemName.toUpperCase(),
                            versionName: version.versionName
                        }
                    ),
                    cancelButtonText: i18n('OK')
                }
            });
        }
    },

    syncItem(
        dispatch,
        { itemId, itemName, versionId, versionName, currentScreen }
    ) {
        let version = { id: versionId, versionName };
        ItemsHelper.fetchVersion({ itemId, versionId }).then(response => {
            let inMerge =
                response &&
                response.state &&
                response.state.synchronizationState === SyncStates.MERGE;
            if (!inMerge) {
                ItemsHelper.performVCAction({
                    itemId,
                    version,
                    action: VersionControllerActionsEnum.SYNC
                }).then(() => {
                    return ItemsHelper.fetchVersion({ itemId, versionId }).then(
                        response => {
                            let inMerge =
                                response &&
                                response.state &&
                                response.state.synchronizationState ===
                                    SyncStates.MERGE;
                            if (!inMerge) {
                                return ScreensHelper.loadScreen(
                                    dispatch,
                                    currentScreen
                                );
                            } else {
                                return this.notifyAboutConflicts(dispatch, {
                                    itemId,
                                    itemName,
                                    version,
                                    currentScreen
                                });
                            }
                        }
                    );
                });
            } else {
                this.notifyAboutConflicts(dispatch, {
                    itemId,
                    itemName,
                    version,
                    currentScreen
                });
            }
        });
    },

    updateNotification(dispatch, { notificationForUpdate }) {
        updateNotification(notificationForUpdate.eventId).then(response => {
            if (
                response.status === 'Success' &&
                Object.keys(response.errors).length === 0
            ) {
                dispatch({
                    type: actionTypes.UPDATE_READ_NOTIFICATION,
                    notificationForUpdate
                });
            }
        });
    },

    updateLastSeenNotification(dispatch, { notificationId }) {
        updateLastSeenNotification(notificationId).then(response => {
            if (
                response.status === 'Success' &&
                Object.keys(response.errors).length === 0
            ) {
                dispatch({ type: actionTypes.RESET_NEW_NOTIFICATIONS });
            }
        });
    }
};

export default UserNotificationsActionHelper;