Notes

import {action, runInAction, makeAutoObservable, observable} from 'mobx';
import API from '../api/disclosuresApi';
import handleError from '../utils/handleError';
import appState from './appState';

class StorefrontDisclosures {
searchTypeByEnv = null;
searchTypeByProject = null;
searchTypeInput = null;
selectedRows = {};
tableData = [];
searchTypeOptionsEnv = [];
searchTypeOptionsProjects = [];
isFetching = false;
isRemoveConfirmModalOpen = false;
isCreateConfirmModalOpen = false;

constructor() {
this.appState = appState;
makeAutoObservable(this, {
searchTypeByEnv: observable,
selectedRows: observable,
searchTypeByProject: observable,
searchTypeOptionsEnv: observable,
searchTypeInput: observable,
searchTypeOptionsProjects: observable,
initialize: action,
deleteRows: action,
createEditStorefront: action
});
}

reset() {
runInAction(() => {
this.searchTypeByEnv = null;
this.searchTypeByProject = null;
this.searchTypeInput = null;
this.selectedRows = {};
this.tableData = [];
this.searchTypeOptionsEnv = [];
this.searchTypeOptionsProjects = [];
});
}

updateValue = ({key, value}) => {
this[key] = value;
};

initialize = async () => {
runInAction(() => {
this.isFetching = true;
this.searchTypeByEnv = null;
this.searchTypeByProject = null;
this.searchTypeInput = null;
this.tableData = [];
this.searchTypeOptionsEnv = [];
this.searchTypeOptionsProjects = [];
});
try {
const response = (await API.fetchStorefrontDisclosures()).data || [];
const storefrontEnv = (await API.fetchEnvironmentsStorefront()).data || [];
const srorefrontProjects = (await API.fetchProjectsStorefront()).data || [];
const setProjectValues = srorefrontProjects.map(val => ({value: val.projectId, label: val.projectCode}));
const storefrontEnvValues = storefrontEnv.map(val => ({value: val, label: val}));
const storeFrontList = response.map(res => {
return {
...res,
environment: res.environment,
projectCode: res.projectDetails.map(value => value.projectCode).join(', '),
storefront: res.storefront
};
});
runInAction(() => {
this.tableData = storeFrontList || [];
this.searchTypeOptionsEnv = storefrontEnvValues;
this.searchTypeOptionsProjects = setProjectValues;
this.isFetching = false;
});
} catch (err) {
handleError(err, `Unable to fetch storefront disclosures, please try again.`);
this.isFetching = false;
}
};

async createEditStorefront(params, isCreate) {
try {
if (isCreate) {
(await API.createStorefrontDisclosures(params)).data;
this.appState.handleNotification({
message: `Storefront disclosures successfully added`,
levelType: 'success'
});
} else {
(await API.editStorefrontDisclosures(params)).data;
this.appState.handleNotification({
message: `Storefront disclosures updated sucessfully`,
levelType: 'success'
});
}
const response = (await API.fetchStorefrontDisclosures()).data || [];
const storeFrontList = response.map(res => {
return {
...res,
environment: res.environment,
projectCode: res.projectDetails.map(value => value.projectCode).join(', '),
storefront: res.storefront
};
});

runInAction(() => {
this.tableData = storeFrontList || [];
this.searchTypeByEnv = null;
this.searchTypeInput = null;
this.searchTypeByProject = [];
});
} catch (err) {
handleError(err, `Failed to fetch storefront disclosures for entered input.`);
this.isFetching = false;
}
}

async deleteRows(environment, storefront) {
try {
(await API.deleteStorefrontDisclosures({environment, storefront})).data;
const response = (await API.fetchStorefrontDisclosures()).data || [];
const storeFrontList = response.map(res => {
return {
...res,
environment: res.environment,
projectCode: res.projectDetails.map(value => value.projectCode).join(', '),
storefront: res.storefront
};
});
this.appState.handleNotification({
message: `Storefront disclosures deleted sucessfully`,
levelType: 'success'
});
runInAction(() => {
this.tableData = storeFrontList || [];
});
} catch (err) {
handleError(err, `Failed to delete storefront disclosures`);
this.isFetching = false;
}
}
}

export default new StorefrontDisclosures();