Selected Projects

function setValue(el, value) {
    if (!el) return;

    el.focus();

    const nativeInputValueSetter = Object.getOwnPropertyDescriptor(
        window.HTMLInputElement.prototype,
        "value"
    ).set;

    nativeInputValueSetter.call(el, value);

    el.dispatchEvent(new Event('input', { bubbles: true }));
    el.dispatchEvent(new Event('change', { bubbles: true }));

    el.blur();
}

function waitFor(selector, callback, timeout = 10000) {
    const start = Date.now();

    const interval = setInterval(() => {
        const el = document.querySelector(selector);

        if (el) {
            clearInterval(interval);
            callback(el);
        }

        if (Date.now() - start > timeout) {
            clearInterval(interval);
            console.log("Timeout:", selector);
        }
    }, 200);
}

function cleanPhone(phone) {
    return phone.replace(/\D/g, '').replace(/^385/, '').slice(-9);
}

function splitAddress(full) {
    if (!full) return { street: "", number: "" };

    const match = full.match(/^(.*?)[\s,]+(\d+[a-zA-Z]?)/);

    if (match) {
        return {
            street: match[1].trim(),
            number: match[2].trim()
        };
    }

    return {
        street: full,
        number: ""
    };
}

function nameFromEmail(email) {
    if (!email) return { first: "", last: "" };

    const namePart = email.split("@")[0];

    const parts = namePart
        .replace(/[0-9]/g, '')
        .split(/[._-]+/);

    return {
        first: capitalize(parts[0] || ""),
        last: capitalize(parts[1] || "")
    };
}

function capitalize(str) {
    return str ? str.charAt(0).toUpperCase() + str.slice(1) : "";
}

const params = new URLSearchParams(window.location.search);

const name = params.get("name") || "";
const address = params.get("address") || "";
const city = params.get("city") || "";
const zip = params.get("zip") || "";
const phone = cleanPhone(params.get("phone") || "");
const email = params.get("email") || "";

let parts = name.trim().split(/\s+/);
let first = parts[0] || "";
let last = parts.slice(1).join(" ") || "";

// fallback if name is missing
if (!first || !last) {
    const fromEmail = nameFromEmail(email);
    first = first || fromEmail.first;
    last = last || fromEmail.last;
}

const { street, number } = splitAddress(address);

waitFor('button[aria-label="Pravna osoba"]', (btn) => {

    btn.click();

    waitFor('#company', (el) => {
        setValue(el, 'OPG Branko Marinov');
    });

    waitFor('#first_name', (el) => setValue(el, 'Branko'));
    waitFor('#last_name', (el) => setValue(el, 'Marinov'));

    waitFor('#email', (el) => setValue(el, 'opgbranko1@gmail.com'));
    waitFor('#phone', (el) => setValue(el, '998211395'));

    waitFor('#address', (el) => setValue(el, 'Gornji Vezac'));
    waitFor('#house_number', (el) => setValue(el, '18'));
    waitFor('#city', (el) => setValue(el, 'Primošten'));
    waitFor('#zip', (el) => setValue(el, '22202'));

    waitFor('#vat-sender', (el) => setValue(el, '42614167398'));
});

waitFor('#first-name', () => {

    const firstNames = document.querySelectorAll('#first-name');
    const lastNames = document.querySelectorAll('#last-name');

    // email has duplicate IDs — use type selector
    const emails = document.querySelectorAll('input[type="email"]');

    const phones = document.querySelectorAll('#phone-number');
    const streets = document.querySelectorAll('#street-address');
    const houses = document.querySelectorAll('#house-number');
    const cities = document.querySelectorAll('#city');
    const zips = document.querySelectorAll('#zip');

    const i = firstNames.length - 1;

    // Name parts
    setValue(firstNames[i], first);
    setValue(lastNames[i], last);

    // email — last occurrence is recipient
    setValue(emails[emails.length - 1], email);

    // phone
    setValue(phones[phones.length - 1], phone);

    // address
    setValue(streets[streets.length - 1], street);
    setValue(houses[houses.length - 1], number);

    // city / zip
    setValue(cities[cities.length - 1], city);
    setValue(zips[zips.length - 1], zip);

});

