@griddo/ax 12.6.1 → 12.6.2

package/src/containers/Analytics/actions.tsx

@@ -0,0 +1,109 @@
+import { analytics } from "@ax/api";
+import { appActions } from "@ax/containers/App";
+import { handleRequest } from "@ax/helpers";
+import type { IAnalytics } from "@ax/types";
+import type { Dispatch } from "redux";
+import { SET_ANALYTICS } from "./constants";
+import type { ISetAnalytics } from "./interfaces";
+
+function setAnalytics(analytics: IAnalytics): ISetAnalytics {
+	return { type: SET_ANALYTICS, payload: analytics };
+}
+
+function getAnalytics(siteId?: number | null): (dispatch: Dispatch) => Promise<void> {
+	return async (dispatch) => {
+		try {
+			const callback = async () => analytics.getAnalytics(siteId || "global");
+
+			const responseActions = {
+				handleSuccess: (response: any) => {
+					dispatch(setAnalytics(response));
+				},
+				handleError: (response: any) => appActions.handleError(response)(dispatch),
+			};
+
+			await handleRequest(callback, responseActions, [])(dispatch);
+		} catch (e) {
+			console.log(e);
+		}
+	};
+}
+
+function updateAnalytics(analyticsState: IAnalytics, siteId?: number | null): (dispatch: Dispatch) => Promise<boolean> {
+	return async (dispatch) => {
+		try {
+			const { scriptCode, dimensions, groups } = analyticsState;
+			const callback = async () => {
+				const promises = [];
+				const site = siteId || "global";
+				promises.push(analytics.updateScriptCode(site, { scriptCode }));
+				promises.push(analytics.createDimensions(site, { dimensions }));
+				promises.push(analytics.createDimensionsGroups(site, { groups }));
+				return Promise.all(promises);
+			};
+
+			const responseActions = {
+				handleSuccess: () => {
+					getAnalytics(siteId)(dispatch);
+				},
+				handleError: (response: any) => {
+					const {
+						data: { message },
+					} = response;
+					const isMultiple = Array.isArray(message) && message.length > 1;
+					const msg = isMultiple ? `The action failed due to ${message.length} errors.` : undefined;
+					appActions.handleError(response, isMultiple, msg)(dispatch);
+				},
+			};
+
+			return await handleRequest(callback, responseActions, [appActions.setIsSaving])(dispatch);
+		} catch (e) {
+			console.log(e);
+			return false;
+		}
+	};
+}
+
+function updateScriptCode(scriptCode: string, siteId?: number | null): (dispatch: Dispatch) => Promise<boolean> {
+	return async (dispatch) => {
+		try {
+			const callback = async () => {
+				return analytics.updateScriptCode(siteId || "global", { scriptCode });
+			};
+
+			const responseActions = {
+				handleSuccess: () => {
+					getAnalytics(siteId)(dispatch);
+				},
+				handleError: (response: any) => appActions.handleError(response)(dispatch),
+			};
+
+			return await handleRequest(callback, responseActions, [appActions.setIsSaving])(dispatch);
+		} catch (e) {
+			console.log(e);
+			return false;
+		}
+	};
+}
+
+function deleteScriptCode(siteId?: number | null): (dispatch: Dispatch) => Promise<boolean> {
+	return async (dispatch) => {
+		try {
+			const callback = async () => analytics.deleteScriptCode(siteId || "global");
+
+			const responseActions = {
+				handleSuccess: () => {
+					getAnalytics(siteId)(dispatch);
+				},
+				handleError: (response: any) => appActions.handleError(response)(dispatch),
+			};
+
+			return await handleRequest(callback, responseActions, [])(dispatch);
+		} catch (e) {
+			console.log(e);
+			return false;
+		}
+	};
+}
+
+export { setAnalytics, getAnalytics, updateAnalytics, updateScriptCode, deleteScriptCode };

package/src/containers/Analytics/constants.tsx

@@ -0,0 +1,5 @@
+const NAME = "analytics";
+
+const SET_ANALYTICS = `${NAME}/SET_ANALYTICS`;
+
+export { NAME, SET_ANALYTICS };

