@meetelise/chat 1.34.7 → 1.35.1

package/src/WebComponent/FeeCalculator/model/building-fee-view.ts

@@ -0,0 +1,84 @@
+import { PricingMatrix } from "./pricing-matrix";
+
+export enum BuildingFeeFrequency {
+  OneTime = "One Time",
+  Monthly = "Monthly",
+  Quarterly = "Quarterly",
+  Annually = "Annually",
+  PerOccurrence = "Per Occurrence",
+}
+
+export class BuildingFeeView {
+  id?: number;
+  buildingId: number;
+  feeName: string;
+  description?: string;
+  category = "Other";
+  unitIds?: number[];
+  layoutIds?: number[];
+  startDate?: Date;
+  endDate?: Date;
+  source?: string;
+  externalKey?: string;
+  syncActive = true;
+  hiddenReason?: string;
+  refundable = false;
+  bundleKey?: string;
+  publicFacing = true;
+  chargeCode?: string;
+  prorated?: boolean;
+  pricingCategory: "mandatory" | "situational";
+  pricingType: "fixed" | "per-item" | "usage-based" | "percent-rent" | "custom";
+  frequency: BuildingFeeFrequency;
+  nlpPricing?: string;
+
+  // Optional fields that depend on fee type
+  amount?: number;
+  percentRent?: number;
+  unitLabel?: string;
+  minAmount?: number;
+  maxAmount?: number;
+  customMatrixData?: PricingMatrix;
+
+  constructor(data: Partial<BuildingFeeView> = {}) {
+    this.id = data.id;
+    this.buildingId = data.buildingId ?? 0;
+    this.feeName = data.feeName ?? "";
+    this.description = data.description;
+    this.category = data.category ?? "Other";
+    this.unitIds = data.unitIds;
+    this.layoutIds = data.layoutIds;
+    this.startDate = data.startDate;
+    this.endDate = data.endDate;
+    this.source = data.source;
+    this.externalKey = data.externalKey;
+    this.syncActive = data.syncActive ?? true;
+    this.hiddenReason = data.hiddenReason;
+    this.refundable = data.refundable ?? false;
+    this.bundleKey = data.bundleKey;
+    this.publicFacing = data.publicFacing ?? true;
+    this.chargeCode = data.chargeCode;
+    this.prorated = data.prorated;
+    this.pricingCategory = data.pricingCategory ?? "mandatory";
+    this.pricingType = data.pricingType ?? "fixed";
+    this.frequency = data.frequency ?? BuildingFeeFrequency.OneTime;
+    this.nlpPricing = data.nlpPricing;
+
+    // Optional fields
+    if (data.amount !== undefined) this.amount = data.amount;
+    if (data.percentRent !== undefined) this.percentRent = data.percentRent;
+    if (data.unitLabel !== undefined) this.unitLabel = data.unitLabel;
+    if (data.minAmount !== undefined) this.minAmount = data.minAmount;
+    if (data.maxAmount !== undefined) this.maxAmount = data.maxAmount;
+    if (data.customMatrixData !== undefined)
+      this.customMatrixData = data.customMatrixData;
+  }
+
+  get isOptional(): boolean {
+    return this.pricingCategory === "situational";
+  }
+
+  get hasMatrix(): boolean {
+    return !!(this.pricingType === "custom" && this.customMatrixData);
+  }
+}

package/src/WebComponent/FeeCalculator/model/building-fee.ts

