@wikicasa-dev/utilities 0.1.1 → 0.1.2

package/src/services/publicUserAPI.ts

@@ -0,0 +1,216 @@
+import type {
+  PublicUser,
+  PublicUserMenuInfo,
+  SaveSearchBean,
+} from "@wikicasa-dev/types";
+
+import { getDefaultSaveSearchBean } from "@wikicasa-dev/types";
+import axios, { AxiosError } from "axios";
+import { handleAxiosError } from "./servicesUtils";
+
+//@ts-ignore
+const baseURL: string = window["_baseURLIt"];
+const baseController = `${baseURL}/rest/publicUser`;
+
+export const getMenuInfo = async (): Promise<PublicUserMenuInfo> => {
+  try {
+    const res = await axios.get(`${baseController}/getMenuInfo`);
+    return res.data as PublicUserMenuInfo;
+  } catch (error) {
+    handleAxiosError(error as AxiosError);
+    throw null;
+  }
+};
+
+export const getPublicUser = async (): Promise<PublicUser> => {
+  try {
+    const res = await axios.get(`${baseController}/getUser`);
+    return res.data as PublicUser;
+  } catch (err) {
+    handleAxiosError(err as AxiosError);
+    throw null;
+  }
+};
+
+export const getMarketingConsent = async (email: string): Promise<boolean> => {
+  try {
+    const res = await axios.get(
+      `${baseController}/getMarketingConsent?email=${email}`
+    );
+    return res.data as boolean;
+  } catch (error) {
+    handleAxiosError(error as AxiosError);
+    return false;
+  }
+};
+
+export const deleteAllSaveSearch = async (): Promise<number> => {
+  try {
+    const res = await axios.post(`${baseController}/deleteAllUserSaveSearch`);
+    return res.data as number;
+  } catch (err) {
+    handleAxiosError(err as AxiosError);
+    throw null;
+  }
+};
+
+export const deleteSaveSearch = async (id: number): Promise<string> => {
+  try {
+    const res = await axios.post(
+      `${baseController}/deleteUserSaveSearchParam/${id}`
+    );
+    return res.data as string;
+  } catch (error) {
+    handleAxiosError(error as AxiosError);
+    throw null;
+  }
+};
+
+export const getFavourites = async (): Promise<number[]> => {
+  try {
+    const res = await axios.get(`${baseController}/getFavouriteIdList`);
+    return res.data as number[];
+  } catch (error) {
+    handleAxiosError(error as AxiosError);
+    return [];
+  }
+};
+
+export const addUserFavorite = async (id: number): Promise<boolean> => {
+  try {
+    const res = await axios.post(`${baseController}/addUserFavourite/${id}`);
+    return res.data as boolean;
+  } catch (error) {
+    handleAxiosError(error as AxiosError);
+    return false;
+  }
+};
+
+export const deleteUserFavorite = async (id: number): Promise<boolean> => {
+  try {
+    const res = await axios.post(`${baseController}/deleteUserFavourite/${id}`);
+    return res.data as boolean;
+  } catch (error) {
+    handleAxiosError(error as AxiosError);
+    return false;
+  }
+};
+
+export const updateNote = async (
+  id: number,
+  note: string | null
+): Promise<boolean> => {
+  if (note === " " || note === "  ") return false;
+
+  try {
+    const res = await axios.post(`${baseController}/updateFavouriteNote`, {
+      realEstateId: id,
+      note: note,
+    });
+    return res.data as boolean;
+  } catch (error) {
+    handleAxiosError(error as AxiosError);
+    return false;
+  }
+};
+
+export const removeFavourites = async (): Promise<boolean> => {
+  try {
+    const res = await axios.post(`${baseController}/deleteAllUserFavourite`);
+    return res.data as boolean;
+  } catch (error) {
+    handleAxiosError(error as AxiosError);
+    return false;
+  }
+};
+
+export const saveUserFirebaseToken = async (
+  firebaseToken: string
+): Promise<boolean> => {
+  try {
+    if (!firebaseToken) return false;
+
+    await axios.post(
+      `${baseController}/refreshUserFirebaseToken?token=${firebaseToken}`
+    );
+    return true;
+  } catch (err) {
+    return false;
+  }
+};
+
+export const deleteUserFirebaseToken = async (
+  firebaseToken: string
+): Promise<boolean> => {
+  try {
+    await axios.delete(
+      `${baseController}/deleteUserFirebaseToken?token=${firebaseToken}`
+    );
+    return true;
+  } catch (error) {
+    return false;
+  }
+};
+
+export const updateMarketingConsent = async (data: {
+  email: string;
+  marketingConsent: boolean;
+}): Promise<boolean> => {
+  const { email, marketingConsent } = data;
+  try {
+    await axios.post(
+      `${baseController}/updateMarketingConsent?email=${email}&marketingConsent=${marketingConsent}`,
+      data
+    );
+    return true;
+  } catch (error) {
+    handleAxiosError(error as AxiosError);
+    return false;
+  }
+  /*    return $.ajax({
+            type: "POST",
+            contentType: "application/json",
+            data: JSON.stringify(data),
+            url: `/rest/publicUser/updateMarketingConsent?email=${email}&marketingConsent=${marketingConsent}`,
+        });*/
+};
+
+export const getPublicUserSaveSearchList = async (
+  offset = 0,
+  limit = 10
+): Promise<Array<any>> => {
+  try {
+    const res = await axios.get(
+      `${baseController}/getPublicUserSavedSearchBeanList/${offset}/${limit}`
+    );
+    return res.data as Array<SaveSearchBean>;
+  } catch (error) {
+    handleAxiosError(error as AxiosError);
+    return [];
+  }
+};
+export const updatePublicUserSavedSearchBean = async (
+  savedSearchBean: SaveSearchBean
+): Promise<SaveSearchBean> => {
+  try {
+    const res = await axios.post(
+      `${baseController}/updatePublicUserSavedSearchBean/`,
+      savedSearchBean
+    );
+    return res.data as SaveSearchBean;
+  } catch (error) {
+    handleAxiosError(error as AxiosError);
+    return getDefaultSaveSearchBean();
+  }
+};
+export const getSavedSearchesCount = async (): Promise<number> => {
+  try {
+    const res = await axios.get(
+      `${baseController}/getPublicUserSaveSearchCount`
+    );
+    return res.data as number;
+  } catch (error) {
+    handleAxiosError(error as AxiosError);
+    return 0;
+  }
+};

