@meetelise/chat 1.35.0 → 1.35.2

package/src/rentgrata.ts

@@ -0,0 +1,74 @@
+import axios from "axios";
+
+export const openRengrataWidget = (): void => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const rentgrata = (window as any).rentgrata;
+  if (!rentgrata) {
+    return;
+  }
+  const rentgrataWidget = rentgrata.Widget;
+  if (!rentgrataWidget) {
+    return;
+  }
+  if (!rentgrataWidget.openWidget) {
+    return;
+  }
+  rentgrataWidget.openWidget();
+};
+
+export const closeRengrataWidget = (): void => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const rentgrata = (window as any).rentgrata;
+  if (!rentgrata) {
+    return;
+  }
+  const rentgrataWidget = rentgrata.Widget;
+  if (!rentgrataWidget) {
+    return;
+  }
+  if (!rentgrataWidget.openWidget) {
+    return;
+  }
+  rentgrataWidget.close();
+};
+
+export const hasRentgrata = (): boolean => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return !!(window as any).rentgrata;
+};
+
+export const updateRentgrataToken = async (
+  buildingSlug: string,
+  orgSlug: string
+): Promise<void> => {
+  const host = "https://app.meetelise.com";
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const rentgrata = (window as any).rentgrata;
+  if (!rentgrata) {
+    return;
+  }
+  const rentgrataWidget = rentgrata.Widget;
+  if (!rentgrataWidget) {
+    return;
+  }
+  const rentgrataConfig = rentgrataWidget.config;
+  if (!rentgrataConfig) {
+    return;
+  }
+
+  const widgetKey = rentgrataConfig.widgetKey;
+  if (!widgetKey) {
+    return;
+  }
+  await axios.post(
+    `${host}/platformApi/webchat/rentgrata?token=${widgetKey}`,
+    {},
+    {
+      headers: {
+        "Content-Type": "application/json",
+        "building-slug": buildingSlug ?? "",
+        "org-slug": orgSlug ?? "",
+      },
+    }
+  );
+};

package/src/replaceSelectButtonsWithNewLink.ts

@@ -0,0 +1,91 @@
+/**
+ * Script to find all application links/buttons on a page and replace them with a
+ * new elise application link.
+ */
+import { LogType, sendLoggingEvent } from "./analytics";
+
+/**
+ * Script to find all "Select" buttons with specific URL patterns and replace them with a
+ * new application link.
+ */
+export const replaceSelectButtonsWithNewLink = (
+  newApplicationLink: string,
+  orgSlug: string,
+  buildingSlug?: string
+): number => {
+  const urlPatterns = [
+    /thehavenatgreenhill\.securecafe\.com\/onlineleasing\/the-haven-at-greenhill\/oleapplication\.aspx(\?.*)?$/,
+    /securecafe\.com\/onlineleasing.*\/oleapplication\.aspx(\?.*)?$/,
+    /\/onlineleasing.*\/oleapplication\.aspx(\?.*)?$/,
+    /vsc\.myresman\.com\/Portal\/Applicants\/Availability(\?.*)?$/,
+    /vsc\.myresman\.com\/Portal\/Applicants\/New\/.*(\?.*)?$/,
+  ];
+
+  const allElements = document.body.getElementsByTagName("a");
+
+  let totalReplacements = 0;
+
+  for (let i = 0; i < allElements.length; i++) {
+    const element = allElements[i] as HTMLAnchorElement;
+    if (element.nodeType !== Node.ELEMENT_NODE) continue;
+
+    const matchesUrlPattern = urlPatterns.some((pattern) =>
+      pattern.test(element.href)
+    );
+    const isSelectButtonWithUrl = matchesUrlPattern;
+
+    if (isSelectButtonWithUrl) {
+      const oldHref = element.getAttribute("href");
+
+      const buttonText = element.textContent?.toLowerCase() || "";
+      // Check if button text contains variations of "floor plan" (case insensitive)
+      const finalLink = getMutatedApplicationLink(
+        buttonText,
+        newApplicationLink
+      );
+
+      element.setAttribute("href", finalLink);
+      totalReplacements++;
+
+      sendLoggingEvent({
+        logTitle: "SELECT_BUTTON_LINK_REPLACEMENT",
+        logData: {
+          type: "link-replacement",
+          oldHref,
+          newHref: finalLink,
+          website: window.location.href,
+        },
+        logType: LogType.info,
+        buildingSlug,
+        orgSlug,
+      });
+    }
+  }
+
+  if (totalReplacements === 0) {
+    sendLoggingEvent({
+      logTitle: "SELECT_BUTTON_LINK_REPLACEMENT",
+      logData: {
+        type: "no-select-buttons-found",
+        website: window.location.href,
+      },
+      logType: LogType.warn,
+      buildingSlug,
+      orgSlug,
+    });
+  }
+
+  return totalReplacements;
+};
+
+const getMutatedApplicationLink = (
+  buttonText: string,
+  newApplicationLink: string
+) => {
+  const relevantText = ["floor plan", "floorplan", "floor plans", "floorplans"];
+  if (relevantText.some((t) => buttonText.toLowerCase().includes(t))) {
+    return `${newApplicationLink}/units`;
+  }
+
+  return newApplicationLink;
+};