package/src/containers/Analytics/index.tsx

@@ -1,15 +1,4 @@
-import { setAnalytics } from "./slice";
-import { deleteScriptCode, getAnalytics, updateAnalytics, updateScriptCode } from "./thunks";
+import * as analyticsActions from "./actions";
+import { analyticsReducer } from "./reducer";
 
-const analyticsActions = {
-	setAnalytics,
-	getAnalytics,
-	updateAnalytics,
-	updateScriptCode,
-	deleteScriptCode,
-};
-
-export { analyticsActions };
-
-export type { IAnalyticsState } from "./slice";
-export { analyticsInitialState, analyticsReducer } from "./slice";
+export { analyticsActions, analyticsReducer };

package/src/containers/Analytics/interfaces.tsx

@@ -0,0 +1,9 @@
+import type { IAnalytics } from "@ax/types";
+import type { SET_ANALYTICS } from "./constants";
+
+export interface ISetAnalytics {
+	type: typeof SET_ANALYTICS;
+	payload: IAnalytics;
+}
+
+export type AnalyticsActionsCreators = ISetAnalytics;

package/src/containers/Analytics/reducer.tsx

@@ -0,0 +1,28 @@
+import type { IDimension, IDimensionsGroup } from "@ax/types";
+import { SET_ANALYTICS } from "./constants";
+import type { AnalyticsActionsCreators } from "./interfaces";
+
+export interface IAnalyticsState {
+	scriptCode: string;
+	siteScriptCodeExists: boolean;
+	dimensions: IDimension[];
+	groups: IDimensionsGroup[];
+}
+
+export const initialState = {
+	scriptCode: "",
+	siteScriptCodeExists: false,
+	dimensions: [],
+	groups: [],
+};
+
+export function reducer(state = initialState, action: AnalyticsActionsCreators): IAnalyticsState {
+	switch (action.type) {
+		case SET_ANALYTICS:
+			return { ...state, ...action.payload };
+		default:
+			return state;
+	}
+}
+
+export { initialState as analyticsInitialState, reducer as analyticsReducer };

package/src/containers/Domains/actions.tsx

@@ -0,0 +1,58 @@
+import { domains } from "@ax/api";
+import { appActions } from "@ax/containers/App";
+import { handleRequest } from "@ax/helpers";
+import type { IDomainRobot } from "@ax/types";
+import { SET_DOMAINS_ROBOTS } from "./constants";
+import type { ISetDomainsRobots } from "./interfaces";
+
+function setDomainsRobots(robots: IDomainRobot[]): ISetDomainsRobots {
+	return { type: SET_DOMAINS_ROBOTS, payload: { robots } };
+}
+
+function getDomainsRobots(): (dispatch: any) => Promise<void> {
+	return async (dispatch) => {
+		try {
+			const callback = async () => domains.getDomainsRobots();
+
+			const responseActions = {
+				handleSuccess: (response: any) => {
+					dispatch(setDomainsRobots(response));
+				},
+				handleError: (response: any) => appActions.handleError(response)(dispatch),
+			};
+
+			await handleRequest(callback, responseActions, [appActions.setIsLoading])(dispatch);
+		} catch (e) {
+			console.log(e);
+		}
+	};
+}
+
+function updateDomainsRobots(robots: IDomainRobot[]): (dispatch: any) => Promise<boolean> {
+	return async (dispatch) => {
+		try {
+			const callback = async () => domains.updateDomainsRobots(robots);
+
+			const responseActions = {
+				handleSuccess: () => {
+					dispatch(getDomainsRobots());
+				},
+				handleError: (response: any) => {
+					const {
+						data: { message },
+					} = response;
+					const isMultiple = Array.isArray(message) && message.length > 1;
+					const msg = isMultiple ? `The action failed due to ${message.length} errors.` : undefined;
+					appActions.handleError(response, isMultiple, msg)(dispatch);
+				},
+			};
+
+			return await handleRequest(callback, responseActions, [appActions.setIsSaving])(dispatch);
+		} catch (e) {
+			console.log(e);
+			return false;
+		}
+	};
+}
+
+export { getDomainsRobots, updateDomainsRobots };

