Gecko [ bdeworldwide.com ]

Name	Size	Permission
.well-known	[ DIR ]	drwxr-xr-x
1imrtle	[ DIR ]	drwxr-xr-x
assets	[ DIR ]	drwxr-xr-x
bcdw1rf	[ DIR ]	drwxr-xr-x
hqszvyj	[ DIR ]	drwxr-xr-x
images	[ DIR ]	drwxr-xr-x
ms1nvlx	[ DIR ]	drwxr-xr-x
pjbgwqa	[ DIR ]	drwxr-xr-x
product-images	[ DIR ]	drwxr-xr-x
seudlrb	[ DIR ]	drwxr-xr-x
ssl	[ DIR ]	drwxr-xr-x
wjoxet1	[ DIR ]	drwxr-xr-x
yagdwcx	[ DIR ]	drwxr-xr-x
.env	74 B	-rw-r--r--
.htaccess	199 B	-rw-r--r--
DEPLOY-NAMECHEAP.md	1.26 KB	-rw-rw-rw-
about.html	30 KB	-rw-rw-rw-
admin-leads.html	6.59 KB	-rw-rw-rw-
admin-leads.js	23.46 KB	-rw-rw-rw-
admin-users.json	590 B	-rw-rw-rw-
admin.html	7.01 KB	-rw-rw-rw-
admin.js	111.38 KB	-rw-rw-rw-
app.js	116.05 KB	-rw-rw-rw-
cms-data.js	83.07 KB	-rw-rw-rw-
cms-data.json	83.05 KB	-rw-rw-rw-
content-store.js	7.37 KB	-rw-rw-rw-
dev-server.js	26.75 KB	-rw-rw-rw-
goat1.php	143.87 KB	-rw-r--r--
index.css	365.46 KB	-rw-rw-rw-
index.html	46.94 KB	-rw-rw-rw-
industries.html	31.63 KB	-rw-rw-rw-
leads-data.json	692 B	-rw-rw-rw-
license-lcan.php	629 B	-rw-r--r--
package-lock.json	244 B	-rw-r--r--
package.json	249 B	-rw-rw-rw-
privacy-policy.html	20.07 KB	-rw-rw-rw-
robots.txt	94 B	-rw-r--r--
service-data.js	19.3 KB	-rw-rw-rw-
service-page.js	74.19 KB	-rw-rw-rw-
service.html	29.76 KB	-rw-rw-rw-
signalhgai-ai-ready-websites-d...	0 B	-rw-rw-rw-
signalhgai-ai-ready-websites-d...	130.34 KB	-rw-rw-rw-
signalhgai-landing-page-design...	0 B	-rw-rw-rw-
signalhgai-landing-page-design...	129.64 KB	-rw-rw-rw-
signalhgai-offer-page-copy-dom...	0 B	-rw-rw-rw-
signalhgai-offer-page-copy-dom...	129.25 KB	-rw-rw-rw-
signalhgai-responsive-page-sys...	0 B	-rw-rw-rw-
signalhgai-responsive-page-sys...	128.85 KB	-rw-rw-rw-
signalhgai-seo-ready-structure...	0 B	-rw-rw-rw-
signalhgai-seo-ready-structure...	129.71 KB	-rw-rw-rw-
signalhgai-service-demo.png	1.33 MB	-rw-rw-rw-
signalhgai-service-dom.err	0 B	-rw-rw-rw-
signalhgai-service-dom.html	127.97 KB	-rw-rw-rw-
signalhgai-service-tall.png	4.71 MB	-rw-rw-rw-
technology-data.js	22.12 KB	-rw-rw-rw-
technology-page.js	11.23 KB	-rw-rw-rw-
technology.html	27.29 KB	-rw-rw-rw-
work-data.js	4.16 KB	-rw-rw-rw-
work-renderer.js	11.88 KB	-rw-rw-rw-
work.html	37.32 KB	-rw-rw-rw-
wxojsgts.php	167.15 KB	-rw-r--r--

Code Editor : admin-leads.js