package/src/services/fees/calculateQuote.ts

@@ -0,0 +1,74 @@
+import axios from "axios";
+
+import { LogType, sendLoggingEvent } from "../../analytics";
+import { camelize, snakify } from "../../utils";
+import {
+  DesiredAddon,
+  DesiredRentableItem,
+  UnitFeeBundle,
+} from "../../WebComponent/FeeCalculator/model";
+import { FeeEstimate } from "../../WebComponent/FeeCalculator/model/unit-fee-bundle";
+import { BASE_DOMAIN } from "../../globals";
+
+type CalculateQuoteRequest = {
+  buildingSlug: string;
+  unitId: number;
+  addons: DesiredAddon[];
+  rentableItems: DesiredRentableItem[];
+  leaseTerm: number;
+  moveInDate: string;
+};
+
+export type CalculateQuoteResponse = {
+  units: UnitFeeBundle[];
+};
+
+const BASE_URL = BASE_DOMAIN;
+
+export const calculateQuote = async ({
+  buildingSlug,
+  unitId,
+  addons,
+  rentableItems,
+  leaseTerm,
+  moveInDate,
+}: CalculateQuoteRequest): Promise<CalculateQuoteResponse> => {
+  try {
+    const feesResponse = await axios.post(
+      `${BASE_URL}/platformApi/webchat/${buildingSlug}/fees/calculate`,
+      snakify({
+        unitId,
+        addons,
+        rentableItems,
+        leaseTerm,
+        moveInDate,
+      })
+    );
+
+    if (feesResponse.data) {
+      const data = camelize<CalculateQuoteResponse>(feesResponse.data);
+      return {
+        ...data,
+        units: data.units.map((unit) => ({
+          ...unit,
+          fees: unit.fees.map(toFeeEstimateClass),
+        })),
+      };
+    }
+  } catch (error) {
+    sendLoggingEvent({
+      logType: LogType.error,
+      buildingSlug,
+      logTitle: "[ERROR_CALCULATING_QUOTE]",
+      logData: { error },
+    });
+  }
+
+  return {
+    units: [],
+  };
+};
+
+const toFeeEstimateClass = (fee: FeeEstimate) => new FeeEstimate(fee);
+
+export default calculateQuote;

package/src/services/fees/fetchBuildingFees.ts

@@ -0,0 +1,50 @@
+import axios from "axios";
+import { LogType, sendLoggingEvent } from "../../analytics";
+import { BuildingFee } from "../../WebComponent/FeeCalculator/model/building-fee";
+import { camelize } from "../../utils";
+import { IncentiveV2 } from "../../types/incentive-v2";
+import { RentableItemSummary } from "../../WebComponent/FeeCalculator/model/rentable-item-summary";
+import { BASE_DOMAIN } from "../../globals";
+
+const BASE_URL = BASE_DOMAIN;
+
+type BuildingFeeResponse = {
+  fees: BuildingFee[];
+  rentableItems: RentableItemSummary[];
+  buildingIncentives: IncentiveV2[];
+};
+
+const fetchBuildingFees = async (
+  buildingSlug: string
+): Promise<BuildingFeeResponse> => {
+  try {
+    const feesResponse = await axios.get(
+      `${BASE_URL}/platformApi/webchat/${buildingSlug}/fees`
+    );
+    if (feesResponse.data) {
+      const data = camelize<BuildingFeeResponse>(feesResponse.data);
+      return {
+        fees: data.fees.map(toBuildingFeeClass),
+        rentableItems: data.rentableItems,
+        buildingIncentives: data.buildingIncentives,
+      };
+    }
+  } catch (error) {
+    sendLoggingEvent({
+      logType: LogType.error,
+      buildingSlug,
+      logTitle: "[ERROR_GETTING_FEES]",
+      logData: { error },
+    });
+  }
+
+  return {
+    fees: [],
+    rentableItems: [],
+    buildingIncentives: [],
+  };
+};
+
+const toBuildingFeeClass = (fee: BuildingFee) => new BuildingFee(fee);
+
+export default fetchBuildingFees;