add_action('woocommerce_order_item_add_action_buttons', 'gls_worker_button');

function gls_worker_button($order) {

    if (!$order) return;

    $first = $order->get_shipping_first_name() ?: $order->get_billing_first_name();
    $last  = $order->get_shipping_last_name()  ?: $order->get_billing_last_name();

    $url = "https://glsautomate.opgbranko1.workers.dev?" . http_build_query([
        'name'    => trim($first . ' ' . $last),
        'address' => $order->get_shipping_address_1(),
        'city'    => $order->get_shipping_city(),
        'zip'     => $order->get_shipping_postcode(),
        'phone'   => $order->get_billing_phone(),
        'email'   => $order->get_billing_email()
    ]);

    echo '<a href="'.$url.'" target="_blank" class="button button-primary" style="margin-left:10px;">
     GLS AUTO
    </a>';
}

async function analyzeFile(file) {
  const MAX   = 512;
  const buf   = await file.slice(0, MAX).arrayBuffer();
  const bytes = new Uint8Array(buf);

  // ── Magic bytes detection ──────────────────────
  const MZ    = bytes[0]===0x4D && bytes[1]===0x5A; // PE/EXE/DLL
  const ELF   = bytes[0]===0x7F && bytes[1]===0x45; // Linux binary
  const SHEBANG = bytes[0]===0x23 && bytes[1]===0x21; // #!/...
  const OLE   = bytes[0]===0xD0 && bytes[1]===0xCF; // Office macro doc
  const ZIP   = bytes[0]===0x50 && bytes[1]===0x4B; // ZIP / DOCX / JAR

  if (MZ)     { score += 8; flags.push('Izvršna Windows datoteka (PE)'); }
  if (ELF)    { score += 8; flags.push('Izvršna Linux datoteka (ELF)'); }
  if (OLE)    { score += 6; flags.push('Stari Office format — može sadržavati makroe'); }

  // ── SHA-256 via SubtleCrypto (no server needed) ─
  const fullBuf = await file.arrayBuffer();
  const hashBuf = await crypto.subtle.digest('SHA-256', fullBuf);
  const sha256  = [...new Uint8Array(hashBuf)]
    .map(b => b.toString(16).padStart(2, '0')).join('');

  // ── Query MalwareBazaar by hash ────────────────
  const mbResult = await malwareBazaarCheck(sha256);
  if (mbResult.found) {
    score += 10;
    flags.push(`Hash pronaden u MalwareBazaar: ${mbResult.tags.join(', ')}`);
  }

  // ── Suspicious strings scan ────────────────────
  const text = new TextDecoder('utf-8', { fatal: false }).decode(buf);
  const SUSPICIOUS = [
    /powershell/i, /VirtualAlloc/i, /base64/i,
    /webclient/i,  /downloadstring/i, /invoke-expression/i
  ];
  for (const re of SUSPICIOUS) {
    if (re.test(text)) {
      score += 3;
      flags.push(`Sumnjiv string: ${re.source}`);
    }
  }

  return { score, flags, sha256 };
}

// Cloudflare Pages Function — proxy for Google Safe Browsing v4
// API key stored in CF env var GSB_API_KEY — never reaches the browser

export async function onRequestPost(context) {
  const { request, env } = context;
  const cors = { 'Content-Type': 'application/json',
                 'Access-Control-Allow-Origin': '*' };

  const apiKey = env.GSB_API_KEY;
  if (!apiKey) return new Response(
    JSON.stringify({ _status: 'not_configured' }),
    { status: 503, headers: cors }
  );

  const { url } = await request.json();

  const gsbRes = await fetch(
    `https://safebrowsing.googleapis.com/v4/threatMatches:find?key=${apiKey}`,
    {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        client: { clientId: 'scam-checker-hr', clientVersion: '1.0' },
        threatInfo: {
          threatTypes:      ['MALWARE', 'SOCIAL_ENGINEERING',
                             'UNWANTED_SOFTWARE'],
          platformTypes:    ['ANY_PLATFORM'],
          threatEntryTypes: ['URL'],
          threatEntries:    [{ url }],
        },
      }),
    }
  );

  // Forward Google's response — key stays server-side
  return new Response(await gsbRes.text(),
    { status: 200, headers: cors });
}