package/src/services/realEstateAPI.ts

@@ -0,0 +1,133 @@
+import axios, { AxiosError, AxiosResponse } from "axios";
+import { handleAxiosError } from "./servicesUtils";
+import type {
+  RealEstateSearchBean,
+  MapMarker,
+  RealEstateMiniItem,
+  Nullable,
+} from "@wikicasa-dev/types";
+import { deepCopy } from "@utils/ObjectUtils";
+
+declare global {
+  interface Window {
+    _serializedSearchBean?: Nullable<any>;
+    _locale: string;
+  }
+}
+
+//@ts-ignore
+const baseUrl: string = window["_baseURLIt"];
+const baseController = `${baseUrl}/rest/realEstate`;
+
+export const getRealEstateNotes = async (
+  realEstateId: number
+): Promise<string> => {
+  try {
+    const res = await axios.post(
+      `${baseUrl}/rest/publicUser/getRealEstateNotes/${realEstateId}`
+    );
+    return res.data;
+  } catch (error) {
+    handleAxiosError(error as AxiosError);
+    return "";
+  }
+};
+
+export const saveSearch = async (
+  email: string,
+  title: string,
+  hourly: boolean,
+  resb: RealEstateSearchBean,
+  pushNotifications = false
+): Promise<AxiosResponse> => {
+  if (!email || !resb) throw `Email or resb are not valid, ${email}, ${resb}`;
+
+  //TODO: solo per testing dato che bisogna chiedere il consenso all'utente
+  return await axios.post(
+    `${baseController}/saveSearch?email=${email}&title=${title}&hourly=${hourly}&pushNotifications=${pushNotifications}`,
+    resb
+  );
+  // return await axios.post(`${baseController}/saveSearch?email=${email}&title=${title}&hourly=${hourly}`, resb);
+};
+
+export const saveSearchFromRequest = async (
+  email: string,
+  searchBean: RealEstateSearchBean,
+  pushNotifications = false
+): Promise<boolean> => {
+  try {
+    const title = "Ricerca salvata";
+    //TODO: solo per testing dato che bisogna chiedere il consenso all'utente
+    const res = await axios.post(
+      `${baseController}/saveSearch?email=${email}&title=${title}&pushNotifications=${pushNotifications}`,
+      searchBean
+    );
+    // const res = await axios.post(`/rest/realEstate/saveSearch?email=${email}`, searchBean);
+    return res.data as boolean;
+  } catch (error) {
+    handleAxiosError(error as AxiosError);
+    throw error;
+  }
+};
+
+export const getRealEstateCounter = async (
+  resb: RealEstateSearchBean
+): Promise<number | null> => {
+  const tempSB = deepCopy(resb);
+  /* Use polygon for DB only if it already set */
+  if (tempSB!.polygonForDB) {
+    tempSB!.polygonFromMap = tempSB!.polygonForDB || "";
+  }
+
+  /* SOREX: BRUTAL FIX COUNTER NUOVE COSTRUZIONI */
+  if (tempSB?.listingTypologyIdList?.includes(15)) {
+    tempSB.conditionType = 5;
+  }
+
+  const res = await axios.post("/rest/realEstate/countRealEstateES", tempSB);
+  return (await res.data) as number | null;
+};
+
+export const getRealEstatesData = async (
+  ids: Array<number>
+): Promise<Array<RealEstateMiniItem> | null> => {
+  try {
+    const res = await axios.post(
+      `${baseUrl}/rest/realEstate/getRealEstateListForInfoWindow/${window["_locale"]}`,
+      ids
+    );
+    return res.data;
+  } catch (e) {
+    handleAxiosError(e as AxiosError);
+    return null;
+  }
+};
+
+export const getMapMarkers = async (): Promise<
+  Array<MapMarker> | undefined
+> => {
+  if (!window["_serializedSearchBean"]) return [];
+
+  const searchBean = deepCopy(JSON.parse(window["_serializedSearchBean"]));
+
+  delete searchBean["latitude"];
+  delete searchBean["longitude"];
+
+  try {
+    const res = await axios.post(
+      `${baseUrl}/rest/realEstate/getMapMarkers`,
+      searchBean,
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+        },
+      }
+    );
+
+    return res.data as MapMarker[];
+  } catch (err) {
+    handleAxiosError(err as AxiosError);
+    throw [];
+  }
+};