package/src/containers/Domains/constants.tsx

@@ -0,0 +1,5 @@
+const NAME = "domains";
+
+const SET_DOMAINS_ROBOTS = `${NAME}/SET_DOMAINS_ROBOTS`;
+
+export { NAME, SET_DOMAINS_ROBOTS };

package/src/containers/Domains/index.tsx

@@ -1,13 +1,4 @@
-import { setDomainsRobots } from "./slice";
-import { getDomainsRobots, updateDomainsRobots } from "./thunks";
+import * as domainsActions from "./actions";
+import { domainsReducer } from "./reducer";
 
-const domainsActions = {
-	setDomainsRobots,
-	getDomainsRobots,
-	updateDomainsRobots,
-};
-
-export { domainsActions };
-
-export type { IDomainsState } from "./slice";
-export { domainsInitialState, domainsReducer } from "./slice";
+export { domainsActions, domainsReducer };

package/src/containers/Domains/interfaces.tsx

@@ -0,0 +1,9 @@
+import type { IDomainRobot } from "@ax/types";
+import type { SET_DOMAINS_ROBOTS } from "./constants";
+
+export interface ISetDomainsRobots {
+	type: typeof SET_DOMAINS_ROBOTS;
+	payload: { robots: IDomainRobot[] };
+}
+
+export type DomainsActionsCreators = ISetDomainsRobots;

package/src/containers/Domains/reducer.tsx

@@ -0,0 +1,22 @@
+import type { IDomainRobot } from "@ax/types";
+import { SET_DOMAINS_ROBOTS } from "./constants";
+import type { DomainsActionsCreators } from "./interfaces";
+
+export interface IDomainsState {
+	robots: IDomainRobot[];
+}
+
+export const initialState = {
+	robots: [],
+};
+
+export function reducer(state = initialState, action: DomainsActionsCreators): IDomainsState {
+	switch (action.type) {
+		case SET_DOMAINS_ROBOTS:
+			return { ...state, ...action.payload };
+		default:
+			return state;
+	}
+}
+
+export { initialState as domainsInitialState, reducer as domainsReducer };

package/src/containers/Redirects/actions.tsx

