Feature/AMP-30574/sectors mapping

amp/TEMPLATE/reampv2/src/App.route.jsx

@@ -9,6 +9,7 @@ const AdminNDDApp = lazy(() => import('./modules/admin/ndd'));
 const NDDDashboardApp = lazy(() => import('./modules/ndddashboard'));
 const ReportGeneratorApp = lazy(() => import('./modules/report_generator'));
 const GeocoderApp = lazy(() => import('./modules/geocoder'));
+const AdminSectorMappingApp = lazy(() => import('./modules/admin/sectorMapping'));
 
 class AppRoute extends Component {
   render() {
@@ -21,6 +22,7 @@ class AppRoute extends Component {
           <Route path="/ndddashboard" component={NDDDashboardApp} />
           <Route path="/report_generator" component={ReportGeneratorApp} />
           <Route path="/geocoder" component={GeocoderApp}/>
+          <Route path="/sector-mapping" component={AdminSectorMappingApp}/>
         </Suspense>
       </Router>
     );

amp/TEMPLATE/reampv2/src/modules/admin/sectorMapping/actions/fetchAvailableSectors.js

@@ -0,0 +1,25 @@
+import {
+    fetchSectorsSuccess,
+    fetchSectorsPending,
+    fetchSectorsError
+} from './startupAction';
+
+function fetchSectors(url, type) {
+  return dispatch => {
+    dispatch(fetchSectorsPending());
+    fetch(url + '/' + type)
+      .then(res => res.json())
+      .then(res => {
+        if (res.error) {
+          throw (res.error);
+        }
+        dispatch(fetchSectorsSuccess(res));
+        return res;
+      })
+      .catch(error => {
+        dispatch(fetchSectorsError(error));
+      });
+  };
+}
+
+export default fetchSectors;

amp/TEMPLATE/reampv2/src/modules/admin/sectorMapping/actions/fetchLayout.js

@@ -0,0 +1,22 @@
+import { fetchLayoutSuccess, fetchLayoutPending, fetchLayoutError } from './layoutAction';
+import { LAYOUT_EP } from '../constants/Constants';
+
+function fetchLayout() {
+  return dispatch => {
+    dispatch(fetchLayoutPending());
+    return fetch(LAYOUT_EP)
+      .then(res => res.json())
+      .then(res => {
+        if (res.error) {
+          throw (res.error);
+        }
+        dispatch(fetchLayoutSuccess(res));
+        return res;
+      })
+      .catch(error => {
+        dispatch(fetchLayoutError(error));
+      });
+  };
+}
+
+export default fetchLayout;

amp/TEMPLATE/reampv2/src/modules/admin/sectorMapping/actions/fetchSchemes.js

@@ -0,0 +1,25 @@
+import {
+    fetchSchemesSuccess,
+    fetchSchemesPending,
+    fetchSchemesError
+} from './startupAction';
+
+function fetchSchemes(url) {
+  return dispatch => {
+    dispatch(fetchSchemesPending());
+    fetch(url)
+      .then(res => res.json())
+      .then(res => {
+        if (res.error) {
+          throw (res.error);
+        }
+        dispatch(fetchSchemesSuccess(res));
+        return res;
+      })
+      .catch(error => {
+        dispatch(fetchSchemesError(error));
+      });
+  };
+}
+
+export default fetchSchemes;

amp/TEMPLATE/reampv2/src/modules/admin/sectorMapping/actions/fetchSectorMappings.js

@@ -0,0 +1,21 @@
+import { fetchSectorMappingSuccess, fetchSectorMappingPending, fetchSectorMappingError } from './startupAction';
+
+function fetchSectorMappings(url) {
+  return dispatch => {
+    dispatch(fetchSectorMappingPending());
+    fetch(url)
+      .then(res => res.json())
+      .then(res => {
+        if (res.error) {
+          throw (res.error);
+        }
+        dispatch(fetchSectorMappingSuccess(res));
+        return res;
+      })
+      .catch(error => {
+        dispatch(fetchSectorMappingError(error));
+      });
+  };
+}
+
+export default fetchSectorMappings;

amp/TEMPLATE/reampv2/src/modules/admin/sectorMapping/actions/fetchSettings.js

@@ -0,0 +1,22 @@
+import { fetchSettingsSuccess, fetchSettingsPending, fetchSettingsError } from './settingsAction';
+import { SETTINGS_EP } from '../constants/Constants';
+
+function fetchSettings() {
+  return dispatch => {
+    dispatch(fetchSettingsPending());
+    return fetch(SETTINGS_EP)
+      .then(res => res.json())
+      .then(res => {
+        if (res.error) {
+          throw (res.error);
+        }
+        dispatch(fetchSettingsSuccess(res));
+        return res;
+      })
+      .catch(error => {
+        dispatch(fetchSettingsError(error));
+      });
+  };
+}
+
+export default fetchSettings;

amp/TEMPLATE/reampv2/src/modules/admin/sectorMapping/actions/layoutAction.js

@@ -0,0 +1,22 @@
+export const FETCH_LAYOUT_PENDING = 'FETCH_LAYOUT_PENDING';
+export const FETCH_LAYOUT_SUCCESS = 'FETCH_LAYOUT_SUCCESS';
+export const FETCH_LAYOUT_ERROR = 'FETCH_LAYOUT_ERROR';
+
+export function fetchLayoutPending() {
+  return {
+    type: FETCH_LAYOUT_PENDING
+  };
+}
+
+export function fetchLayoutSuccess(layout) {
+  return {
+    type: FETCH_LAYOUT_SUCCESS,
+    payload: layout
+  };
+}
+export function fetchLayoutError(error) {
+  return {
+    type: FETCH_LAYOUT_ERROR,
+    error
+  };
+}

amp/TEMPLATE/reampv2/src/modules/admin/sectorMapping/actions/saveAction.js

@@ -0,0 +1,23 @@
+export const SAVE_SECTOR_MAP_PENDING = 'SAVE_SECTOR_MAP_PENDING';
+export const SAVE_SECTOR_MAP_SUCCESS = 'SAVE_SECTOR_MAP_SUCCESS';
+export const SAVE_SECTOR_MAP_ERROR = 'SAVE_SECTOR_MAP_ERROR';
+
+export function saveSectorMappingPending() {
+  return {
+    type: SAVE_SECTOR_MAP_PENDING
+  };
+}
+
+export function saveSectorMappingSuccess(mappings) {
+  return {
+    type: SAVE_SECTOR_MAP_SUCCESS,
+    payload: mappings
+  };
+}
+
+export function saveSectorMappingError(error) {
+  return {
+    type: SAVE_SECTOR_MAP_ERROR,
+    error
+  };
+}

amp/TEMPLATE/reampv2/src/modules/admin/sectorMapping/actions/saveSectorMappings.js

@@ -0,0 +1,41 @@
+import {saveSectorMappingPending, saveSectorMappingSuccess, saveSectorMappingError} from './saveAction';
+import {LAYOUT_EP} from '../constants/Constants';
+
+function saveSectorMappings(mappings, urlSave) {
+  return dispatch => {
+    dispatch(saveSectorMappingPending());
+    fetch(LAYOUT_EP).then(layoutRes => layoutRes.json()).then(data => {
+      if (data.logged) {
+        fetch(urlSave, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(mappings)
+        }).then(response => {
+            processResponse(response);
+            dispatch(saveSectorMappingSuccess(response));
+            return response;
+          })
+          .catch(error => {
+            dispatch(saveSectorMappingError(error));
+          });
+      } else {
+        window.location.replace('/login.do');
+        dispatch(saveSectorMappingError({ error: 'not logged' }));
+      }
+    }).catch(error => {
+      dispatch(saveSectorMappingError(error));
+    });
+  };
+}
+
+function processResponse(response) {
+  if (response.status === 500 || response.error) {
+    if (response.error) {
+      throw (response.error);
+    } else {
+      throw (response.statusText);
+    }
+  }
+}
+
+export default saveSectorMappings;

amp/TEMPLATE/reampv2/src/modules/admin/sectorMapping/actions/settingsAction.js

@@ -0,0 +1,22 @@
+export const FETCH_SETTINGS_PENDING = 'FETCH_SETTINGS_PENDING';
+export const FETCH_SETTINGS_SUCCESS = 'FETCH_SETTINGS_SUCCESS';
+export const FETCH_SETTINGS_ERROR = 'FETCH_SETTINGS_ERROR';
+
+export function fetchSettingsPending() {
+  return {
+    type: FETCH_SETTINGS_PENDING
+  };
+}
+
+export function fetchSettingsSuccess(settings) {
+  return {
+    type: FETCH_SETTINGS_SUCCESS,
+    payload: settings
+  };
+}
+export function fetchSettingsError(error) {
+  return {
+    type: FETCH_SETTINGS_ERROR,
+    error
+  };
+}

amp/TEMPLATE/reampv2/src/modules/admin/sectorMapping/actions/startupAction.js

@@ -0,0 +1,67 @@
+export const FETCH_SECTOR_MAP_PENDING = 'FETCH_SECTOR_MAP_PENDING';
+export const FETCH_SECTOR_MAP_SUCCESS = 'FETCH_SECTOR_MAP_SUCCESS';
+export const FETCH_SECTOR_MAP_ERROR = 'FETCH_SECTOR_MAP_ERROR';
+export const FETCH_SECTORS_PENDING = 'FETCH_SECTORS_PENDING';
+export const FETCH_SECTORS_SUCCESS = 'FETCH_SECTORS_SUCCESS';
+export const FETCH_SECTORS_ERROR = 'FETCH_SECTORS_ERROR';
+export const FETCH_SCHEMES_PENDING = 'FETCH_SCHEMES_PENDING';
+export const FETCH_SCHEMES_SUCCESS = 'FETCH_SCHEMES_SUCCESS';
+export const FETCH_SCHEMES_ERROR = 'FETCH_SCHEMES_ERROR';
+
+export function fetchSectorMappingPending() {
+  return {
+    type: FETCH_SECTOR_MAP_PENDING
+  };
+}
+
+export function fetchSectorMappingSuccess(sectorMapping) {
+  return {
+    type: FETCH_SECTOR_MAP_SUCCESS,
+    payload: sectorMapping
+  };
+}
+export function fetchSectorMappingError(error) {
+  return {
+    type: FETCH_SECTOR_MAP_ERROR,
+    error
+  };
+}
+export function fetchSectorsPending() {
+  return {
+    type: FETCH_SECTORS_PENDING
+  };
+}
+
+export function fetchSectorsSuccess(sectors) {
+  return {
+    type: FETCH_SECTORS_SUCCESS,
+    payload: sectors
+  };
+}
+export function fetchSectorsError(error) {
+  return {
+    type: FETCH_SECTORS_ERROR,
+    error
+  };
+}
+
+
+export function fetchSchemesPending() {
+  return {
+    type: FETCH_SCHEMES_PENDING
+  };
+}
+
+export function fetchSchemesSuccess(schemes) {
+  return {
+    type: FETCH_SCHEMES_SUCCESS,
+    payload: schemes
+  };
+}
+export function fetchSchemesError(error) {
+  return {
+    type: FETCH_SCHEMES_ERROR,
+    error
+  };
+}
+