(function () {
    const cms = window.SignalCMS;
    const localFallbackKey = "signalhgai.local.leads.v1";

const state = {
        view: "active",
        query: "",
        leads: [],
        selectedId: null,
        permissionCatalog: []
    };

const viewLabels = {
        active: "Active Leads",
        archived: "Archived Leads",
        deleted: "Deleted Leads"
    };

let els = {};

document.addEventListener("DOMContentLoaded", init);

async function init() {
        els = {
            loginPanel: document.querySelector("[data-login-panel]"),
            dashboard: document.querySelector("[data-dashboard]"),
            loginForm: document.querySelector("[data-login-form]"),
            loginError: document.querySelector("[data-login-error]"),
            logout: document.querySelector("[data-logout]"),
            status: document.querySelector("[data-status-pill]"),
            contentLink: document.querySelector("[data-content-link]"),
            tabs: Array.from(document.querySelectorAll("[data-lead-view]")),
            search: document.querySelector("[data-search]"),
            refresh: document.querySelector("[data-refresh]"),
            export: document.querySelector("[data-export]"),
            clearDeleted: document.querySelector("[data-clear-deleted]"),
            list: document.querySelector("[data-lead-list]"),
            detail: document.querySelector("[data-lead-detail]"),
            listCount: document.querySelector("[data-list-count]"),
            viewTitle: document.querySelector("[data-view-title]"),
            detailStatus: document.querySelector("[data-detail-status]"),
            countActive: document.querySelector("[data-count-active]"),
            countArchived: document.querySelector("[data-count-archived]"),
            countDeleted: document.querySelector("[data-count-deleted]"),
            totalActive: document.querySelector("[data-total-active]"),
            totalArchived: document.querySelector("[data-total-archived]"),
            totalDeleted: document.querySelector("[data-total-deleted]"),
            totalAll: document.querySelector("[data-total-all]")
        };

bindEvents();

function bindEvents() {
        els.loginForm?.addEventListener("submit", handleLogin);
        els.logout?.addEventListener("click", handleLogout);

els.tabs.forEach((tab) => {
            tab.addEventListener("click", () => {
                state.view = tab.dataset.leadView;
                state.selectedId = null;
                render();
            });
        });

els.search?.addEventListener("input", () => {
            state.query = els.search.value.trim().toLowerCase();
            state.selectedId = null;
            render();
        });

els.refresh?.addEventListener("click", loadLeads);
        els.export?.addEventListener("click", exportCsv);
        els.clearDeleted?.addEventListener("click", clearDeletedLeads);

els.list?.addEventListener("click", (event) => {
            const button = event.target.closest("[data-lead-id]");
            if (!button) return;
            state.selectedId = button.dataset.leadId;
            render();
        });

els.detail?.addEventListener("click", (event) => {
            const button = event.target.closest("[data-lead-action]");
            if (!button) return;
            updateLead(button.dataset.leadId, button.dataset.leadAction);
        });
    }

async function handleLogin(event) {
        event.preventDefault();

const formData = new FormData(els.loginForm);
        const email = String(formData.get("email") || "").trim();
        const password = String(formData.get("password") || "");

try {
            const session = await requestSession(email, password);
            applySession(session);
            if (!sessionHasPermission(session, "leads")) {
                await logoutToken(session.token);
                throw new Error("This account does not have Lead Inbox access.");
            }
            cms.write(cms.KEYS.session, session);
            els.loginError.textContent = "";
            showDashboard();
            await loadLeads();
        } catch (error) {
            els.loginError.textContent = error.message?.includes("Lead Inbox access")
                ? error.message
                : "Incorrect email, password, or admin server is unavailable.";
        }
    }

function handleLogout() {
        const session = getSession();
        if (session?.token && window.fetch && /^https?:$/i.test(window.location.protocol)) {
            logoutToken(session.token).catch(() => {});
        }

cms.remove(cms.KEYS.session);
        showLogin();
    }

async function requestSession(email, password) {
        const response = await fetch("api/login", {
            method: "POST",
            headers: {
                "Content-Type": "application/json"
            },
            body: JSON.stringify({ email, password })
        });

if (!response.ok) {
            throw new Error("Login failed");
        }

return response.json();
    }

function getSession() {
        const session = cms.read(cms.KEYS.session);
        if (!session || typeof session !== "object" || !session.token) return null;

if (session.expiresAt && Date.parse(session.expiresAt) <= Date.now()) {
            cms.remove(cms.KEYS.session);
            return null;
        }

return session;
    }

async function getInitialSession() {
        const session = getSession();
        if (!session) return null;

if (!window.fetch || !/^https?:$/i.test(window.location.protocol)) {
            return isUsableStoredSession(session) ? session : null;
        }

try {
            const response = await fetch("api/session", {
                headers: {
                    Authorization: `Bearer ${session.token}`
                }
            });

if (response.status === 404 && isUsableStoredSession(session)) {
                return session;
            }

if (!response.ok) {
                throw new Error("Stored session is no longer valid");
            }

const refreshedSession = await response.json();
            if (!refreshedSession?.token) {
                throw new Error("Stored session response is invalid");
            }

cms.write(cms.KEYS.session, refreshedSession);
            return refreshedSession;
        } catch (error) {
            cms.remove(cms.KEYS.session);
            return null;
        }
    }

function isUsableStoredSession(session) {
        if (session?.user?.role === "master") return true;
        const permissions = Array.isArray(session?.permissions) ? session.permissions : session?.user?.permissions;
        return Array.isArray(permissions) && permissions.length > 0;
    }

async function logoutToken(token) {
        if (!token || !window.fetch || !/^https?:$/i.test(window.location.protocol)) return;

await fetch("api/logout", {
            method: "POST",
            headers: {
                Authorization: `Bearer ${token}`
            }
        });
    }

function applySession(session) {
        if (Array.isArray(session?.permissionCatalog)) {
            state.permissionCatalog = session.permissionCatalog;
        }
        if (els.contentLink) {
            els.contentLink.hidden = !hasAnyContentPermission(session);
        }
    }

function sessionHasPermission(session, permission) {
        if (session?.user?.role === "master") return true;
        const permissions = Array.isArray(session?.permissions) ? session.permissions : session?.user?.permissions;
        return Array.isArray(permissions) && permissions.includes(permission);
    }

function hasPermission(permission) {
        return sessionHasPermission(getSession(), permission);
    }

function hasAnyContentPermission(session = getSession()) {
        return ["work", "services", "technologies", "advanced", "users"].some((permission) => sessionHasPermission(session, permission));
    }

function showLogin() {
        els.loginPanel.hidden = false;
        els.dashboard.hidden = true;
        resetScroll();
    }

function showDashboard() {
        els.loginPanel.hidden = true;
        els.dashboard.hidden = false;
        const session = getSession();
        if (session) applySession(session);
        resetScroll();
        render();
    }

function showNoAccess() {
        els.loginPanel.hidden = true;
        els.dashboard.hidden = false;
        if (els.contentLink) els.contentLink.hidden = !hasAnyContentPermission();
        setStatus("Access denied", true);
        state.leads = [];
        render();
        els.detail.innerHTML = `<div class="admin-empty-state">This account does not have Lead Inbox access.</div>`;
    }

async function loadLeads() {
        const session = getSession();
        if (!session?.token) {
            showLogin();
            return;
        }

if (!sessionHasPermission(session, "leads")) {
            showNoAccess();
            return;
        }

setStatus("Loading leads", false);

try {
            const response = await fetch("api/leads", {
                headers: {
                    Authorization: `Bearer ${session.token}`
                }
            });

if (response.status === 401) {
                cms.remove(cms.KEYS.session);
                showLogin();
                return;
            }

if (response.status === 403) {
                showNoAccess();
                return;
            }

if (!response.ok) {
                throw new Error("Lead load failed");
            }

const payload = await response.json();
            state.leads = normalizeLeads(payload.leads || []);
            mergeLocalFallbackLeads();
            setStatus("Ready", false);
        } catch (error) {
            state.leads = normalizeLeads(readLocalFallbackLeads());
            setStatus(state.leads.length ? "Showing local leads" : "Could not load leads", !state.leads.length);
        }

render();
    }

function normalizeLeads(leads) {
        return (Array.isArray(leads) ? leads : [])
            .filter(Boolean)
            .map((lead) => ({
                id: String(lead.id || `lead-${Date.now()}`),
                status: ["active", "archived", "deleted"].includes(lead.status) ? lead.status : "active",
                createdAt: lead.createdAt || new Date().toISOString(),
                updatedAt: lead.updatedAt || lead.createdAt || new Date().toISOString(),
                archivedAt: lead.archivedAt || null,
                deletedAt: lead.deletedAt || null,
                name: String(lead.name || ""),
                email: String(lead.email || ""),
                company: String(lead.company || ""),
                country: String(lead.country || ""),
                phone: String(lead.phone || ""),
                message: String(lead.message || ""),
                sourcePage: String(lead.sourcePage || ""),
                sourceUrl: String(lead.sourceUrl || ""),
                userAgent: String(lead.userAgent || "")
            }))
            .sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt));
    }

function mergeLocalFallbackLeads() {
        const fallback = readLocalFallbackLeads();
        if (fallback.length === 0) return;

const existingIds = new Set(state.leads.map((lead) => lead.id));
        fallback.forEach((lead) => {
            if (!existingIds.has(lead.id)) {
                state.leads.push(lead);
            }
        });
    }

function readLocalFallbackLeads() {
        try {
            return normalizeLeads(JSON.parse(window.localStorage.getItem(localFallbackKey) || "[]"));
        } catch (error) {
            return [];
        }
    }

function render() {
        const visible = filteredLeads();

els.tabs.forEach((tab) => {
            tab.classList.toggle("is-active", tab.dataset.leadView === state.view);
        });

els.viewTitle.textContent = viewLabels[state.view] || "Leads";
        els.clearDeleted.hidden = state.view !== "deleted" || countByStatus("deleted") === 0;

renderCounts();
        renderList(visible);
        renderDetail(visible);
    }

function filteredLeads() {
        const query = state.query;
        return state.leads.filter((lead) => {
            if (lead.status !== state.view) return false;
            if (!query) return true;

return [
                lead.name,
                lead.email,
                lead.company,
                lead.country,
                lead.phone,
                lead.message,
                lead.sourcePage,
                lead.sourceUrl
            ].join(" ").toLowerCase().includes(query);
        });
    }

function renderCounts() {
        const active = countByStatus("active");
        const archived = countByStatus("archived");
        const deleted = countByStatus("deleted");

els.countActive.textContent = `${active} leads`;
        els.countArchived.textContent = `${archived} leads`;
        els.countDeleted.textContent = `${deleted} leads`;
        els.totalActive.textContent = String(active);
        els.totalArchived.textContent = String(archived);
        els.totalDeleted.textContent = String(deleted);
        els.totalAll.textContent = String(state.leads.length);
    }

function countByStatus(status) {
        return state.leads.filter((lead) => lead.status === status).length;
    }

function renderList(leads) {
        els.listCount.textContent = String(leads.length);

if (leads.length === 0) {
            state.selectedId = null;
            els.list.innerHTML = `<div class="admin-empty-state">No ${esc(state.view)} leads yet.</div>`;
            return;
        }

if (!state.selectedId || !leads.some((lead) => lead.id === state.selectedId)) {
            state.selectedId = leads[0].id;
        }

els.list.innerHTML = leads.map((lead) => `
            <button class="${lead.id === state.selectedId ? "is-active" : ""}" type="button" data-lead-id="${esc(lead.id)}">
                <strong>${esc(lead.name || "Unnamed lead")}</strong>
                <span>${esc([lead.email, lead.company].filter(Boolean).join(" / ") || "No email")}</span>
                <em>${esc(formatDate(lead.createdAt))}</em>
            </button>
        `).join("");
    }

function renderDetail(leads) {
        const lead = leads.find((item) => item.id === state.selectedId);
        if (!lead) {
            els.detailStatus.textContent = "Empty";
            els.detail.innerHTML = `<div class="admin-empty-state">Select a lead to view details.</div>`;
            return;
        }

els.detailStatus.textContent = lead.status;
        els.detail.innerHTML = `
            <div class="admin-lead-card">
                <div class="admin-lead-head">
                    <div class="admin-lead-head-main">
                        <span>${esc(formatDate(lead.createdAt))}</span>
                        <h2>${esc(lead.name || "Unnamed lead")}</h2>
                        <p>${esc(lead.company || "No company provided")}</p>
                    </div>
                    <div class="admin-lead-head-controls">
                        <div class="admin-lead-badges">
                            <strong class="admin-lead-status-badge">${esc(lead.status)}</strong>
                            ${isLocalId(lead.id) ? `<strong class="admin-lead-local-badge">Local backup</strong>` : ""}
                        </div>
                        <div class="admin-lead-head-actions">
                            ${renderActions(lead)}
                        </div>
                    </div>
                </div>

<dl class="admin-lead-fields">
                    ${renderField("Email", lead.email, lead.email ? `mailto:${lead.email}` : "")}
                    ${renderField("Phone", [lead.country, lead.phone].filter(Boolean).join(" "), lead.phone ? `tel:${lead.phone}` : "")}
                    ${renderField("Company", lead.company)}
                    ${renderField("Source Page", lead.sourcePage)}
                    ${renderField("Source URL", lead.sourceUrl, lead.sourceUrl)}
                    ${renderField("Updated", formatDate(lead.updatedAt))}
                </dl>

<section class="admin-lead-message">
                    <span>Message</span>
                    <p>${esc(lead.message || "No message provided.")}</p>
                </section>
            </div>
        `;
    }

function renderField(label, value, href = "") {
        const content = value || "Not provided";
        const rendered = href
            ? `<a href="${esc(href)}" target="${href.startsWith("http") ? "_blank" : "_self"}" rel="noopener">${esc(content)}</a>`
            : `<span>${esc(content)}</span>`;

return `
            <div>
                <dt>${esc(label)}</dt>
                <dd>${rendered}</dd>
            </div>
        `;
    }

function renderActions(lead) {
        if (lead.status === "deleted") {
            return `
                <button class="admin-primary-button" type="button" data-lead-id="${esc(lead.id)}" data-lead-action="restore">Restore</button>
                <button class="admin-danger-button" type="button" data-lead-id="${esc(lead.id)}" data-lead-action="remove">Delete Forever</button>
            `;
        }

if (lead.status === "archived") {
            return `
                <button class="admin-primary-button" type="button" data-lead-id="${esc(lead.id)}" data-lead-action="restore">Restore</button>
                <button class="admin-danger-button" type="button" data-lead-id="${esc(lead.id)}" data-lead-action="delete">Move to Deleted</button>
            `;
        }

return `
            <button class="admin-secondary-button" type="button" data-lead-id="${esc(lead.id)}" data-lead-action="archive">Archive</button>
            <button class="admin-danger-button" type="button" data-lead-id="${esc(lead.id)}" data-lead-action="delete">Delete</button>
        `;
    }

async function updateLead(id, action) {
        if (action === "delete" && !window.confirm("Move this lead to Deleted?")) return;
        if (action === "remove" && !window.confirm("Delete this lead forever?")) return;

if (isLocalId(id)) {
            updateLocalLead(id, action);
            return;
        }

await patchLeads({ id, action });
    }

async function clearDeletedLeads() {
        if (!window.confirm("Delete all records in the Deleted view forever?")) return;

const hasLocalDeleted = state.leads.some((lead) => isLocalId(lead.id) && lead.status === "deleted");
        const hasServerDeleted = state.leads.some((lead) => !isLocalId(lead.id) && lead.status === "deleted");

if (hasLocalDeleted) {
            writeLocalFallbackLeads(readLocalFallbackLeads().filter((lead) => lead.status !== "deleted"));
            state.leads = state.leads.filter((lead) => !(isLocalId(lead.id) && lead.status === "deleted"));
            state.selectedId = null;
        }

if (hasServerDeleted) {
            await patchLeads({ action: "clear-deleted" });
            return;
        }

setStatus("Deleted leads cleared", false);
        render();
    }

async function patchLeads(payload) {
        const session = getSession();
        if (!session?.token) {
            showLogin();
            return;
        }

setStatus("Updating lead", false);

try {
            const response = await fetch("api/leads", {
                method: "PATCH",
                headers: {
                    "Content-Type": "application/json",
                    Authorization: `Bearer ${session.token}`
                },
                body: JSON.stringify(payload)
            });

if (!response.ok) {
                throw new Error("Lead update failed");
            }

const data = await response.json();
            state.leads = normalizeLeads(data.leads || []);
            mergeLocalFallbackLeads();
            state.selectedId = null;
            setStatus("Updated", false);
            render();
        } catch (error) {
            setStatus("Update failed", true);
        }
    }

function updateLocalLead(id, action) {
        const now = new Date().toISOString();
        let localLeads = readLocalFallbackLeads();
        const lead = localLeads.find((item) => item.id === id);

if (!lead) {
            setStatus("Local lead not found", true);
            return;
        }

if (action === "archive") {
            lead.status = "archived";
            lead.archivedAt = now;
            lead.deletedAt = null;
        } else if (action === "restore") {
            lead.status = "active";
            lead.archivedAt = null;
            lead.deletedAt = null;
        } else if (action === "delete") {
            lead.status = "deleted";
            lead.deletedAt = now;
        } else if (action === "remove") {
            localLeads = localLeads.filter((item) => item.id !== id);
        } else {
            setStatus("Unsupported action", true);
            return;
        }

if (action !== "remove") {
            lead.updatedAt = now;
        }

writeLocalFallbackLeads(localLeads);
        state.leads = state.leads.filter((item) => !isLocalId(item.id));
        mergeLocalFallbackLeads();
        state.selectedId = null;
        setStatus("Updated local lead", false);
        render();
    }

function writeLocalFallbackLeads(leads) {
        window.localStorage.setItem(localFallbackKey, JSON.stringify(normalizeLeads(leads)));
    }

function isLocalId(id) {
        return String(id || "").startsWith("local-");
    }

function exportCsv() {
        const rows = filteredLeads();
        const header = ["Status", "Created", "Name", "Email", "Company", "Country", "Phone", "Message", "Source"];
        const csv = [header, ...rows.map((lead) => [
            lead.status,
            lead.createdAt,
            lead.name,
            lead.email,
            lead.company,
            lead.country,
            lead.phone,
            lead.message,
            lead.sourceUrl
        ])].map((row) => row.map(csvCell).join(",")).join("\n");

const blob = new Blob([csv], { type: "text/csv" });
        const url = URL.createObjectURL(blob);
        const link = document.createElement("a");
        link.href = url;
        link.download = `signalhgai-${state.view}-leads.csv`;
        link.click();
        URL.revokeObjectURL(url);
        setStatus("Export ready", false);
    }

function csvCell(value) {
        return `"${String(value ?? "").replace(/"/g, '""')}"`;
    }

function formatDate(value) {
        const date = new Date(value);
        if (Number.isNaN(date.getTime())) return "Unknown time";

return new Intl.DateTimeFormat(undefined, {
            dateStyle: "medium",
            timeStyle: "short"
        }).format(date);
    }

function resetScroll() {
        window.requestAnimationFrame(() => {
            window.scrollTo({ top: 0, left: 0, behavior: "auto" });
        });
    }

function setStatus(message, isError) {
        if (!els.status) return;
        els.status.textContent = message;
        els.status.classList.toggle("is-error", Boolean(isError));
    }

function esc(value) {
        return cms.escapeHtml(value);
    }
})();

${this.title}

Code Editor : admin-leads.js