@@ -0,0 +1,190 @@
+import { redirects } from "@ax/api";
+import { appActions } from "@ax/containers/App";
+import { handleRequest } from "@ax/helpers";
+import {
+	DEFAULT_PARAMS,
+	ERROR_CODE,
+	SET_IMPORTS,
+	SET_REDIRECTS,
+	SET_TOTAL_IMPORTS,
+	SET_TOTAL_ITEMS,
+} from "./constants";
+import type { ISetImports, ISetRedirects, ISetTotalImports, ISetTotalItems } from "./interfaces";
+
+function setRedirects(redirects: any[]): ISetRedirects {
+	return { type: SET_REDIRECTS, payload: { redirects } };
+}
+
+function setTotalItems(totalItems: number): ISetTotalItems {
+	return { type: SET_TOTAL_ITEMS, payload: { totalItems } };
+}
+
+function setImports(imports: any): ISetImports {
+	return { type: SET_IMPORTS, payload: { imports } };
+}
+
+function setTotalImports(totalImports: number): ISetTotalImports {
+	return { type: SET_TOTAL_IMPORTS, payload: { totalImports } };
+}
+
+function getRedirects(params: any, filters?: string): (dispatch: any) => Promise<void> {
+	return async (dispatch) => {
+		try {
+			dispatch(setRedirects([]));
+			const callback = async () => redirects.getRedirects(params, filters);
+
+			const responseActions = {
+				handleSuccess: (response: any) => {
+					const { items, totalItems } = response;
+					dispatch(setRedirects(items));
+					dispatch(setTotalItems(totalItems));
+				},
+				handleError: (response: any) => appActions.handleError(response)(dispatch),
+			};
+
+			await handleRequest(callback, responseActions, [appActions.setIsLoading])(dispatch);
+		} catch (e) {
+			console.log(e);
+		}
+	};
+}
+
+function addRedirect(
+	redirect: { from: string; to: string | number },
+	errorAction: () => void,
+	force?: boolean,
+	filter?: string,
+): (dispatch: any, getState: any) => Promise<void> {
+	return async (dispatch, getState) => {
+		try {
+			const {
+				sites: { currentSiteInfo },
+			} = getState();
+
+			const callback = async () => redirects.createRedirect(redirect, force);
+
+			const responseActions = {
+				handleSuccess: () => {
+					const params = { ...DEFAULT_PARAMS };
+					const siteFilterQuery = currentSiteInfo && currentSiteInfo.id ? `&sites=${currentSiteInfo.id}` : filter;
+					dispatch(getRedirects(params, siteFilterQuery));
+				},
+				handleError: (response: any) => {
+					const { status } = response;
+
+					status === ERROR_CODE.isBeingUsed ? errorAction() : appActions.handleError(response)(dispatch);
+				},
+			};
+
+			await handleRequest(callback, responseActions, [])(dispatch);
+		} catch (e) {
+			console.log(e);
+		}
+	};
+}
+
+function updateRedirect(
+	redirect: { from: string; to: string | number },
+	redirectID: number,
+	filter?: string,
+): (dispatch: any, getState: any) => Promise<void> {
+	return async (dispatch, getState) => {
+		try {
+			const {
+				sites: { currentSiteInfo },
+			} = getState();
+
+			const callback = async () => redirects.updateRedirect(redirect, redirectID);
+
+			const responseActions = {
+				handleSuccess: () => {
+					const params = { ...DEFAULT_PARAMS };
+					const siteFilterQuery = currentSiteInfo && currentSiteInfo.id ? `&sites=${currentSiteInfo.id}` : filter;
+					dispatch(getRedirects(params, siteFilterQuery));
+				},
+				handleError: (response: any) => appActions.handleError(response)(dispatch),
+			};
+
+			await handleRequest(callback, responseActions, [])(dispatch);
+		} catch (e) {
+			console.log(e);
+		}
+	};
+}
+
+function deleteRedirect(
+	redirectID: number | number[],
+	filter?: string,
+): (dispatch: any, getState: any) => Promise<boolean> {
+	return async (dispatch, getState) => {
+		try {
+			const {
+				sites: { currentSiteInfo },
+			} = getState();
+
+			const callback = async () =>
+				Array.isArray(redirectID) ? redirects.deleteRedirectsBulk(redirectID) : redirects.deleteRedirect(redirectID);
+
+			const responseActions = {
+				handleSuccess: () => {
+					const params = { ...DEFAULT_PARAMS };
+					const siteFilterQuery = currentSiteInfo?.id ? `&sites=${currentSiteInfo.id}` : filter;
+					dispatch(getRedirects(params, siteFilterQuery));
+				},
+				handleError: (response: any) => {
+					const {
+						data: { message },
+					} = response;
+					const isMultiple = Array.isArray(message) && message.length > 1;
+					const msg = isMultiple ? `The delete action failed due to ${message.length} errors.` : undefined;
+					appActions.handleError(response, isMultiple, msg)(dispatch);
+				},
+			};
+
+			return await handleRequest(callback, responseActions, [appActions.setIsSaving])(dispatch);
+		} catch (e) {
+			console.log(e);
+			return false;
+		}
+	};
+}
+
+function importRedirects(
+	redirect: { from: string; to: string | number }[],
+	check: boolean,
+): (dispatch: any) => Promise<boolean> {
+	return async (dispatch) => {
+		try {
+			const callback = async () =>
+				check ? redirects.createRedirectsBulkCheck(redirect) : redirects.createRedirectsBulk(redirect);
+
+			const responseActions = {
+				handleSuccess: (response: any) => {
+					if (check) {
+						const { total, error, existing, ok } = response;
+						dispatch(setImports({ error, existing, ok }));
+						dispatch(setTotalImports(total));
+					} else {
+						const params = { ...DEFAULT_PARAMS };
+						dispatch(getRedirects(params));
+					}
+				},
+				handleError: (response: any) => {
+					const {
+						data: { message },
+					} = response;
+					const isMultiple = Array.isArray(message) && message.length > 1;
+					const msg = isMultiple ? `The import action failed due to ${message.length} errors.` : undefined;
+					appActions.handleError(response, isMultiple, msg)(dispatch);
+				},
+			};
+
+			return await handleRequest(callback, responseActions, [])(dispatch);
+		} catch (e) {
+			console.log(e);
+			return false;
+		}
+	};
+}
+
+export { getRedirects, addRedirect, updateRedirect, deleteRedirect, importRedirects };