package/src/services/requestAPI.ts

@@ -0,0 +1,40 @@
+import axios, { AxiosError } from "axios";
+import type { Contacts } from "@wikicasa-dev/types";
+import { baseURL, handleAxiosError } from "./servicesUtils";
+
+const baseController = `${baseURL}/rest/request`;
+
+export const sendSuggestion = async (suggestion: {
+  argument: string;
+  email: string;
+  message: string;
+  privacy: boolean;
+  url: string;
+}): Promise<boolean> => {
+  const res = await axios.post(`${baseController}/sendSuggestion`, suggestion);
+  return res.data as boolean;
+};
+
+export const addGenericRequest = async (data: Contacts): Promise<boolean> => {
+  try {
+    const res = await axios.post("/rest/request/addRequestGeneric", data);
+    return res.data;
+  } catch (error) {
+    handleAxiosError(error as AxiosError);
+    throw error;
+  }
+};
+
+export const sendWidgetRequest = async (suggestion: {
+  name: string;
+  company: string;
+  email: string;
+  phone: string;
+  privacy: boolean;
+}): Promise<boolean> => {
+  const res = await axios.post(
+    `${baseController}/sendWidgetRequest`,
+    suggestion
+  );
+  return res.data as boolean;
+};

package/src/services/servicesUtils.ts

@@ -0,0 +1,27 @@
+import { AxiosError } from "axios";
+
+declare global {
+  interface Window {
+    _baseURLIt: string;
+  }
+}
+
+export const baseURL: string = window["_baseURLIt"];
+
+export const handleAxiosError = (error: AxiosError): void => {
+  const cause = `errorMessage: ${error.message} \n`;
+  //ErrorCode !== 200 with server response
+  if (error.response) {
+    console.error(
+      `${cause} errorCode: ${error.response.status} \\n ${error.request.data}`
+    );
+  }
+  //ErrorCode !== 200 WITHOUT server response
+  else if (error.request) {
+    console.error(`${cause} \n ${error.request}`);
+  }
+  //Error in request setup
+  else {
+    console.error(cause);
+  }
+};

package/src/services/statisticsAPI.ts