@@ -0,0 +1,126 @@
+import { formatCurrency, sentenceTitleCase } from "../../../utils";
+import { TransactionCategory } from "./transaction-category";
+
+export class BuildingFee {
+  id: number;
+  buildingId: number;
+  blueprint: FeeBlueprint;
+  unitIds: number[] | null;
+  layoutIds: number[] | null;
+  startDate: Date | null;
+  endDate: Date | null;
+  source: string | null;
+  timeCreated: Date;
+  externalKey: string | null;
+  syncActive: boolean;
+  hiddenReason: string | null;
+  refundable: boolean | null;
+  required?: boolean;
+
+  constructor(data: Partial<BuildingFee> = {}) {
+    this.id = data.id ?? 0;
+    this.buildingId = data.buildingId ?? 0;
+    this.blueprint = data.blueprint ?? ({} as FeeBlueprint);
+    this.unitIds = data.unitIds ?? null;
+    this.layoutIds = data.layoutIds ?? null;
+    this.startDate = data.startDate ?? null;
+    this.endDate = data.endDate ?? null;
+    this.source = data.source ?? null;
+    this.timeCreated = data.timeCreated ?? new Date();
+    this.externalKey = data.externalKey ?? null;
+    this.syncActive = data.syncActive ?? false;
+    this.hiddenReason = data.hiddenReason ?? null;
+    this.refundable = data.refundable ?? null;
+    this.required = data.required ?? false;
+  }
+
+  get isAddOn(): boolean {
+    return this.blueprint.addOnInfo !== null;
+  }
+
+  displayName(fallback = "Fee"): string {
+    if (this.isAddOn && this.blueprint.addOnInfo?.addOnType) {
+      return sentenceTitleCase(this.blueprint.addOnInfo.addOnType);
+    }
+
+    return this.blueprint.category
+      ? sentenceTitleCase(this.blueprint.category)
+      : fallback;
+  }
+
+  get description(): string {
+    return this.blueprint.transactionDescription || "";
+  }
+
+  get displayAmount(): string {
+    const amount = this.blueprint.transactionAmount;
+    return formatCurrency(amount ?? 0);
+  }
+}
+
+interface FeeBlueprint {
+  transactionId: number | null;
+  transactionAmount: number | null;
+  flowDirection: TransactionFlow;
+  transactionDescription: string | null;
+  category: TransactionCategory;
+  recurrenceInfo: RecurrenceInfo | null;
+  adjustmentInfo: AdjustmentInfo | null;
+  triggerInfo: TriggerInfo | null;
+  addOnInfo: AddOnInfo | null;
+  priceType: PriceType;
+  handledByThirdParty: boolean;
+  handledByThirdPartyReasoning: string | null;
+  leaseStartDate: Date | null;
+  leaseEndDate: Date | null;
+}
+
+interface AdjustmentInfo {
+  reason: string;
+  percentage: number;
+}
+
+export enum RecurrenceFrequency {
+  OneTime = "OneTime",
+  Daily = "Daily",
+  Weekly = "Weekly",
+  BiWeekly = "BiWeekly",
+  Monthly = "Monthly",
+  Yearly = "Yearly",
+  Unknown = "Unknown",
+}
+
+interface RecurrenceInfo {
+  frequency: RecurrenceFrequency;
+  startDate: Date | null;
+  endDate: Date | null;
+}
+
+interface TriggerInfo {
+  triggerEvent: string;
+  maxDaysBeforeEvent: number;
+  maxDaysAfterEvent: number;
+  triggerEventEmbedding: number[] | null;
+  startDate: Date | null;
+  endDate: Date | null;
+}
+
+export interface AddOnInfo {
+  addOnType: string;
+  maxUnitsCharged: number | null;
+  minUnitsCharged: number | null;
+  maxUnitsAllowed: number | null;
+  minUnitsAllowed: number | null;
+  addOnTypeEmbedding: number[] | null;
+}
+
+export enum TransactionFlow {
+  Debit = "Debit",
+  Credit = "Credit",
+}
+
+export enum PriceType {
+  Fixed = "Fixed",
+  UsageBased = "UsageBased",
+  Varies = "Varies",
+}

package/src/WebComponent/FeeCalculator/model/desired-addon.ts

@@ -0,0 +1,6 @@
+import { ItemQuantity } from "./item-quantity";
+
+export type DesiredAddon = {
+  id: number;
+  quantities: ItemQuantity[];
+};

package/src/WebComponent/FeeCalculator/model/desired-rentable-item.ts

@@ -0,0 +1,4 @@
+export type DesiredRentableItem = {
+  id: number;
+  type: string;
+};

package/src/WebComponent/FeeCalculator/model/index.ts

@@ -0,0 +1,13 @@
+export * from "./building-fee";
+export * from "./building-fee-view";
+export * from "./desired-addon";
+export * from "./desired-rentable-item";
+export * from "./item-combination";
+export * from "./item-quantity";
+export * from "./pricing-matrix";
+export * from "./pricing-rule";
+export type { RentFrequency } from "./rent-frequency";
+export type { RentableItem } from "./rentable-item";
+export * from "./rentable-item-summary";
+export * from "./transaction-category";
+export * from "./unit-fee-bundle";

package/src/WebComponent/FeeCalculator/model/item-combination.ts

@@ -0,0 +1,16 @@
+import { ItemQuantity } from "./item-quantity";
+
+export class ItemCombination {
+  quantities: ItemQuantity[];
+
+  constructor(quantities: ItemQuantity[] = []) {
+    this.quantities = quantities;
+  }
+
+  toKey(): string {
+    return this.quantities
+      .sort((a, b) => a.itemType.localeCompare(b.itemType))
+      .map((q) => `${q.itemType}:${q.quantity}`)
+      .join(",");
+  }
+}

package/src/WebComponent/FeeCalculator/model/item-quantity.ts

@@ -0,0 +1,4 @@
+export interface ItemQuantity {
+  itemType: string;
+  quantity: number;
+}

package/src/WebComponent/FeeCalculator/model/pricing-matrix.ts