package/src/containers/Redirects/constants.tsx

@@ -1,3 +1,10 @@
+const NAME = "redirects";
+
+const SET_REDIRECTS = `${NAME}/SET_REDIRECTS`;
+const SET_TOTAL_ITEMS = `${NAME}/SET_TOTAL_ITEMS`;
+const SET_TOTAL_IMPORTS = `${NAME}/SET_TOTAL_IMPORTS`;
+const SET_IMPORTS = `${NAME}/SET_IMPORTS`;
+
 const ITEMS_PER_PAGE = 50;
 
 const DEFAULT_PARAMS = {
@@ -10,4 +17,13 @@ const ERROR_CODE = {
 	isBeingUsed: 409,
 };
 
-export { ERROR_CODE, DEFAULT_PARAMS, ITEMS_PER_PAGE };
+export {
+	NAME,
+	SET_REDIRECTS,
+	SET_TOTAL_ITEMS,
+	ERROR_CODE,
+	DEFAULT_PARAMS,
+	ITEMS_PER_PAGE,
+	SET_IMPORTS,
+	SET_TOTAL_IMPORTS,
+};

package/src/containers/Redirects/index.tsx

@@ -1,15 +1,4 @@
-import { addRedirect, deleteRedirect, getRedirects, importRedirects, updateRedirect } from "./thunks";
+import * as redirectsActions from "./actions";
+import { redirectsReducer } from "./reducer";
 
-const redirectsActions = {
-	getRedirects,
-	addRedirect,
-	updateRedirect,
-	deleteRedirect,
-	importRedirects,
-};
-
-export { redirectsActions };
-
-export type { IRedirectsState } from "./slice";
-export { redirectsInitialState, redirectsReducer } from "./slice";
-export type { IAddRedirectResult, IRedirectsQuery } from "./thunks";
+export { redirectsActions, redirectsReducer };

package/src/containers/Redirects/interfaces.tsx

@@ -0,0 +1,23 @@
+import type { SET_IMPORTS, SET_REDIRECTS, SET_TOTAL_IMPORTS, SET_TOTAL_ITEMS } from "./constants";
+
+export interface ISetRedirects {
+	type: typeof SET_REDIRECTS;
+	payload: { redirects: any[] };
+}
+
+export interface ISetTotalItems {
+	type: typeof SET_TOTAL_ITEMS;
+	payload: { totalItems: number };
+}
+
+export interface ISetImports {
+	type: typeof SET_IMPORTS;
+	payload: { imports: any };
+}
+
+export interface ISetTotalImports {
+	type: typeof SET_TOTAL_IMPORTS;
+	payload: { totalImports: number };
+}
+
+export type RedirectsActionsCreators = ISetRedirects | ISetTotalItems | ISetImports | ISetTotalImports;

package/src/containers/Redirects/reducer.tsx

@@ -0,0 +1,35 @@
+import type { IRedirect } from "@ax/types";
+import { SET_IMPORTS, SET_REDIRECTS, SET_TOTAL_IMPORTS, SET_TOTAL_ITEMS } from "./constants";
+import type { RedirectsActionsCreators } from "./interfaces";
+
+export interface IRedirectsState {
+	redirects: any[];
+	totalItems: number;
+	totalImports: number;
+	imports: null | {
+		error: IRedirect[];
+		existing: IRedirect[];
+		ok: IRedirect[];
+	};
+}
+
+export const initialState = {
+	redirects: [],
+	totalItems: 0,
+	totalImports: 0,
+	imports: null,
+};
+
+export function reducer(state = initialState, action: RedirectsActionsCreators): IRedirectsState {
+	switch (action.type) {
+		case SET_REDIRECTS:
+		case SET_TOTAL_ITEMS:
+		case SET_IMPORTS:
+		case SET_TOTAL_IMPORTS:
+			return { ...state, ...action.payload };
+		default:
+			return state;
+	}
+}
+
+export { initialState as redirectsInitialState, reducer as redirectsReducer };

package/src/containers/Settings/Languages/actions.tsx

@@ -0,0 +1,88 @@
+import type { Dispatch } from "redux";
+import type { ISiteLanguage } from "@ax/types";
+import { handleRequest } from "@ax/helpers";
+import { languages } from "@ax/api";
+import { appActions } from "@ax/containers/App";
+import { sitesActions } from "@ax/containers/Sites";
+import { UPDATE_FORM, CREATE_FORM } from "./constants";
+import { languagesInitialState } from "./reducer";
+
+const { setIsSaving, setIsLoading } = appActions;
+const { getSiteLanguages } = sitesActions;
+function setForm(form: any) {
+	return { type: CREATE_FORM, payload: { form } };
+}
+
+function updateForm(form: any) {
+	return { type: UPDATE_FORM, payload: { form } };
+}
+
+function updateFormValue(valueObj: any): (dispatch: Dispatch, getState: any) => void {
+	return (dispatch, getState) => {
+		const {
+			languages: { form },
+		} = getState();
+		const updatedForm = { ...form, ...valueObj };
+		dispatch(updateForm(updatedForm));
+	};
+}
+
+function resetForm(): (dispatch: Dispatch) => void {
+	return (dispatch) => {
+		const { form } = languagesInitialState;
+		dispatch(updateForm(form));
+	};
+}
+
+function createSiteLanguage(siteID: number, data: ISiteLanguage): (dispatch: Dispatch) => Promise<void> {
+	return async (dispatch) => {
+		try {
+			const responseActions = {
+				handleSuccess: () => getSiteLanguages(siteID)(dispatch),
+				handleError: (response: any) => appActions.handleError(response)(dispatch),
+			};
+
+			const callback = async () => languages.createSiteLanguage(siteID, data);
+
+			await handleRequest(callback, responseActions, [setIsSaving])(dispatch);
+		} catch (e) {
+			console.log(e); // TODO: capturar error bien
+		}
+	};
+}
+
+function updateSiteLanguage(siteID: number, data: ISiteLanguage): (dispatch: Dispatch) => Promise<void> {
+	return async (dispatch) => {
+		try {
+			const responseActions = {
+				handleSuccess: () => getSiteLanguages(siteID)(dispatch),
+				handleError: (response: any) => appActions.handleError(response)(dispatch),
+			};
+
+			const callback = async () => languages.updateSiteLanguage(siteID, data);
+
+			await handleRequest(callback, responseActions, [setIsSaving])(dispatch);
+		} catch (e) {
+			console.log(e); // TODO: capturar error bien
+		}
+	};
+}
+
+function deleteSiteLanguage(siteID: number, id: number): (dispatch: Dispatch) => Promise<void> {
+	return async (dispatch) => {
+		try {
+			const responseActions = {
+				handleSuccess: () => getSiteLanguages(siteID)(dispatch),
+				handleError: (response: any) => appActions.handleError(response)(dispatch),
+			};
+
+			const callback = async () => languages.deleteSiteLanguage(siteID, id);
+
+			await handleRequest(callback, responseActions, [setIsLoading])(dispatch);
+		} catch (e) {
+			console.log(e); // TODO: capturar error bien
+		}
+	};
+}
+
+export { createSiteLanguage, updateSiteLanguage, setForm, updateForm, updateFormValue, resetForm, deleteSiteLanguage };

package/src/containers/Settings/Languages/constants.tsx

@@ -0,0 +1,6 @@
+const NAME = "languages";
+
+const CREATE_FORM = `${NAME}/CREATE_FORM`;
+const UPDATE_FORM = `${NAME}/UPDATE_FORM`;
+
+export { NAME, CREATE_FORM, UPDATE_FORM };