Merge pull request #1049 from singnet/users-development

Marketplace refactoring

Author: elmiringos

package.json

@@ -55,7 +55,7 @@
   },
   "resolutions": {
     "concat-stream": "github:singnet/concat-stream",
-    "zod": "3.21.4" 
+    "zod": "3.21.4"
   },
   "overrides": {
     "rimraf": "^4.0.0",

scripts/sitemap-generator.js

@@ -7,11 +7,11 @@ require("@babel/register")({
 const defaultPagination = {
   q: "",
   limit: 50,
-  offset: 0,
-  total_count: 0,
+  page: 1,
+  totalCount: 0,
   s: "all",
-  sort_by: "ranking",
-  order_by: "asc",
+  sort: "ranking",
+  order: "asc",
   filters: [],
 };
 
@@ -24,17 +24,17 @@ async function fetchServices(pagination = defaultPagination, step = 50) {
       data: { data },
     } = await axios.post(url, pagination);
     const { result } = data;
-    console.log("offset", data.offset);
+    console.log("page", data.page);
     console.log("limit", data.limit);
     console.log("services length", services.length);
-    console.log("total count", data.total_count);
+    console.log("total count", data.totalCount);
     console.log("-----****-----");
     services = services.concat(result);
-    if (services.length < data.total_count) {
+    if (services.length < data.totalCount) {
       const enhancedPagination = Object.assign({}, pagination, {
-        offset: pagination.offset + step,
+        page: pagination.page + step,
       });
-      if (enhancedPagination.offset > data.total_count) {
+      if (enhancedPagination.page > data.totalCount) {
         throw new Error("Trying to fetch more than total count");
       }
       await fetchServices(enhancedPagination);
@@ -55,8 +55,8 @@ async function generateSitemap() {
   await fetchServices();
   console.log("fetched all services");
   const idMap = services.map((service) => ({
-    orgId: service.org_id,
-    serviceId: service.service_id,
+    orgId: service.orgId,
+    serviceId: service.serviceId,
   }));
 
   const activeUserTabsMap = ["account", "settings", "transactions"].map((tab) => ({ "activeTab?": tab }));

src/App.js

@@ -51,16 +51,17 @@ initGDPRNotification();
 
 const App = () => {
   const isLoggedIn = useSelector((state) => state.userReducer.login.isLoggedIn);
-  const isTermsAccepted = useSelector((state) => state.userReducer.isTermsAccepted);
+  const isTermsAccepted = useSelector((state) => state.userReducer.isTermsAccepted.accepted);
   const isInitialized = useSelector((state) => state.userReducer.isInitialized);
 
   const isLoggedInAndTermsAccepted = isLoggedIn && isTermsAccepted;
-  const isNotLoggedInPageAvailable = !isLoggedIn || isTermsAccepted;
+  const isNotLoggedInPageAvailable = !isLoggedIn || isLoggedInAndTermsAccepted;
 
   const dispatch = useDispatch();
 
   useEffect(() => {
     dispatch(userActions.fetchUserDetails());
+    dispatch(userActions.getIsTermsAcceptedInfo());
   }, [dispatch]);
 
   const Loader = () => {

src/Redux/actionCreators/ServiceActions.js

@@ -1,8 +1,7 @@
 import { APIEndpoints, APIPaths } from "../../config/APIEndpoints";
 import { loaderActions, userActions } from "./";
 import { getAPI, postAPI, initializeAPIOptions } from "../../utility/API";
-import { generateOrganizationsFilterObject } from "../../utility/constants/Pagination";
-// import { cacheS3Url } from "../../utility/image";
+import { defaultActiveFilterItem } from "../../utility/constants/Pagination";
 
 export const UPDATE_SERVICE_LIST = "SET_SERVICE_LIST";
 export const UPDATE_PAGINATION_DETAILS = "SET_PAGINATION_DETAILS";
@@ -13,18 +12,23 @@ export const UPDATE_FILTER_DATA = "UPDATE_FILTER_DATA";
 export const UPDATE_ACTIVE_FILTER_ITEM = "UPDATE_ACTIVE_FILTER_ITEM";
 export const RESET_FILTER_ITEM = "RESET_FILTER_ITEM";
 export const UPDATE_FEEDBACK = "UPDATE_FEEDBACK";
+export const UPDATE_SRVICE_COUNT = "UPDATE_SRVICE_COUNT";
 
 export const updateActiveFilterItem = (activeFilterItem) => (dispatch) => {
   dispatch({ type: UPDATE_ACTIVE_FILTER_ITEM, payload: { ...activeFilterItem } });
 };
 
+const updateServicesTotalCount = (totalCount) => (dispatch) => {
+  dispatch({ type: UPDATE_SRVICE_COUNT, payload: totalCount });
+};
+
 export const resetFilterItem = (dispatch) => {
   dispatch({ type: RESET_FILTER_ITEM });
 };
 
 export const fetchServiceSuccess = (res) => (dispatch) => {
-  dispatch(updatePagination({ total_count: res.data.total_count }));
-  dispatch({ type: UPDATE_SERVICE_LIST, payload: res.data.result });
+  dispatch(updateServicesTotalCount(res.totalCount));
+  dispatch({ type: UPDATE_SERVICE_LIST, payload: res.services });
   dispatch(loaderActions.stopAIServiceListLoader());
 };
 
@@ -38,29 +42,26 @@ export const fetchUserOrganizationsList = () => async (dispatch) => {
 
 const onlyUserOrgsFilter = () => async (dispatch) => {
   const userOrganizations = await dispatch(fetchUserOrganizationsList());
-  const userOrganizationsId = userOrganizations.data.map((organization) => organization.org_id);
-  const filterObj = generateOrganizationsFilterObject([
-    ...userOrganizationsId,
-    process.env.REACT_APP_EXAMPLE_SERVICE_ORG_ID,
-  ]);
+  const userOrganizationsId = userOrganizations.data.map((organization) => organization.orgId);
+  const filterObj = { orgId: [...userOrganizationsId, process.env.REACT_APP_EXAMPLE_SERVICE_ORG_ID] };
   return filterObj;
 };
 
 export const fetchService =
-  (pagination, filters = []) =>
+  (pagination, filter = defaultActiveFilterItem) =>
   async (dispatch) => {
     // env variable is string
     if (process.env.REACT_APP_IS_ALL_SERVICES_AVAILIBLE !== "true") {
-      filters = await dispatch(onlyUserOrgsFilter());
+      filter = await dispatch(onlyUserOrgsFilter());
     }
     dispatch(loaderActions.startAIServiceListLoader());
     const url = new URL(APIEndpoints.CONTRACT.endpoint + APIPaths.GET_SERVICE_LIST);
     return fetch(url, {
       method: "POST",
-      body: JSON.stringify({ ...pagination, filters }),
+      body: JSON.stringify({ ...pagination, filter }),
     })
       .then((res) => res.json())
-      .then((res) => dispatch(fetchServiceSuccess(res)))
+      .then((res) => dispatch(fetchServiceSuccess(res.data)))
       .catch(() => dispatch(loaderActions.stopAIServiceListLoader()));
   };
 
@@ -80,18 +81,14 @@ export const fetchFilterData = (attribute) => (dispatch) => {
     });
 };
 
-export const handleFilterChange =
-  ({ pagination, filterObj, currentActiveFilterData }) =>
-  (dispatch) => {
-    dispatch(loaderActions.startAIServiceListLoader());
-    Promise.all([
-      dispatch(updatePagination(pagination)),
-      dispatch(fetchService(pagination, filterObj)),
-      dispatch(updateActiveFilterItem(currentActiveFilterData)),
-    ])
-      .then(() => dispatch(loaderActions.stopAIServiceListLoader()))
-      .catch(() => dispatch(loaderActions.stopAIServiceListLoader()));
-  };
+export const handleFilterChange = (pagination, filter) => async (dispatch) => {
+  dispatch(loaderActions.startAIServiceListLoader());
+  dispatch(updatePagination(pagination));
+  dispatch(updateActiveFilterItem(filter));
+
+  await dispatch(fetchService(pagination, filter));
+  dispatch(loaderActions.stopAIServiceListLoader());
+};
 
 export const resetFilter =
   ({ pagination }) =>
@@ -104,7 +101,7 @@ export const resetFilter =
 
 const fetchFeedbackAPI = (orgId, serviceId, token) => {
   const apiName = APIEndpoints.USER.name;
-  const path = `${APIPaths.FEEDBACK}?org_id=${orgId}&service_id=${serviceId}`;
+  const path = `${APIPaths.FEEDBACK}?orgId=${orgId}&serviceId=${serviceId}`;
   const apiOptions = initializeAPIOptions(token);
   return getAPI(apiName, path, apiOptions);
 };
@@ -125,12 +122,10 @@ const submitFeedbackAPI = (feedbackObj, token) => {
 export const submitFeedback = (orgId, serviceId, feedback) => async (dispatch) => {
   const { token } = await dispatch(userActions.fetchAuthenticatedUser());
   const feedbackObj = {
-    feedback: {
-      org_id: orgId,
-      service_id: serviceId,
-      user_rating: parseFloat(feedback.rating).toFixed(1),
-      comment: feedback.comment,
-    },
+    orgId,
+    serviceId,
+    userRating: Number(parseFloat(feedback.rating).toFixed(1)),
+    comment: feedback.comment,
   };
   return submitFeedbackAPI(feedbackObj, token);
 };

src/Redux/actionCreators/ServiceDetailsActions.js

@@ -14,7 +14,7 @@ export const UPDATE_FREE_CALLS_INFO = "UPDATE_FREE_CALLS_INFO";
 export const UPDATE_TRAINING_DETAILS = "UPDATE_TRAINING_DETAILS";
 export const UPDATE_FREECALL_SIGNATURE = "UPDATE_FREECALL_SIGNATURE";
 
-const resetServiceDetails = (dispatch) => {
+const resetServiceDetails = () => (dispatch) => {
   dispatch({ type: RESET_SERVICE_DETAILS });
 };
 
@@ -37,18 +37,37 @@ const fetchServiceDetailsAPI = async (orgId, serviceId) => {
   return response.json();
 };
 
-export const fetchServiceDetails = (orgId, serviceId) => async (dispatch) => {
-  try {
-    dispatch(loaderActions.startAppLoader(LoaderContent.FETCH_SERVICE_DETAILS));
-    dispatch(resetServiceDetails);
-    dispatch(resetCurrentModelDetails());
-    dispatch(resetModelList());
-    const { data: serviceDetails } = await fetchServiceDetailsAPI(orgId, serviceId);
-    dispatch(fetchServiceDetailsSuccess(serviceDetails));
-  } catch (error) {
-    dispatch(fetchServiceDetailsFailure(error));
-    throw error;
+const enhanceGroup = (group) => ({ ...group, endpoints: group.endpoints.map(({ endpoint }) => endpoint) });
+
+const parseGroupInfo = (groups) => {
+  const serviceGroups = groups;
+  const availableGroup = serviceGroups.find(({ endpoints }) =>
+    endpoints.some((endpoint) => endpoint.isAvailable === 1)
+  );
+  if (availableGroup) {
+    return enhanceGroup(availableGroup);
+  }
+  const firstGroup = serviceGroups[0];
+  if (firstGroup) {
+    return enhanceGroup(firstGroup);
+  }
+};
+
+const parsePricing = (group) => {
+  if (!group) {
+    return {};
   }
+
+  return group.pricing.find((price) => price.default === true);
+};
+
+const parseServiceDetails = (service) => {
+  const groupInfo = parseGroupInfo(service.groups);
+  return {
+    ...service,
+    groupInfo,
+    pricing: parsePricing(groupInfo),
+  };
 };
 
 const fetchMeteringDataSuccess = (freeCallsAvailable, freeCallsTotal) => (dispatch) => {
@@ -65,22 +84,27 @@ const fetchTrainingModelSuccess = (serviceTrainingData) => (dispatch) => {
   dispatch({ type: UPDATE_TRAINING_DETAILS, payload: serviceTrainingData });
 };
 
-const fetchServiceTrainingDataAPI = async (orgId, serviceId) => {
+export const fetchServiceDetails = (orgId, serviceId) => async (dispatch) => {
+  if (!orgId || !serviceId) {
+    console.error("orgId: ", orgId, "serviceId: ", serviceId);
+    return;
+  }
+
   try {
-    const dataForUrl = await fetchServiceDetailsAPI(orgId, serviceId);
-    const url = `${dataForUrl.data.groups[0].endpoints[0].endpoint}/heartbeat`;
-    const response = await fetch(url);
-    return response.json();
+    dispatch(loaderActions.startAppLoader(LoaderContent.FETCH_SERVICE_DETAILS));
+    dispatch(resetServiceDetails());
+    dispatch(resetCurrentModelDetails());
+    dispatch(resetModelList());
+    const { data: serviceDetails } = await fetchServiceDetailsAPI(orgId, serviceId);
+    const parsedServiceDetails = parseServiceDetails(serviceDetails);
+    dispatch(fetchServiceDetailsSuccess(parsedServiceDetails));
+    dispatch(fetchTrainingModelSuccess(serviceDetails));
   } catch (error) {
-    return {};
+    dispatch(fetchServiceDetailsFailure(error));
+    throw error;
   }
 };
 
-export const fetchTrainingModel = (orgId, serviceId) => async (dispatch) => {
-  const serviceTrainingData = await fetchServiceTrainingDataAPI(orgId, serviceId);
-  dispatch(fetchTrainingModelSuccess(serviceTrainingData));
-};
-
 const getAvailableFreeCalls = (orgId, serviceId, groupId) => async (dispatch) => {
   const {
     signature,

src/Redux/actionCreators/ServiceTrainingActions.js

@@ -105,15 +105,6 @@ export const deleteModel = (organizationId, serviceId, modelId, methodName, serv
   }
 };
 
-// export const getServiceName = () => (getState) => {
-//   // const { serviceDetailsReducer, serviceTrainingReducer } = getState();
-//   // if (serviceTrainingReducer.serviceName) {
-//   //   return serviceTrainingReducer.serviceName;
-//   // }
-//   const training = serviceDetailsReducer.training;
-//   return getServiceNameFromTrainingMethod(training.trainingMethods[0]);
-// };
-
 const getServiceNameFromTrainingMethod = (trainingMethod) => {
   return trainingMethod.split(".")[1].split("/")[0];
 };