@@ -0,0 +1,45 @@
+import { ItemCombination } from "./item-combination";
+import { PricingRule } from "./pricing-rule";
+
+export class PricingMatrix {
+  private rules: Map<string, PricingRule>;
+  pricingRules: PricingRule[];
+
+  constructor(data: { pricingRules?: PricingRule[] } = {}) {
+    this.rules = new Map();
+    this.pricingRules = data.pricingRules ?? [];
+
+    // Initialize from provided pricing rules
+    this.pricingRules.forEach((rule) => this.addRule(rule));
+  }
+
+  addRule(rule: PricingRule): void {
+    const key = rule.combination.toKey();
+    this.rules.set(key, rule);
+  }
+
+  getPrice(combination: ItemCombination): number | undefined {
+    const key = combination.toKey();
+    const rule = this.rules.get(key);
+    return rule?.price;
+  }
+
+  toRuleArray(): PricingRule[] {
+    return Array.from(this.rules.values());
+  }
+
+  toJSON(): { pricingRules: PricingRule[] } {
+    return {
+      pricingRules: this.toRuleArray(),
+    };
+  }
+
+  static fromJSON(data: { pricingRules: PricingRule[] }): PricingMatrix {
+    return new PricingMatrix({
+      pricingRules: data.pricingRules?.map((rule: PricingRule) => ({
+        ...rule,
+        combination: new ItemCombination(rule.combination.quantities),
+      })),
+    });
+  }
+}

package/src/WebComponent/FeeCalculator/model/pricing-rule.ts

@@ -0,0 +1,9 @@
+import { ItemCombination } from "./item-combination";
+
+export interface PricingRule {
+  combination: ItemCombination;
+  price?: number;
+  percentRent?: number;
+  minimumPrice?: number;
+  maximumPrice?: number;
+}

package/src/WebComponent/FeeCalculator/model/rent-frequency.ts

@@ -0,0 +1 @@
+export type RentFrequency = "monthly" | "annually";

package/src/WebComponent/FeeCalculator/model/rentable-item-summary.ts

@@ -0,0 +1,10 @@
+import { RentableItem } from "./rentable-item";
+
+export interface RentableItemSummary {
+  description: string;
+  type: string;
+  minAvailableItem?: RentableItem;
+  maxAvailableItem?: RentableItem;
+  allItems: RentableItem[];
+  rent?: number;
+}

package/src/WebComponent/FeeCalculator/model/rentable-item.ts

@@ -0,0 +1,10 @@
+import { RentFrequency } from "./rent-frequency";
+
+export interface RentableItem {
+  id: string;
+  description: string;
+  rent: number;
+  rentFrequency: RentFrequency;
+  available: boolean;
+  reservedUntil?: Date;
+}

package/src/WebComponent/FeeCalculator/model/transaction-category.ts

@@ -0,0 +1,23 @@
+export enum TransactionCategory {
+  AdminFee = "AdminFee",
+  ApplicationFee = "ApplicationFee",
+  Concession = "Concession",
+  Insurance = "Insurance",
+  LateFee = "LateFee",
+  Legal = "Legal",
+  NonSufficientFundFee = "NSF",
+  Other = "Other",
+  Parking = "Parking",
+  Penalty = "Penalty",
+  Pest = "Pest",
+  PetDeposit = "PetDeposit",
+  PetRent = "PetRent",
+  Refund = "Refund",
+  Relet = "Relet",
+  Rent = "Rent",
+  SecurityDeposit = "SecurityDeposit",
+  Storage = "Storage",
+  Trash = "Trash",
+  Utility = "Utility",
+  WaterSewer = "WaterSewer",
+}

package/src/WebComponent/FeeCalculator/model/unit-fee-bundle.ts

@@ -0,0 +1,54 @@
+import { RentableItemSummary } from "./rentable-item-summary";
+import { formatCurrency, sentenceTitleCase } from "../../../utils";
+
+export type UnitFeeBundle = {
+  unitId: number;
+  unitNumber: string;
+  unitLayout: number;
+  rent: number;
+  fees: FeeEstimate[];
+  feeTotal: number;
+  rentableItems: RentableItemSummary[];
+  rentableItemTotal: number;
+};
+
+type FeeAdjustment = {
+  reason: string;
+  amount: number;
+};
+
+export class FeeEstimate {
+  name: string;
+  description?: string | null;
+  amount: number;
+  frequency: string;
+  addOnType?: string;
+  applicable?: boolean;
+  required?: boolean;
+  adjustments?: FeeAdjustment[];
+  comment?: string;
+
+  constructor(data: FeeEstimate) {
+    this.name = data.name;
+    this.description = data.description;
+    this.amount = data.amount;
+    this.frequency = data.frequency;
+    this.addOnType = data.addOnType;
+    this.applicable = data.applicable;
+    this.required = data.required;
+    this.adjustments = data.adjustments;
+    this.comment = data.comment;
+  }
+
+  get displayAmount(): string {
+    return formatCurrency(this.amount);
+  }
+
+  get displayName(): string {
+    return sentenceTitleCase(this.name);
+  }
+
+  get isAddOn(): boolean {
+    return !!this.addOnType;
+  }
+}