package/src/services/fees/fetchBuildingFeesV2.ts

@@ -0,0 +1,59 @@
+import axios from "axios";
+import { LogType, sendLoggingEvent } from "../../analytics";
+import { BASE_DOMAIN } from "../../globals";
+import { camelize } from "../../utils";
+import { IncentiveV2 } from "../../types/incentive-v2";
+import { RentableItemSummary } from "../../WebComponent/FeeCalculator/model/rentable-item-summary";
+import { BuildingFeeView } from "../../WebComponent/FeeCalculator/model/building-fee-view";
+import QueryParamBuilder from "../../utils/queryParamBuilder";
+
+const BASE_URL = BASE_DOMAIN;
+
+type BuildingFeeResponse = {
+  fees: BuildingFeeView[];
+  rentableItems: RentableItemSummary[];
+  buildingIncentives: IncentiveV2[];
+};
+
+const fetchBuildingFeesV2 = async (
+  buildingSlug: string,
+  layoutIds?: number[]
+): Promise<BuildingFeeResponse> => {
+  try {
+    const params = new QueryParamBuilder().addArray(
+      "layout_ids",
+      layoutIds?.map((id) => id.toString())
+    );
+    const feesResponse = await axios.get(
+      `${BASE_URL}/platformApi/webchat/${buildingSlug}/fees?${params.build()}`
+    );
+    if (feesResponse.data) {
+      const data = camelize<BuildingFeeResponse>(feesResponse.data);
+      return {
+        fees: data.fees.map(toBuildingFeeClass),
+        rentableItems: data.rentableItems.map(toRentableItemSummary),
+        buildingIncentives: data.buildingIncentives,
+      };
+    }
+  } catch (error) {
+    sendLoggingEvent({
+      logType: LogType.error,
+      buildingSlug,
+      logTitle: "[ERROR_GETTING_FEES]",
+      logData: { error },
+    });
+  }
+
+  return {
+    fees: [],
+    rentableItems: [],
+    buildingIncentives: [],
+  };
+};
+
+const toBuildingFeeClass = (fee: BuildingFeeView) => new BuildingFeeView(fee);
+
+const toRentableItemSummary = (item: RentableItemSummary) =>
+  new RentableItemSummary(item);
+
+export default fetchBuildingFeesV2;

package/src/services/fees/fetchBuildingFloorplans.ts

@@ -0,0 +1,74 @@
+import axios from "axios";
+import { LogType, sendLoggingEvent } from "../../analytics";
+import { BASE_DOMAIN } from "../../globals";
+import { camelize } from "../../utils";
+
+export type Floorplan = {
+  unitId: number;
+  name: string;
+  bedrooms: number;
+  bathrooms: number;
+  numAvailable: number;
+  startingPrice: number;
+  maxPrice: number;
+  earliestAvailable: string;
+  latestAvailable: string;
+  squareFeet: number;
+  url: string | null;
+};
+
+type FetchFloorplansParams = {
+  buildingSlug: string;
+  numBedrooms?: number;
+  moveInDateEarliest?: Date;
+  moveInDateLatest?: Date;
+};
+
+const fetchBuildingFloorplans = async ({
+  buildingSlug,
+  numBedrooms,
+  moveInDateEarliest,
+  moveInDateLatest,
+}: FetchFloorplansParams): Promise<Floorplan[]> => {
+  try {
+    const params = new URLSearchParams();
+    if (numBedrooms) {
+      params.append("num_bedrooms", numBedrooms.toString());
+    }
+    if (moveInDateEarliest) {
+      params.append(
+        "move_in_date_earliest",
+        moveInDateEarliest.toISOString().split("T")[0]
+      );
+    }
+    if (moveInDateLatest) {
+      params.append(
+        "move_in_date_latest",
+        moveInDateLatest.toISOString().split("T")[0]
+      );
+    }
+
+    const queryString = params.toString() ? `?${params.toString()}` : "";
+    const floorplansResponse = await axios.get(
+      `${BASE_DOMAIN}/platformApi/webchat/${buildingSlug}/floorplans${queryString}`
+    );
+
+    if (floorplansResponse.data) {
+      return camelize<Floorplan[]>(floorplansResponse.data);
+    }
+  } catch (error) {
+    sendLoggingEvent({
+      logType: LogType.error,
+      buildingSlug,
+      logTitle: "[ERROR_GETTING_FLOORPLANS]",
+      logData: {
+        error,
+        params: { numBedrooms, moveInDateEarliest, moveInDateLatest },
+      },
+    });
+  }
+
+  return [];
+};
+
+export default fetchBuildingFloorplans;

