erlc-v2 1.0.0 → 1.1.0

package/src/util/vehicleSearch.js

@@ -0,0 +1,120 @@
+function cleanText(value) {
+  return String(value ?? "")
+    .trim()
+    .toLowerCase();
+}
+
+function cleanPlate(value) {
+  return cleanText(value).replace(/[^a-z0-9]/g, "");
+}
+
+function toVehicleTerms(vehicle) {
+  return {
+    raw: vehicle,
+    name: String(vehicle?.Name ?? "").trim(),
+    owner: String(vehicle?.Owner ?? "").trim(),
+    plate: String(vehicle?.Plate ?? "").trim(),
+    texture: String(vehicle?.Texture ?? "").trim(),
+    colorName: String(vehicle?.ColorName ?? "").trim(),
+    colorHex: String(vehicle?.ColorHex ?? "").trim(),
+  };
+}
+
+function matchText(value, query, exact) {
+  if (!query) return true;
+  if (exact) return value === query;
+  return value.includes(query);
+}
+
+function scoreVehicle(terms, query) {
+  if (!query) return 0;
+  if (terms.plate && cleanPlate(terms.plate) === query) return 100;
+  if (terms.plate && cleanPlate(terms.plate).startsWith(query)) return 80;
+  if (terms.owner && cleanText(terms.owner) === query) return 75;
+  if (terms.name && cleanText(terms.name) === query) return 70;
+  if (terms.plate && cleanPlate(terms.plate).includes(query)) return 60;
+  if (terms.owner && cleanText(terms.owner).includes(query)) return 50;
+  if (terms.name && cleanText(terms.name).includes(query)) return 40;
+  if (terms.colorName && cleanText(terms.colorName).includes(query)) return 30;
+  if (terms.texture && cleanText(terms.texture).includes(query)) return 20;
+  return 10;
+}
+
+function searchVehicles(list, filters = {}) {
+  const vehicles = Array.isArray(list) ? list : [];
+  const input =
+    typeof filters === "string" ? { query: filters } : filters || {};
+
+  const exact = input.exact === true;
+  const queryText = cleanText(input.query ?? input.search ?? "");
+  const plateQuery = cleanPlate(input.plate ?? "");
+  const ownerQuery = cleanText(input.owner ?? "");
+  const nameQuery = cleanText(input.name ?? "");
+  const colorQuery = cleanText(input.color ?? input.colorName ?? "");
+  const textureQuery = cleanText(input.texture ?? "");
+  const limit =
+    input.limit === undefined || input.limit === null
+      ? null
+      : Math.max(0, Number(input.limit) || 0);
+
+  const matched = [];
+  for (const vehicle of vehicles) {
+    const terms = toVehicleTerms(vehicle);
+    const plateValue = cleanPlate(terms.plate);
+    const ownerValue = cleanText(terms.owner);
+    const nameValue = cleanText(terms.name);
+    const colorValue = cleanText(terms.colorName);
+    const textureValue = cleanText(terms.texture);
+
+    if (!matchText(plateValue, plateQuery, exact)) continue;
+    if (!matchText(ownerValue, ownerQuery, exact)) continue;
+    if (!matchText(nameValue, nameQuery, exact)) continue;
+    if (!matchText(colorValue, colorQuery, exact)) continue;
+    if (!matchText(textureValue, textureQuery, exact)) continue;
+
+    if (queryText) {
+      const hit =
+        plateValue.includes(queryText) ||
+        ownerValue.includes(queryText) ||
+        nameValue.includes(queryText) ||
+        colorValue.includes(queryText) ||
+        textureValue.includes(queryText) ||
+        cleanText(terms.colorHex).includes(queryText);
+      if (!hit) continue;
+    }
+
+    matched.push({
+      vehicle,
+      score: scoreVehicle(terms, queryText || plateQuery || ownerQuery || nameQuery),
+      plate: plateValue,
+      owner: ownerValue,
+      name: nameValue,
+    });
+  }
+
+  matched.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    if (a.owner !== b.owner) return a.owner.localeCompare(b.owner);
+    if (a.name !== b.name) return a.name.localeCompare(b.name);
+    return a.plate.localeCompare(b.plate);
+  });
+
+  const output = matched.map((item) => item.vehicle);
+  if (limit === null) return output;
+  return output.slice(0, limit);
+}
+
+function findVehicleByPlate(list, plate) {
+  const results = searchVehicles(list, {
+    plate,
+    exact: true,
+    limit: 1,
+  });
+  return results[0] ?? null;
+}
+
+module.exports = {
+  searchVehicles,
+  findVehicleByPlate,
+  cleanPlate,
+};

package/src/util/webhook.js

