github.com/replicatedhq/ship@v0.55.0/web/init/src/redux/data/applicationSettings/actions.js (about)

     1  import "isomorphic-fetch";
     2  import { loadingData } from "../../ui/main/actions";
     3  import { Utilities } from "../../../utilities/utilities";
     4  
     5  export const constants = {
     6    RECEIVE_APPLICATION_SETTINGS: "RECEIVE_APPLICATION_SETTINGS",
     7    SET_CONFIG_ERRORS: "SET_CONFIG_ERRORS"
     8  };
     9  
    10  export function receiveApplicationSettings(fields) {
    11    return {
    12      type: constants.RECEIVE_APPLICATION_SETTINGS,
    13      payload: fields
    14    };
    15  }
    16  
    17  export function setConfigErrors(error) {
    18    return {
    19      type: constants.SET_CONFIG_ERRORS,
    20      payload: error
    21    }
    22  }
    23  
    24  export function getApplicationSettings(payload, shouldLoad = true) {
    25    return async (dispatch, getState) => {
    26      const { apiEndpoint } = getState();
    27      let response;
    28      if (shouldLoad) {
    29        dispatch(loadingData("appSettingsFields", true));
    30      }
    31      try {
    32        const url = `${apiEndpoint}/config/live`;
    33        response = await fetch(url, {
    34          method: "POST",
    35          body: JSON.stringify(payload),
    36          headers: {
    37            "Content-Type": "application/json"
    38          },
    39        });
    40        if (!response.ok) {
    41          if (response.status === 401) {
    42            // unauthorized
    43          }
    44          dispatch(loadingData("appSettingsFields", false));
    45          throw new Error(`Unexpected response status code ${response.status}`);
    46        }
    47        const body = await response.json();
    48        dispatch(loadingData("appSettingsFields", false));
    49        dispatch(receiveApplicationSettings(body));
    50        return body;
    51      } catch (error) {
    52        console.log(error);
    53        dispatch(loadingData("appSettingsFields", false));
    54        if (Utilities.isFailedToFetchErr(error.message)) {
    55          window.location.href = "/";
    56        }
    57        return;
    58      }
    59    };
    60  }
    61  
    62  export function saveApplicationSettings(payload, validate) {
    63    return async (dispatch, getState) => {
    64      dispatch(loadingData("saveAppSettings", true));
    65  
    66      const { apiEndpoint } = getState();
    67      let response;
    68      try {
    69        const url = `${apiEndpoint}/config`;
    70        response = await fetch(url, {
    71          method: "PUT",
    72          body: JSON.stringify({
    73            options: payload,
    74            validate,
    75          }),
    76          headers: {
    77            "Accept": "application/json",
    78            "Content-Type": "application/json"
    79          }
    80        });
    81        if (!response.ok) {
    82          if (response.status === 401) {
    83            // unauthorized
    84          }
    85          const serverErr = await response.json();
    86          dispatch(setConfigErrors(serverErr));
    87          throw new Error(`Unexpected response status code ${response.status}`);
    88        }
    89        const body = await response.json();
    90        dispatch(loadingData("saveAppSettings", false));
    91        return body;
    92      } catch (error) {
    93        dispatch(loadingData("saveAppSettings", false));
    94        console.log(error);
    95        return false;
    96      }
    97    }
    98  }
    99  
   100  export function finalizeApplicationSettings(payload, validate) {
   101    return async (dispatch, getState) => {
   102      dispatch(loadingData("finalizeAppSettings", true));
   103  
   104      const { apiEndpoint } = getState();
   105      let response;
   106      try {
   107        const url = `${apiEndpoint}/config/finalize`;
   108        response = await fetch(url, {
   109          method: "PUT",
   110          body: JSON.stringify({
   111            options: payload,
   112            validate,
   113          }),
   114          headers: {
   115            "Accept": "application/json",
   116            "Content-Type": "application/json"
   117          }
   118        });
   119        if (!response.ok) {
   120          if (response.status === 401) {
   121            // unauthorized
   122          }
   123          throw new Error(`Unexpected response status code ${response.status}`);
   124        }
   125        const body = await response.json();
   126        dispatch(loadingData("finalizeAppSettings", false));
   127        return body;
   128      } catch (error) {
   129        dispatch(loadingData("finalizeAppSettings", false));
   130        console.log(error);
   131        return;
   132      }
   133    }
   134  }
   135  
   136  export function setApplicationState(payload) {
   137    return async (dispatch, getState) => {
   138      dispatch(loadingData("setAppState", true));
   139  
   140      const { apiEndpoint } = getState();
   141      let response;
   142      try {
   143        const url = `${apiEndpoint}/state`;
   144        response = await fetch(url, {
   145          method: "PUT",
   146          body: JSON.stringify({
   147            runState: payload
   148          }),
   149          headers: {
   150            "Accept": "application/json",
   151            "Content-Type": "application/json"
   152          }
   153        });
   154        if (!response.ok) {
   155          if (response.status === 401) {
   156            // unauthorized
   157          }
   158          throw new Error(`Unexpected response status code ${response.status}`);
   159        }
   160        const body = await response.json();
   161        console.log(body);
   162        dispatch(loadingData("setAppState", false));
   163      } catch (error) {
   164        dispatch(loadingData("setAppState", false));
   165        console.log(error);
   166        return;
   167      }
   168    }
   169  }