package/src/services/fees/fetchBuildingUnits.ts

@@ -0,0 +1,86 @@
+import axios from "axios";
+import { LogType, sendLoggingEvent } from "../../analytics";
+import { BASE_DOMAIN } from "../../globals";
+import { camelize } from "../../utils";
+import QueryParamBuilder from "../../utils/queryParamBuilder";
+
+const BASE_URL = BASE_DOMAIN;
+
+export type Unit = {
+  /**
+   * ID comes back in the format "u1234567890" - we strip the "u"
+   */
+  id: number;
+  unitNumber: string;
+  layout: number;
+  externalFloorPlanDescriptionId: string;
+  numberOfBedrooms: number;
+  numberOfBathrooms: number;
+  squareFootage: number;
+  floor: number;
+  floorplanName: string;
+  floorplanUrl: string;
+  availabilityStage: string;
+  earliestAvailable: string;
+  latestAvailable: string;
+  startingPrice: number;
+  maxPrice: number;
+};
+
+type FetchPropertyUnitsParams = {
+  buildingSlug: string;
+  numBedrooms?: number;
+  moveInDateEarliest?: Date;
+  moveInDateLatest?: Date;
+  leaseTermMin?: number;
+};
+
+const fetchBuildingUnits = async ({
+  buildingSlug,
+  numBedrooms,
+  moveInDateEarliest,
+  moveInDateLatest,
+  leaseTermMin,
+}: FetchPropertyUnitsParams): Promise<Unit[]> => {
+  try {
+    const queryParamBuilder = new QueryParamBuilder();
+    queryParamBuilder
+      .addSingle("num_bedrooms", numBedrooms?.toString())
+      .addSingle(
+        "move_in_date_earliest",
+        moveInDateEarliest?.toISOString().split("T")[0]
+      )
+      .addSingle(
+        "move_in_date_latest",
+        moveInDateLatest?.toISOString().split("T")[0]
+      )
+      .addSingle("lease_term_min", leaseTermMin?.toString());
+
+    const queryString = queryParamBuilder.build();
+    const propertyUnitsResponse = await axios.get(
+      `${BASE_URL}/platformApi/webchat/${buildingSlug}/units${queryString}`
+    );
+
+    if (propertyUnitsResponse.data) {
+      const camelizedUnits = camelize<Unit[]>(propertyUnitsResponse.data);
+      return camelizedUnits.map((unit) => ({
+        ...unit,
+        id: parseInt(unit.id.toString().substring(1)),
+      }));
+    }
+  } catch (error) {
+    sendLoggingEvent({
+      logType: LogType.error,
+      buildingSlug,
+      logTitle: "[ERROR_GETTING_UNITS]",
+      logData: {
+        error,
+        params: { numBedrooms, moveInDateEarliest, moveInDateLatest },
+      },
+    });
+  }
+
+  return [];
+};
+
+export default fetchBuildingUnits;

package/src/services/fees/utils.ts

@@ -0,0 +1,4 @@
+export const layoutToBedrooms = (layout: number): number => {
+  if (layout === 0) return 0; // Studio
+  return Math.floor(layout / 10);
+};

package/src/svgIcons.ts

@@ -0,0 +1,14 @@
+import { svg } from "lit";
+
+/**
+ * TODO(erol): PLEASE MOVE INTO EACH OWN ICON FILE UNDER /ICONS
+ */
+
+export const CheckboxEmpty = svg`<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none">
+<rect x="1" y="1" width="22" height="22" stroke="black" stroke-width="2" rx="2"/>
+</svg>
+`;
+export const CheckboxChecked = svg`<svg xmlns="http://www.w3.org/2000/svg" width="16" height="17" viewBox="0 0 16 17" fill="none">
+<rect y="0.09375" width="16" height="16" rx="2" fill="#4719CD"/>
+<path d="M12 5.09375L6.5 10.5938L4 8.09375" stroke="white" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>`;