@@ -0,0 +1,204 @@
+const crypto = require("crypto");
+
+const PUBLIC_KEY = crypto.createPublicKey({
+  key: Buffer.from(
+    "MCowBQYDK2VwAyEAjSICb9pp0kHizGQtdG8ySWsDChfGqi+gyFCttigBNOA=",
+    "base64",
+  ),
+  format: "der",
+  type: "spki",
+});
+
+function getHeader(req, name) {
+  const value = req.headers?.[name.toLowerCase()];
+  if (Array.isArray(value)) return value[0] ?? "";
+  return typeof value === "string" ? value : "";
+}
+
+function verifyWebhookSignature(timestamp, sigHex, rawBody) {
+  if (!timestamp || !sigHex || !Buffer.isBuffer(rawBody)) return false;
+  if (!/^[a-f0-9]+$/i.test(sigHex) || sigHex.length % 2 !== 0) return false;
+
+  const signature = Buffer.from(sigHex, "hex");
+  const message = Buffer.concat([Buffer.from(String(timestamp), "utf8"), rawBody]);
+  return crypto.verify(null, message, PUBLIC_KEY, signature);
+}
+
+function detectWebhookType(body = {}) {
+  if (!body || typeof body !== "object") {
+    return "verification";
+  }
+
+  if (Object.keys(body).length === 0) {
+    return "verification";
+  }
+
+  const events = Array.isArray(body.events)
+    ? body.events
+    : Array.isArray(body.Events)
+      ? body.Events
+      : [];
+
+  for (const entry of events) {
+    const eventName = String(entry?.event ?? entry?.Event ?? "")
+      .trim()
+      .toLowerCase();
+    const data = entry?.data ?? entry?.Data ?? {};
+
+    if (!eventName && (!data || typeof data !== "object")) {
+      continue;
+    }
+
+    if (
+      eventName.includes("probe") ||
+      eventName.includes("verify") ||
+      eventName.includes("validation") ||
+      eventName.includes("challenge")
+    ) {
+      return "verification";
+    }
+
+    if (eventName.includes("emergency")) {
+      return "emergencyCall";
+    }
+
+    if (eventName.includes("command")) {
+      return "command";
+    }
+
+    const dataCommand =
+      data.command ??
+      data.Command ??
+      data.message ??
+      data.Message ??
+      data.content ??
+      data.Content;
+    if (typeof dataCommand === "string" && dataCommand.trim().startsWith(";")) {
+      return "command";
+    }
+  }
+
+  const hints = [
+    body.type,
+    body.Type,
+    body.event,
+    body.Event,
+    body.eventType,
+    body.EventType,
+    body.kind,
+    body.Kind,
+  ]
+    .filter((value) => typeof value === "string")
+    .map((value) => value.trim().toLowerCase());
+
+  for (const hint of hints) {
+    if (
+      hint.includes("verify") ||
+      hint.includes("validation") ||
+      hint.includes("challenge")
+    ) {
+      return "verification";
+    }
+    if (hint.includes("emergency")) return "emergencyCall";
+    if (hint.includes("command")) return "command";
+  }
+
+  const commandText =
+    body.command ??
+    body.Command ??
+    body.message ??
+    body.Message ??
+    body.content ??
+    body.Content;
+  if (typeof commandText === "string" && commandText.trim().startsWith(";")) {
+    return "command";
+  }
+
+  if (
+    body.CallNumber !== undefined ||
+    body.callNumber !== undefined ||
+    body.PositionDescriptor !== undefined ||
+    body.positionDescriptor !== undefined
+  ) {
+    return "emergencyCall";
+  }
+
+  if (
+    body.challenge !== undefined ||
+    body.Challenge !== undefined ||
+    body.validation !== undefined ||
+    body.Validation !== undefined ||
+    body.nonce !== undefined ||
+    body.Nonce !== undefined
+  ) {
+    return "verification";
+  }
+
+  return "unknown";
+}
+
+function getEventEntries(body = {}) {
+  if (Array.isArray(body?.events)) return body.events;
+  if (Array.isArray(body?.Events)) return body.Events;
+  return [];
+}
+
+function normalizeEventEntry(entry = {}) {
+  const data =
+    entry?.data && typeof entry.data === "object"
+      ? entry.data
+      : entry?.Data && typeof entry.Data === "object"
+        ? entry.Data
+        : {};
+  const command =
+    data.command ??
+    data.Command ??
+    null;
+  const argument =
+    data.argument ??
+    data.Argument ??
+    data.args ??
+    data.Args ??
+    "";
+
+  return {
+    event: entry?.event ?? entry?.Event ?? null,
+    origin: entry?.origin ?? entry?.Origin ?? null,
+    eventTimestamp: entry?.timestamp ?? entry?.Timestamp ?? null,
+    data,
+    command: typeof command === "string" ? command : null,
+    argument: typeof argument === "string" ? argument : String(argument ?? ""),
+    args: typeof argument === "string" ? argument : String(argument ?? ""),
+  };
+}
+
+function normalizeWebhookPayload(body = {}, meta = {}) {
+  const events = getEventEntries(body).map(normalizeEventEntry);
+  const first = events[0] || null;
+
+  return {
+    type: detectWebhookType(body),
+    body,
+    timestamp: meta.timestamp ?? null,
+    signature: meta.signature ?? null,
+    rawBody: meta.rawBody ?? null,
+    headers: meta.headers ?? {},
+    server: body?.server ?? body?.Server ?? null,
+    events,
+    entry: first,
+    event: first?.event ?? null,
+    origin: first?.origin ?? null,
+    eventTimestamp: first?.eventTimestamp ?? null,
+    data: first?.data ?? null,
+    command: first?.command ?? null,
+    argument: first?.argument ?? "",
+    args: first?.args ?? "",
+  };
+}
+
+module.exports = {
+  getHeader,
+  verifyWebhookSignature,
+  detectWebhookType,
+  normalizeWebhookPayload,
+};