manage list correctly

app/bot.py

@@ -1,10 +1,10 @@
-import time
 import logging
 from typing import Optional
 
 from config import BotConfig, HARDCODED_USERNAME, HARDCODED_PASSWORD
 from browser_session import BrowserSession
 from auth_handler import AuthHandler
+from modify_listings_updater import update_wo_case_listing_prices
 
 import queue
 
@@ -70,12 +70,18 @@ class BotRunner:
                 self._log("Failed to open target page")
                 return
 
-            self._log("Phase 3 ▶ Browser active — click Stop to close")
-            while True:
-                if self.stop_event and self.stop_event.is_set():
-                    self._log("Stopped by user")
-                    break
-                time.sleep(0.5)
+            self._log("Phase 3 - Updating w/o case listing prices")
+            result = update_wo_case_listing_prices(
+                session.page,
+                dashboard_url=self.target_url,
+                stop_event=self.stop_event,
+            )
+            self._log(
+                "Update complete: "
+                f"matched={result['matched']}, updated={result['updated']}, "
+                f"failed={result['failed']}, pages={result['pages_scanned']}"
+            )
+            self._log(f"CSV saved: {result['csv_path']}")
 
         except Exception as e:
             logger.exception("Unexpected error in BotRunner")

app/main.py

@@ -7,13 +7,13 @@ Usage:
 """
 import argparse
 import sys
-import time
 from pathlib import Path
 
 from config import BotConfig, DEFAULT_TARGET_URL, HARDCODED_USERNAME, HARDCODED_PASSWORD
 from logger_setup import setup_logger
 from browser_session import BrowserSession
 from auth_handler import AuthHandler
+from modify_listings_updater import update_wo_case_listing_prices
 
 
 def build_parser() -> argparse.ArgumentParser:
@@ -76,14 +76,17 @@ def main() -> None:
             logger.error("Failed to open target page — aborting")
             sys.exit(1)
 
-        # Keep browser open for user to interact
-        logger.info("Browser session active. Press Ctrl+C to exit.")
-        print("\n  Press Ctrl+C in this terminal to close the browser.")
-        try:
-            while True:
-                time.sleep(1)
-        except KeyboardInterrupt:
-            logger.info("Interrupted by user")
+        logger.info("")
+        logger.info("Phase 3 - Updating w/o case listing prices")
+        result = update_wo_case_listing_prices(session.page, dashboard_url=args.url)
+        logger.info(
+            "Update complete: matched=%s, updated=%s, failed=%s, pages=%s",
+            result["matched"],
+            result["updated"],
+            result["failed"],
+            result["pages_scanned"],
+        )
+        logger.info("CSV saved: %s", result["csv_path"])
 
     except Exception as exc:
         logger.error(f"Unexpected error: {exc}", exc_info=True)

app/modify_listings_updater.py

@@ -0,0 +1,318 @@
+import csv
+import logging
+import re
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional
+from urllib.parse import urljoin
+
+from playwright.sync_api import Page, TimeoutError as PlaywrightTimeoutError
+
+from config import DEFAULT_TARGET_URL
+
+logger = logging.getLogger("bot")
+
+CSV_HEADERS = ["Timestamp", "Listing ID", "Item Title", "Old Price", "New Price"]
+ROW_SELECTOR = "table.table-striped tbody tr"
+TARGET_MARKER = "w/o case"
+TARGET_PRICE = "9.95"
+
+
+def _ensure_csv(csv_path: Path) -> None:
+    csv_path.parent.mkdir(parents=True, exist_ok=True)
+    if not csv_path.exists() or csv_path.stat().st_size == 0:
+        with csv_path.open("w", newline="", encoding="utf-8") as csv_file:
+            csv.writer(csv_file).writerow(CSV_HEADERS)
+
+
+def _append_change(csv_path: Path, listing: Dict[str, str], new_price: str) -> None:
+    with csv_path.open("a", newline="", encoding="utf-8") as csv_file:
+        csv.writer(csv_file).writerow(
+            [
+                datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                listing["listing_id"],
+                listing["title"],
+                listing["old_price"],
+                new_price,
+            ]
+        )
+
+
+def _clean_title(cell_text: str) -> str:
+    lines = [line.strip() for line in cell_text.splitlines() if line.strip()]
+    skipped_patterns = (
+        re.compile(r"edit\s+my\s+listing", re.IGNORECASE),
+        re.compile(r"\bcount\s*:", re.IGNORECASE),
+        re.compile(r"\bw/o\s+case\b", re.IGNORECASE),
+    )
+
+    for line in lines:
+        if not any(pattern.search(line) for pattern in skipped_patterns):
+            return line
+
+    cleaned = re.sub(r"edit\s+my\s+listing", "", cell_text, flags=re.IGNORECASE)
+    cleaned = re.sub(r"count\s*:\s*\d+.*", "", cleaned, flags=re.IGNORECASE)
+    return " ".join(cleaned.split()) or "Unknown Title"
+
+
+def _extract_price(cell_text: str, fallback_value: str = "") -> str:
+    match = re.search(r"\$\s*[\d,]+(?:\.\d{1,2})?", cell_text)
+    if match:
+        return match.group(0).replace(" ", "")
+
+    match = re.search(r"[\d,]+(?:\.\d{1,2})", cell_text)
+    if match:
+        return match.group(0)
+
+    return fallback_value.strip()
+
+
+def _extract_listing_id(name_value: str) -> Optional[str]:
+    match = re.search(r"(?:price|selectcb)_(\d+)", name_value or "")
+    return match.group(1) if match else None
+
+
+def _wait_for_dashboard(page: Page) -> None:
+    page.wait_for_selector(ROW_SELECTOR, state="attached", timeout=30000)
+
+
+def _scan_current_dashboard_page(page: Page) -> List[Dict[str, str]]:
+    _wait_for_dashboard(page)
+    rows = page.locator(ROW_SELECTOR)
+    matched: List[Dict[str, str]] = []
+
+    for index in range(rows.count()):
+        row = rows.nth(index)
+        cells = row.locator("td")
+
+        if cells.count() < 4:
+            continue
+
+        title_cell = cells.nth(1)
+        price_cell = cells.nth(3)
+        title_cell_text = title_cell.inner_text(timeout=3000)
+
+        if TARGET_MARKER not in title_cell_text.lower():
+            continue
+
+        price_input = price_cell.locator("input[type='text'][name^='price_']").first
+        price_input_name = ""
+        price_input_value = ""
+        try:
+            price_input_name = price_input.get_attribute("name", timeout=1000) or ""
+            price_input_value = price_input.get_attribute("value", timeout=1000) or ""
+        except Exception:
+            pass
+
+        listing_id = _extract_listing_id(price_input_name)
+        if not listing_id:
+            checkbox = row.locator("input[name^='selectcb_']").first
+            try:
+                listing_id = _extract_listing_id(checkbox.get_attribute("name", timeout=1000) or "")
+            except Exception:
+                listing_id = None
+
+        edit_link = title_cell.locator("a:has-text('Edit My Listing')").first
+        try:
+            edit_href = edit_link.get_attribute("href", timeout=2000) or ""
+        except Exception:
+            edit_href = ""
+
+        if not listing_id or not edit_href:
+            logger.warning("Skipping matched row %s because listing id or edit href is missing", index + 1)
+            continue
+
+        matched.append(
+            {
+                "listing_id": listing_id,
+                "title": _clean_title(title_cell_text),
+                "old_price": _extract_price(price_cell.inner_text(timeout=3000), price_input_value),
+                "edit_url": urljoin(page.url, edit_href),
+            }
+        )
+
+    logger.info("Found %s matching listing(s) on current dashboard page", len(matched))
+    return matched
+
+
+def _click_value_input(page: Page, label_pattern: re.Pattern) -> bool:
+    inputs = page.locator("input[type='submit'], input[type='button']")
+    for index in range(inputs.count()):
+        candidate = inputs.nth(index)
+        try:
+            value = candidate.get_attribute("value", timeout=1000) or ""
+            if label_pattern.search(value) and candidate.is_visible(timeout=1000) and candidate.is_enabled(timeout=1000):
+                candidate.click()
+                return True
+        except Exception:
+            continue
+    return False
+
+
+def _click_control(page: Page, label: str) -> None:
+    label_pattern = re.compile(re.escape(label), re.IGNORECASE)
+
+    candidates = [
+        page.get_by_role("button", name=label_pattern),
+        page.get_by_role("link", name=label_pattern),
+        page.locator("button").filter(has_text=label_pattern),
+        page.locator("a").filter(has_text=label_pattern),
+    ]
+
+    for locator in candidates:
+        candidate = locator.first
+        try:
+            if candidate.is_visible(timeout=2000) and candidate.is_enabled(timeout=2000):
+                candidate.click()
+                return
+        except Exception:
+            continue
+
+    if _click_value_input(page, label_pattern):
+        return
+
+    raise RuntimeError(f"Could not find clickable control labeled '{label}'")
+
+
+def _wait_after_click(page: Page) -> None:
+    try:
+        page.wait_for_load_state("networkidle", timeout=15000)
+    except PlaywrightTimeoutError:
+        page.wait_for_load_state("domcontentloaded", timeout=15000)
+
+
+def _process_listing(page: Page, listing: Dict[str, str], new_price: str) -> None:
+    logger.info("Updating listing %s: %s", listing["listing_id"], listing["title"])
+
+    page.goto(listing["edit_url"], wait_until="domcontentloaded", timeout=30000)
+    _wait_after_click(page)
+
+    _click_control(page, "Update Your Listing")
+    _wait_after_click(page)
+
+    price_input = page.locator(f"input[name='price_{listing['listing_id']}']").first
+    price_input.wait_for(state="visible", timeout=30000)
+    price_input.fill("")
+    price_input.fill(new_price)
+
+    _click_control(page, "Update Changed Prices")
+    _wait_after_click(page)
+
+
+def _is_disabled(locator) -> bool:
+    try:
+        aria_disabled = (locator.get_attribute("aria-disabled", timeout=500) or "").lower()
+        class_name = (locator.get_attribute("class", timeout=500) or "").lower()
+        parent_class = (locator.locator("xpath=ancestor::*[self::li or self::button][1]").get_attribute("class", timeout=500) or "").lower()
+        return aria_disabled == "true" or "disabled" in class_name or "disabled" in parent_class
+    except Exception:
+        return False
+
+
+def _click_next_page(page: Page) -> bool:
+    candidates = [
+        page.locator("a[rel='next'], button[rel='next']"),
+        page.get_by_role("link", name=re.compile(r"^\s*(next|>)\s*$", re.IGNORECASE)),
+        page.get_by_role("button", name=re.compile(r"^\s*(next|>)\s*$", re.IGNORECASE)),
+        page.locator("a, button").filter(has_text=re.compile(r"^\s*(next|>)\s*$", re.IGNORECASE)),
+    ]
+
+    for locator in candidates:
+        for index in range(locator.count()):
+            candidate = locator.nth(index)
+            try:
+                if candidate.is_visible(timeout=1000) and candidate.is_enabled(timeout=1000) and not _is_disabled(candidate):
+                    candidate.click()
+                    _wait_after_click(page)
+                    _wait_for_dashboard(page)
+                    return True
+            except Exception:
+                continue
+
+    return False
+
+
+def update_wo_case_listing_prices(
+    page: Page,
+    dashboard_url: str = DEFAULT_TARGET_URL,
+    target_price: str = TARGET_PRICE,
+    csv_path: str = "changed_listings.csv",
+    max_pages: int = 1000,
+    stop_event: Any = None,
+    status_callback: Optional[Callable[[Dict[str, Any]], None]] = None,
+) -> Dict[str, Any]:
+    """
+    Update dashboard listings marked "w/o case" to the target price.
+
+    The active Playwright page is expected to already be authenticated and on
+    the modify listings dashboard.
+    """
+    output_path = Path(csv_path)
+    _ensure_csv(output_path)
+
+    total_matched = 0
+    total_updated = 0
+    total_failed = 0
+    current_page_number = 1
+    current_dashboard_url = page.url or dashboard_url
+
+    while current_page_number <= max_pages:
+        if stop_event and stop_event.is_set():
+            logger.info("Listing price update stopped by user")
+            break
+
+        logger.info("Scanning modify listings dashboard page %s", current_page_number)
+        _wait_for_dashboard(page)
+
+        if status_callback:
+            status_callback({"state": "Scanning dashboard", "current_page": current_page_number})
+
+        listings = _scan_current_dashboard_page(page)
+        total_matched += len(listings)
+
+        for listing in listings:
+            if stop_event and stop_event.is_set():
+                logger.info("Listing price update stopped by user")
+                break
+
+            try:
+                _process_listing(page, listing, target_price)
+                _append_change(output_path, listing, target_price)
+                total_updated += 1
+                logger.info("Updated listing %s to %s", listing["listing_id"], target_price)
+            except Exception as exc:
+                total_failed += 1
+                logger.exception("Failed to update listing %s: %s", listing.get("listing_id"), exc)
+            finally:
+                page.goto(current_dashboard_url, wait_until="domcontentloaded", timeout=30000)
+                _wait_after_click(page)
+
+            if status_callback:
+                status_callback(
+                    {
+                        "state": "Updating prices",
+                        "current_page": current_page_number,
+                        "matched": total_matched,
+                        "updated": total_updated,
+                        "failed": total_failed,
+                    }
+                )
+
+        if stop_event and stop_event.is_set():
+            break
+
+        logger.info("Finished dashboard page %s; checking pagination", current_page_number)
+        if not _click_next_page(page):
+            logger.info("No enabled next page control found. Listing price update complete.")
+            break
+
+        current_page_number += 1
+        current_dashboard_url = page.url or current_dashboard_url
+
+    return {
+        "matched": total_matched,
+        "updated": total_updated,
+        "failed": total_failed,
+        "pages_scanned": current_page_number,
+        "csv_path": str(output_path.resolve()),
+    }

app/services/run_bot.py

@@ -1,6 +1,5 @@
 import logging
 import threading
-import time
 from dataclasses import dataclass, field
 from datetime import datetime
 from pathlib import Path
@@ -9,6 +8,7 @@ from typing import Any, Dict, List, Optional
 from auth_handler import AuthHandler
 from browser_session import BrowserSession
 from config import HARDCODED_USERNAME, HARDCODED_PASSWORD
+from modify_listings_updater import update_wo_case_listing_prices
 
 logger = logging.getLogger("bot")
 
@@ -81,8 +81,11 @@ class AutomationController:
             elif "opened" in lowered:
                 self._state.current_state = "Page loaded"
                 self._state.progress = max(self._state.progress, 50)
-            elif "browser active" in lowered:
-                self._state.current_state = "Browser active"
+            elif "updating w/o case" in lowered:
+                self._state.current_state = "Updating prices"
+                self._state.progress = max(self._state.progress, 60)
+            elif "update complete" in lowered:
+                self._state.current_state = "Complete"
                 self._state.progress = max(self._state.progress, 100)
 
     def _set_state(self, **updates: Any) -> None:
@@ -168,13 +171,26 @@ class AutomationController:
             self.append_log(f"Opened: {target_url}")
             self._set_state(progress=50, current_state="Page loaded")
 
-            self.append_log("Phase 3 ▶ Browser active — click Stop to close")
-            self._set_state(progress=100, current_state="Browser active")
-            while True:
-                if self._stop_event.is_set():
-                    self.append_log("Stopped by user")
-                    break
-                time.sleep(0.5)
+            self._set_state(progress=60, current_state="Updating prices")
+            self.append_log("Phase 3 - Updating w/o case listing prices")
+            result = update_wo_case_listing_prices(
+                session.page,
+                dashboard_url=target_url,
+                stop_event=self._stop_event,
+            )
+            self.append_log(
+                "Update complete: "
+                f"matched={result['matched']}, updated={result['updated']}, "
+                f"failed={result['failed']}, pages={result['pages_scanned']}"
+            )
+            self.append_log(f"CSV saved: {result['csv_path']}")
+            self._set_state(
+                progress=100,
+                current_state="Complete",
+                total_items_found=result["matched"],
+                current_page=result["pages_scanned"],
+                last_csv_path=result["csv_path"],
+            )
 
         except Exception as exc:
             logger.exception("Unexpected error in web runner")