@@ -0,0 +1,84 @@
+import type { Place, GraphData } from "@wikicasa-dev/types";
+import axios, { AxiosError } from "axios";
+import { handleAxiosError } from "./servicesUtils";
+
+const baseStatisticControllerUrl = "/rest/statistics";
+
+export const updateViewListing = async (
+  data: Array<{ agencyId: number; realEstateId: number }>
+): Promise<boolean> => {
+  try {
+    await axios.post(`${baseStatisticControllerUrl}/updateViewListing/W`, data);
+    return true;
+  } catch (error) {
+    handleAxiosError(error as AxiosError);
+    return false;
+  }
+};
+
+export const updateRealEstateSearch = async (
+  realEstateSearchBean: any
+): Promise<boolean> => {
+  try {
+    axios.post(
+      `${baseStatisticControllerUrl}/updateRealEstateSearch`,
+      realEstateSearchBean
+    );
+    return true;
+  } catch (error) {
+    handleAxiosError(error as AxiosError);
+    return false;
+  }
+};
+
+export const updatePhoneView = async (
+  agencyId: number,
+  id: number
+): Promise<boolean> => {
+  try {
+    const res = await axios.post(
+      id
+        ? `${baseStatisticControllerUrl}/updatePhoneView/${agencyId}/${id}/W`
+        : `/rest/statistics/updatePhoneView/${agencyId}/W`
+    );
+    return res.data;
+  } catch (error) {
+    handleAxiosError(error as AxiosError);
+    throw error;
+  }
+};
+export const getPlaceTrendData = async (place: Place): Promise<any> => {
+  try {
+    const promiseSale = await axios.post(
+      `${baseStatisticControllerUrl}/getPlaceTrendData?sale=${true}`,
+      place
+    );
+    const promiseRent = await axios.post(
+      `${baseStatisticControllerUrl}/getPlaceTrendData?sale=${false}`,
+      place
+    );
+    return Promise.all([promiseSale, promiseRent]);
+  } catch (error) {
+    handleAxiosError(error as AxiosError);
+    throw error;
+  }
+};
+
+export const getSaleGraphData = async (
+  place: Place,
+  filters: any = {
+    contract: "sale",
+    macroTypologyId: 1,
+  }
+): Promise<GraphData[]> => {
+  try {
+    const res = await axios.post(
+      `${baseStatisticControllerUrl}/getAveragePriceGraphData/${filters.contract}/${filters.macroTypologyId}`,
+      place
+    );
+    return res.data;
+  } catch (error) {
+    handleAxiosError(error as AxiosError);
+    throw error;
+  }
+};

package/src/services/valuationAPI.ts

@@ -0,0 +1,45 @@
+import axios, { AxiosError } from "axios";
+import type { PublicValuation, Nullable } from "@wikicasa-dev/types";
+import { handleAxiosError, baseURL } from "@services/servicesUtils";
+import { appendQueryString } from "@utils/URLBuilderUtils";
+
+const baseController = `/rest/wikicasaPro`;
+
+export interface ValuationResult
+  extends Record<string, number | boolean | undefined> {
+  valid: boolean;
+  upper: number;
+  mean: number;
+  lower: number;
+  estimated: number;
+  count: number;
+  maxDistance?: number;
+}
+
+// eslint-disable-next-line max-len
+export const evaluateRealEstateWidget = async (
+  publicValuation: PublicValuation,
+  token: Nullable<string>,
+  conditionTypeId = undefined as number | undefined,
+  floor = undefined as number | undefined
+): Promise<PublicValuation> => {
+  if (!token) throw new Error("The token can't be null");
+
+  try {
+    let params: Record<string, any> = { token: token };
+
+    if (conditionTypeId) params = { ...params, conditionTypeId };
+    if (floor != undefined) params = { ...params, floor };
+
+    const url = appendQueryString(
+      new URL(`${baseURL}${baseController}/evaluateRealEstateWidget`),
+      params
+    );
+    const res = await axios.post(url.toString(), publicValuation);
+    res.data.valid = !!res.data.valid;
+    return res.data as PublicValuation;
+  } catch (error) {
+    handleAxiosError(error as AxiosError);
+    throw error;
+  }
+};

package/src/services/wikicasaPro.ts

