TeamLive Calendar Feed

Status: 0 shift(s), last captured 2026-07-28T01:06:06.042Z
Scraper: Last headless scrape succeeded at 2026-07-28T01:06:16.462Z
Google sync: Last Google Calendar sync succeeded at 2026-07-28T01:06:22.344Z
Harri: Last Harri schedule fetch succeeded at 2026-07-28T01:06:15.738Z

Local feed URL

http://127.0.0.1:8765/calendar.ics?token=gG73K-KXs6MltiVAVtjAAW_ikMc2g3I-

Public feed URL

https://35-225-27-236.sslip.io/calendar.ics?token=gG73K-KXs6MltiVAVtjAAW_ikMc2g3I-

Capture bookmarklet

Drag this to the bookmarks bar, then click it while viewing TeamLive shift trading:

Capture TeamLive shifts

Or copy this into the Chrome address bar while TeamLive is open:

javascript:(()=>{const endpoint="http://127.0.0.1:8765/capture?token=gG73K-KXs6MltiVAVtjAAW_ikMc2g3I-";const capture=(()=>{const rows=(function extractPendingShiftRows() {
  const dateRe =
    /(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun),\s*\d{1,2}\s+(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[a-z]*,\s*\d{4}/i;
  const timeRe =
    /(\d{1,2}:\d{2}\s*[ap]m)\s*-\s*(\d{1,2}:\d{2}\s*[ap]m)(?:\s*\|\s*([\d.]+\s*hrs?))?/i;
  const clean = (value) =>
    String(value || "")
      .replace(/\u00a0/g, " ")
      .replace(/[ \t]+/g, " ")
      .trim();
  const lines = (value) =>
    String(value || "")
      .split(/\n+/)
      .map(clean)
      .filter(Boolean);

  function parseBlock(text) {
    const blockLines = lines(text);
    const joined = blockLines.join("\n");
    const dateMatch = joined.match(dateRe);
    const timeMatch = joined.match(timeRe);
    if (!dateMatch || !timeMatch) return null;

    let offeredByLabel = "Offered by";
    let offeredBy = "Unknown";
    for (let index = 0; index < blockLines.length; index += 1) {
      if (/^Offered(?:\s+to\s+all)?\s+by$/i.test(blockLines[index])) {
        offeredByLabel = blockLines[index];
        offeredBy = blockLines[index + 1] || offeredBy;
        break;
      }
      const inline = blockLines[index].match(/^(Offered(?:\s+to\s+all)?\s+by)\s+(.+)$/i);
      if (inline) {
        offeredByLabel = inline[1];
        offeredBy = inline[2];
        break;
      }
    }

    const role =
      blockLines.find((line) => /^Team Member$/i.test(line) || /\bTeam Member\b/i.test(line)) ||
      "Team Member";
    const locationLine =
      blockLines.find(
        (line) =>
          /\b\d{3,5}\s+SS\b/i.test(line) ||
          /\b\d{3,5}\b.*\b[A-Z]{2}\b.*\b[A-Za-z]+/i.test(line),
      ) || "";
    const location = clean(locationLine.replace(dateRe, "").replace(timeRe, ""));
    const statusMatch = joined.match(/Awaiting manager(?:['’]s)?\s+approval/i);
    const status = clean(statusMatch?.[0] || "Awaiting manager's approval").replace(
      /manager’s/g,
      "manager's",
    );

    return {
      offeredByLabel,
      offeredBy: clean(offeredBy),
      role: clean(role),
      location: clean(location),
      date: clean(dateMatch[0]),
      startTime: clean(timeMatch[1]),
      endTime: clean(timeMatch[2]),
      hours: clean(timeMatch[3] || ""),
      status,
    };
  }

  function personFromRow(row) {
    return clean(row?.querySelector?.(".request-details .bold")?.innerText || "");
  }

  function parseSwapGroup(firstRow) {
    if (!firstRow || !/Shift swapping by/i.test(firstRow.innerText || "")) return null;

    const outgoing = parseBlock(firstRow.innerText || "");
    if (!outgoing) return null;

    let incomingRow = firstRow.nextElementSibling;
    let incoming = null;
    while (incomingRow && !incomingRow.classList?.contains("first-row")) {
      if (!incomingRow.classList?.contains("actions-row-wrapper")) {
        incoming = parseBlock(incomingRow.innerText || "");
        if (incoming) break;
      }
      incomingRow = incomingRow.nextElementSibling;
    }
    if (!incoming) return null;

    return {
      ...incoming,
      requestType: "swap",
      offeredByLabel: "Swapping with",
      offeredBy: personFromRow(incomingRow) || incoming.offeredBy || "Unknown",
      status: outgoing.status,
      outgoingDate: outgoing.date,
      outgoingStartTime: outgoing.startTime,
      outgoingEndTime: outgoing.endTime,
      outgoingHours: outgoing.hours,
      outgoingRole: outgoing.role,
      outgoingLocation: outgoing.location,
    };
  }

  function candidates() {
    const selectors =
      "tr,[role=row],li,article,section,.request,.request-item,.shift,.shift-row,.card,div";
    const swapFirstRows = [...document.querySelectorAll("tr.first-row")].filter((row) =>
      /Shift swapping by/i.test(row.innerText || ""),
    );
    const parsedSwaps = swapFirstRows
      .map((firstRow) => ({ firstRow, row: parseSwapGroup(firstRow) }))
      .filter((entry) => entry.row);
    const items = [];
    for (const el of document.querySelectorAll(selectors)) {
      if (parsedSwaps.some(({ firstRow }) => firstRow === el || firstRow.contains(el))) continue;
      const text = el.innerText || "";
      if (!/Awaiting manager/i.test(text) || !dateRe.test(text) || !timeRe.test(text)) continue;
      const dateCount = (text.match(new RegExp(dateRe.source, "gi")) || []).length;
      const timeCount = (text.match(new RegExp(timeRe.source, "gi")) || []).length;
      if (dateCount !== 1 || timeCount !== 1) continue;
      items.push({ el, text, area: text.length });
    }
    items.sort((a, b) => a.area - b.area);

    const chosen = [];
    for (const item of items) {
      if (chosen.some((candidate) => candidate.el.contains(item.el) || candidate.text === item.text)) {
        continue;
      }
      chosen.push(item);
    }
    return [
      ...parsedSwaps.map((entry) => entry.row),
      ...chosen.map((item) => parseBlock(item.text)).filter(Boolean),
    ];
  }

  function fallback() {
    const bodyLines = lines(document.body.innerText);
    const rows = [];
    for (let index = 0; index < bodyLines.length; index += 1) {
      if (!dateRe.test(bodyLines[index])) continue;
      const windowText = bodyLines.slice(Math.max(0, index - 8), Math.min(bodyLines.length, index + 8)).join("\n");
      const parsed = parseBlock(windowText);
      if (parsed) rows.push(parsed);
    }
    return rows;
  }

  let rows = candidates();
  if (!rows.length) rows = fallback();

  const seen = new Set();
  return rows.filter((row) => {
    const key = [
      row.requestType || "offer",
      row.date,
      row.startTime,
      row.endTime,
      row.offeredBy,
      row.location,
      row.outgoingDate || "",
      row.outgoingStartTime || "",
      row.outgoingEndTime || "",
    ].join("|");
    if (seen.has(key)) return false;
    seen.add(key);
    return true;
  });
})();const pageState=(function readPendingShiftPageState(rows = []) {
  const text = document.body?.innerText || "";
  const hasShiftTradingUrl = /\/shift-trading(?:[/?#]|$)/i.test(location.href);
  const hasShiftTradeText = /\bShift Trade\b/i.test(text);
  const hasAwaitingManagerText = /Awaiting manager/i.test(text);
  const hasNoRequestsText = /(?:There are no|No)[\s\S]{0,80}requests/i.test(text);
  const renderedCorrectly =
    hasShiftTradingUrl && hasShiftTradeText && (rows.length > 0 || hasNoRequestsText);

  return {
    renderedCorrectly,
    hasShiftTradingUrl,
    hasShiftTradeText,
    hasAwaitingManagerText,
    hasNoRequestsText,
    rowCount: rows.length,
  };
})(rows);return{rows,sourceRenderedCorrectly:pageState.renderedCorrectly,pageState};})();fetch(endpoint,{method:"POST",mode:"cors",headers:{"Content-Type":"application/json"},body:JSON.stringify({sourceUrl:location.href,capturedAt:new Date().toISOString(),...capture})}).then(r=>r.ok?r.json():r.text().then(t=>Promise.reject(new Error(t)))).then(j=>alert("Captured "+j.count+" TeamLive pending shift"+(j.count===1?"":"s")+" for the calendar feed.")).catch(e=>alert("TeamLive calendar capture failed: "+e.message));})();

Google Calendar

Google Calendar cannot subscribe to a localhost URL. Expose the tokenized feed URL through HTTPS before adding it in Google Calendar.