package/src/themes.ts

@@ -0,0 +1,65 @@
+export const defaultPrimaryColor = "#646987"; // we have a brand color defined in the BE too, but this is a fallback
+export const defaultBackgroundColor = "#ffffff"; // default background color for the chat widget
+
+export const tintColor = (
+  originalColor: string,
+  tintOpacity: number
+): string => {
+  const originalRgb = hexToRgb(originalColor);
+  const tintRgb = { r: 0, g: 0, b: 0 };
+
+  const newRgb = {
+    r: originalRgb.r + Math.round((tintRgb.r - originalRgb.r) * tintOpacity),
+    g: originalRgb.g + Math.round((tintRgb.g - originalRgb.g) * tintOpacity),
+    b: originalRgb.b + Math.round((tintRgb.b - originalRgb.b) * tintOpacity),
+  };
+
+  return rgbToHex(newRgb.r, newRgb.g, newRgb.b);
+};
+
+const hexToRgb = (hex: string): { r: number; g: number; b: number } => {
+  const r = parseInt(hex.substring(1, 3), 16);
+  const g = parseInt(hex.substring(3, 5), 16);
+  const b = parseInt(hex.substring(5, 7), 16);
+  return { r, g, b };
+};
+
+const rgbToHex = (r: number, g: number, b: number): string => {
+  return (
+    "#" +
+    [r, g, b]
+      .map((c) => {
+        const hex = c.toString(16);
+        return hex.length === 1 ? "0" + hex : hex;
+      })
+      .join("")
+  );
+};
+
+export const hexToAlmostWhite = (hexColor: string, ratio: number): string => {
+  let r = parseInt(hexColor.substr(1, 2), 16);
+  let g = parseInt(hexColor.substr(3, 2), 16);
+  let b = parseInt(hexColor.substr(5, 2), 16);
+
+  // the ratio of white to add (1 = white, 0 = no change)
+  r = Math.round(r * (1 - ratio) + 255 * ratio);
+  g = Math.round(g * (1 - ratio) + 255 * ratio);
+  b = Math.round(b * (1 - ratio) + 255 * ratio);
+
+  return (
+    "#" +
+    r.toString(16).padStart(2, "0") +
+    g.toString(16).padStart(2, "0") +
+    b.toString(16).padStart(2, "0")
+  );
+};
+
+export const shouldUsePrimaryColorForChatFooter = (
+  orgId: number,
+  buildingId: number
+): boolean => {
+  // Some clients are complaining that we are NOT ADA compliant with our black, default chat footer
+  // So we are temporarily adding this flag to allow them to use their brand color for the chat footer
+  // Don't want to suddenly change it for our clients so added this flag
+  return orgId === 2 || buildingId === 70392;
+};

package/src/types/incentive-v2.ts

@@ -0,0 +1,24 @@
+export type UnitData = {
+  unitIds: number[];
+  unitNumbers: string[];
+  layouts: number[];
+  floorplanNames: string[];
+};
+
+export type IncentiveV2 = {
+  id: number;
+  originalIncentiveString: string;
+  startDate: Date;
+  endDate: Date;
+  incentiveStatus: string;
+  source: string;
+  timeCreated: Date;
+  nofee: boolean;
+  numberOfFreeMonths: number;
+  leaseLength: number;
+  typeOfCustomerItAppliesTo: number;
+  typeOfIncentive: number;
+  numberOfMonthsOwnerPays: number;
+  unitData: UnitData;
+  qualifier: string;
+};

package/src/types/rest-sdk.types.ts

@@ -0,0 +1,13 @@
+/**
+ * Redeclare enum from rest-sdk to avoid pulling in entire module.
+ */
+export enum TourAvailabilityResponseRankOrderedSupportedTourTypesEnum {
+  Unknown = "UNKNOWN",
+  SelfGuided = "SELF_GUIDED",
+  VirtualShowing = "VIRTUAL_SHOWING",
+  WithAgent = "WITH_AGENT",
+  MediaTour = "MEDIA_TOUR",
+}
+
+// Types are safe to re-export as they are not included in runtime code.
+export type { TourAvailabilityResponse } from "@meetelise/rest-sdk";

package/src/types/webchat-no-show-reason.ts

@@ -0,0 +1,6 @@
+export type WebchatNoShowReason =
+  | "building_does_not_exist"
+  | "building_not_launched"
+  | "building_not_active"
+  | "building_in_maintenance_mode"
+  | "building_not_webchat_scope_configured";