@@ -0,0 +1,25 @@
+import axios, { AxiosError } from "axios";
+import { handleAxiosError } from "./servicesUtils";
+import type { FEEDBACK } from "@wikicasa-dev/types/dist/index";
+
+const baseStatisticControllerUrl = "/rest/wikicasaPro";
+
+export const userValuationWithPhotoFeedback = async (
+  email: string,
+  token: string,
+  feedback: FEEDBACK,
+  userFeedbackValue: number = 0
+): Promise<boolean> => {
+  try {
+    // eslint-disable-next-line max-len
+    const res = await axios.post(
+      `${baseStatisticControllerUrl}/userValuationWithPhotoFeedback/?email=${email}&token=${token}&feedback=${feedback}${
+        userFeedbackValue > 0 ? "&userFeedbackValue=" + userFeedbackValue : ""
+      }`
+    );
+    return res.data;
+  } catch (error) {
+    handleAxiosError(error as AxiosError);
+    throw error;
+  }
+};

package/src/utils/AppRedirectUtils.ts

@@ -0,0 +1,26 @@
+export const redirectToApp = (
+  eventLocation: "Banner" | "MenuUserModal" = "Banner"
+): void => {
+  if (window.navigator.userAgent.includes("iPhone")) {
+    //firefox on ios can't open the app
+    if (!window.navigator.userAgent.match(/firefox|fxios/i))
+      window.location.replace("wikicasa://");
+
+    setTimeout(() => {
+      window.location.replace(
+        "https://apps.apple.com/it/app/wikicasa/id1626038379"
+      );
+    }, 500);
+  } else if (window.navigator.userAgent.includes("Android")) {
+    const url =
+      "intent://wikicasa.it/#Intent;scheme=https;package=it.wikicasa.wikicasa_app;end";
+    window.location.replace(url);
+  }
+  //@ts-ignore
+  window.dataLayer.push({
+    //GA4
+    event_name: "open_store",
+    event_location: eventLocation,
+    OS: window.navigator?.userAgent,
+  });
+};

package/src/utils/ArrayUtils.ts

@@ -0,0 +1,2 @@
+export const isArrNullOrEmpty = (arrToCheck?: any[]): boolean =>
+  !arrToCheck?.length;

package/src/utils/ColorUtils.ts

@@ -0,0 +1,11 @@
+/**
+ * @return {string}
+ */
+export function rgba(hex: string, opacity: number): string {
+  hex = hex.replace("#", "");
+  const r = parseInt(hex.substring(0, 2), 16);
+  const g = parseInt(hex.substring(2, 4), 16);
+  const b = parseInt(hex.substring(4, 6), 16);
+
+  return `rgba(${r}, ${g}, ${b}, ${opacity})`;
+}

package/src/utils/CookieUtils.ts

@@ -0,0 +1,43 @@
+import * as Cookie from "js-cookie";
+
+export function encodeCookie<T>(
+  name: string,
+  obj: T,
+  days: number = 30,
+  encodeObj = true
+): void {
+  const d = new Date();
+  d.setTime(d.getTime() + 24 * 60 * 60 * 1000 * days);
+
+  const stringObj = typeof obj !== "string" ? JSON.stringify(obj) : obj;
+  const cookieValue = encodeObj
+    ? btoa(encodeURIComponent(stringObj))
+    : stringObj;
+  document.cookie =
+    name + "=" + cookieValue + ";path=/;expires=" + d.toUTCString();
+}
+
+export function getCookie(name: string): string | null {
+  try {
+    const v = document.cookie.match("(^|;) ?" + name + "=([^;]*)(;|$)");
+    return v ? v[2] : null;
+  } catch (e) {
+    console.error(e);
+    return null;
+  }
+}
+
+export function decodeCookie(name: string): any {
+  try {
+    const v = document.cookie.match("(^|;) ?" + name + "=([^;]*)(;|$)");
+    return v ? JSON.parse(decodeURIComponent(atob(v[2]))) : null;
+  } catch (e) {
+    console.error(e);
+    removeCookie(name);
+    return null;
+  }
+}
+
+export function removeCookie(name: string): void {
+  Cookie.remove(name);
+}

package/src/utils/CurrencyUtils.ts

@@ -0,0 +1,18 @@
+import { shallowCopyObjectTo } from "@utils/ObjectUtils";
+
+export const formatCurrency = (
+  numberToFormat: number | undefined,
+  options?: Intl.NumberFormatOptions,
+  locale = "it-IT"
+): string => {
+  if (numberToFormat === undefined) return `0`;
+
+  const _options: Partial<Intl.NumberFormatOptions> = {
+    style: "currency",
+    currency: "EUR",
+    maximumFractionDigits: 0,
+  };
+  shallowCopyObjectTo(options, _options);
+
+  return new Intl.NumberFormat(locale, _options).format(numberToFormat);
+};