/*! Kori Collectibles v2.3.0 - FULL app.js with variant pill + PB/MB overlays (PRE/BLK/WHT) */
(function(){
'use strict';
const REST = window.KORI_REST || '/wp-json/kori/v2/';
const AJAX = window.KORI_AJAX || (window.ajaxurl || '/wp-admin/admin-ajax.php');
// ------- helpers -------
const $ = (s, c=document)=>c.querySelector(s);
const $$ = (s, c=document)=>Array.from(c.querySelectorAll(s));
const rest = p => fetch(REST+p,{credentials:'same-origin'}).then(r=>{if(!r.ok) throw 0; return r.json()});
const ajax = (action, data={}) => {
const body = new URLSearchParams({action, ...data}).toString();
return fetch(AJAX,{method:'POST',credentials:'same-origin',headers:{'Content-Type':'application/x-www-form-urlencoded'},body}).then(r=>r.json());
};
const svgPH = 'data:image/svg+xml;base64,'+btoa(`No image ${lbl}
`;
}
// Determine base URL of this script to resolve overlays/ folder
function scriptBaseUrl(){
try{
const scripts = Array.from(document.getElementsByTagName('script'));
const hit = scripts.find(sc=>/app\.js(\?|$)/.test(sc.src)) || scripts[scripts.length-1];
if (!hit || !hit.src) return '';
return hit.src.replace(/\/[^\/?#]*(\?[^#]*)?$/, '/');
}catch(_){}
return '';
}
const BASE_URL = scriptBaseUrl();
// File maps: generic (BLK/WHT) vs prismatic (PRE)
const OVERLAY_FILES = {
generic: {
PB: 'overlays/pokeball-overlay.png',
MB: 'overlays/masterball-overlay.png'
},
prismatic: {
PB: 'overlays/prismatic-pokeball-overlay.png',
MB: 'overlays/prismatic-masterball-overlay.png'
}
};
// Build the overlay `;
html += setsByEra[era].map(s=>{
const src = (s.local_logo||s.logo||'') || svgPH;
const sym = (s.local_symbol||s.symbol||'') || '';
return `
${sym ? `
` : `
`}
${s.name||''} ${s.code||''}
`;
}).join('');
html += '
${Array(12).fill().map(() => `
`).join('')}
`;
const container = shadow.getElementById('setsContainer');
// Check global cache first (immediate render, no loading state)
if (setsDataCache && Date.now() - setsDataCache.timestamp < SETS_CACHE_DURATION) {
container.innerHTML = ''; // Clear any loading state
renderSetsData(stage, container, setsDataCache.sets, shadow);
return;
}
// Check stage cache (immediate render, no loading state)
if (stage.__koriSetsData && Date.now() - stage.__koriSetsData.timestamp < SETS_CACHE_DURATION) {
container.innerHTML = ''; // Clear any loading state
renderSetsData(stage, container, stage.__koriSetsData.sets, shadow);
return;
}
// Fetch data with progress indication
rest('sets/local/full').then(sets=>{
// Store in global cache
setsDataCache = {
sets: sets,
timestamp: Date.now()
};
// Clear loading state and render
container.innerHTML = '';
renderSetsData(stage, container, sets, shadow);
}).catch(()=> {
container.innerHTML = `Failed to load sets
`;
});
}
// Cache for variant definitions
let variantDefinitionsCache = null;
// Function to get variant definitions (cached)
async function getVariantDefinitions() {
if (variantDefinitionsCache) return variantDefinitionsCache;
try {
const REST_BASE = (window.KORI_REST||'/wp-json/kori/v2/');
const response = await fetch(REST_BASE + 'variants/defs', { credentials: 'same-origin' });
if (response.ok) {
variantDefinitionsCache = await response.json();
return variantDefinitionsCache;
}
} catch (e) {
console.warn('Could not fetch variant definitions:', e);
}
return [];
}
// Function to build eBay search URL for a card variant
function buildEbayUrl(card, variantDefs = [], setInfo = {}) {
const vLabel = getVariantLabel(card);
const vKey = getVariantKey(card);
// Clean the card name (remove variant suffix)
const cleanCardName = stripVariantFromName(card.name) || card.name || '';
// Build card number in format 001/086 using set info
const cardNumber = card.card_number || '';
const setTotal = setInfo.total || setInfo.printed_total || '';
const setName = setInfo.name || '';
let cardNumberFormatted = '';
// Check if this is a promo card by looking at set name or set ID
const isPromo = setName.toLowerCase().includes('promos') ||
(card.set_id && card.set_id.toLowerCase().includes('promo'));
if (cardNumber && setTotal) {
// Check if this is a TG or GG card
const tgMatch = cardNumber.match(/^(TG)(\d+)$/i);
const ggMatch = cardNumber.match(/^(GG)(\d+)$/i);
if (tgMatch) {
// Format as TG01/TG30 (no extra padding for gallery cards)
const tgNumber = tgMatch[2].padStart(2, '0');
const tgTotal = setTotal.padStart(2, '0');
cardNumberFormatted = `TG${tgNumber}/TG${tgTotal}`;
} else if (ggMatch) {
// Format as GG01/GG70 (no extra padding for gallery cards)
const ggNumber = ggMatch[2].padStart(2, '0');
const ggTotal = setTotal.padStart(2, '0');
cardNumberFormatted = `GG${ggNumber}/GG${ggTotal}`;
} else if (isPromo) {
// Format promo cards with set prefix (SVP001, SWSH001, etc.)
const paddedNumber = cardNumber.padStart(3, '0');
const setPrefix = getPromoSetPrefix(setName, card.set_id);
cardNumberFormatted = `${setPrefix}${paddedNumber}`;
} else {
// Regular card formatting
const paddedNumber = cardNumber.padStart(3, '0');
const paddedTotal = setTotal.padStart(3, '0');
cardNumberFormatted = `${paddedNumber}/${paddedTotal}`;
}
} else if (cardNumber) {
if (isPromo) {
const setPrefix = getPromoSetPrefix(setName, card.set_id);
cardNumberFormatted = `${setPrefix}${cardNumber.padStart(3, '0')}`;
} else {
cardNumberFormatted = cardNumber.padStart(3, '0');
}
}
// Helper function to get promo set prefix
function getPromoSetPrefix(setName, setId) {
const name = (setName || '').toLowerCase();
const id = (setId || '').toLowerCase();
if (name.includes('scarlet') || name.includes('violet') || id.includes('sv')) return 'SVP';
if (name.includes('sword') || name.includes('shield') || id.includes('swsh')) return 'SWSH';
if (name.includes('sun') || name.includes('moon') || id.includes('sm')) return 'SM';
if (name.includes('xy') || id.includes('xy')) return 'XY';
if (name.includes('black') || name.includes('white') || id.includes('bw')) return 'BW';
if (name.includes('diamond') || name.includes('pearl') || id.includes('dp')) return 'DP';
if (name.includes('heartgold') || name.includes('soulsilver') || id.includes('hgss')) return 'HGSS';
return 'PROMO'; // fallback
}
// Get set name from set info and clean it for promo cards
let cleanSetName = setInfo.name || '';
// Remove "Promos" from set name for promo cards to avoid redundancy
if (cleanSetName && cleanSetName.toLowerCase().includes('promos')) {
cleanSetName = cleanSetName.replace(/\s+Promos\s*$/i, '').trim();
}
// Get variant query from cached definitions
let variantQuery = '';
// Handle empty variant names as "Normal"
const lookupVariantName = vLabel || 'Normal';
const variant = variantDefs.find(v =>
v.name === lookupVariantName ||
v.name.toLowerCase() === lookupVariantName.toLowerCase()
);
if (variant && variant.query) {
variantQuery = variant.query;
}
// Build search terms (same order as Python scraper: card name, card number, set name, variant name, variant query)
const searchTerms = [];
searchTerms.push(cleanCardName);
if (cardNumberFormatted) searchTerms.push(cardNumberFormatted);
if (cleanSetName) searchTerms.push(cleanSetName);
if (vLabel && vLabel.toLowerCase() !== 'normal') searchTerms.push(vLabel);
if (variantQuery) searchTerms.push(variantQuery);
// Join and encode
const query = searchTerms.join(' ');
const encodedQuery = encodeURIComponent(query);
// Return eBay sold listings URL (UK only)
return `https://www.ebay.co.uk/sch/i.html?_nkw=${encodedQuery}&_sacat=0&LH_Sold=1&LH_Complete=1&_sop=13&LH_PrefLoc=1`;
}
function viewCards(shadow, stage, setId){
console.log('viewCards called with setId:', setId);
console.log('Available cached data:', {
totals: stage.__koriSetTotals,
logos: stage.__koriSetLogos,
symbols: stage.__koriSetSymbols,
codes: stage.__koriSetCodes
});
const totals = stage.__koriSetTotals||{}; const logos = stage.__koriSetLogos||{}; const symbols = stage.__koriSetSymbols||{}; const codes = stage.__koriSetCodes||{};
const total = totals[setId]||0; const padLen = String(total||0).length||3;
const logo = logos[setId]||''; const sym = symbols[setId]||''; const setCode = setId;
// Add filter and sort dropdowns above the cards grid (variant filter will be populated dynamically)
const filterSortDropdowns = `
Sort by:
Card ID
Highest Price
Lowest Price
`;
// Add back button to return to sets view (top left)
const backButton = `
← Back to Sets
`;
stage.innerHTML = `${logo?``:''}${backButton}${filterSortDropdowns}
`;
const grid = shadow.getElementById('cardsGrid');
const sortSelect = shadow.getElementById('sortSelect');
const variantFilter = shadow.getElementById('variantFilter');
const backToSetsBtn = shadow.getElementById('backToSets');
// Add back button event listener
backToSetsBtn?.addEventListener('click', (e) => {
e.preventDefault();
// Clear any loading state and go back to sets view
stage.innerHTML = '';
viewSets(shadow, stage);
});
// Store cards data for sorting
let allCards = [];
// Function to populate variant filter dropdown with only variants that exist in the cards
function populateVariantFilter(cards) {
const uniqueVariants = new Set();
cards.forEach(card => {
const variantLabel = getVariantLabel(card);
if (variantLabel) {
uniqueVariants.add(variantLabel);
}
});
// Clear existing options except "All Variants"
variantFilter.innerHTML = 'All Variants ';
// Add options for each unique variant found
Array.from(uniqueVariants).sort().forEach(variant => {
const option = document.createElement('option');
option.value = variant;
option.textContent = variant;
variantFilter.appendChild(option);
});
}
// Function to filter cards by variant
function filterCardsByVariant(cards, variantFilter) {
if (variantFilter === 'all') return cards;
return cards.filter(card => {
const variantLabel = getVariantLabel(card);
return variantLabel === variantFilter;
});
}
// Function to render cards with current filter and sort
function renderCards(cards, variantDefs, setInfo) {
if(!cards||!cards.length){
grid.innerHTML='No cards found
';
return;
}
// Apply variant filter
const filteredCards = filterCardsByVariant(cards, variantFilter.value);
if(!filteredCards.length){
grid.innerHTML='No cards found for selected variant
';
return;
}
grid.innerHTML = filteredCards.map(c=>{
const img = imgOf(c);
const vLabel = getVariantLabel(c);
const vKey = getVariantKey(c);
const imgTag = `
${img ? `
`
: `
`}
${OVERLAY_SETS.has(setCode.toUpperCase()) ? variantImageOverlayHTML(setCode, vKey) : ''}
${variantPillHTML(vLabel, vKey)}
${sym ? `
` : `
`}
${stripVariantFromName(c.name)||''}
${imgTag}
${meta}
${sku}
${priceDisplay}
`;
}).join('');
}
// Function to sort cards based on selected option
function sortCards(cards, sortBy) {
const sortedCards = [...cards];
switch(sortBy) {
case 'card_id':
return sortedCards.sort((a, b) => {
const aNum = parseInt(a.card_number) || 0;
const bNum = parseInt(b.card_number) || 0;
return aNum - bNum;
});
case 'price_high':
return sortedCards.sort((a, b) => {
const aPrice = getVariantPrice(a);
const bPrice = getVariantPrice(b);
return bPrice - aPrice;
});
case 'price_low':
return sortedCards.sort((a, b) => {
const aPrice = getVariantPrice(a);
const bPrice = getVariantPrice(b);
return aPrice - bPrice;
});
default:
return sortedCards;
}
}
// Helper function to get the price for this specific variant
function getVariantPrice(card) {
if (!card.prices || !Array.isArray(card.prices)) return 0;
const variantIndex = getVariantIndex(card, getVariantKey(card));
return variantIndex >= 0 && card.prices[variantIndex] > 0 ? card.prices[variantIndex] : 0;
}
// Load variant definitions and cards, then get set info from the cached data
console.log('Fetching cards for set:', setId);
Promise.all([
getVariantDefinitions(),
rest('sets/local/'+encodeURIComponent(setId)+'/cards')
]).then(async ([variantDefs, cards]) => {
console.log('Cards loaded successfully:', cards?.length || 0, 'cards');
// Get set info from the cached sets data, with fallback to fetch if not available
let setInfo = {
name: stage.__koriSetNames?.[setId] || '',
total: stage.__koriSetTotals?.[setId] || 0,
printed_total: stage.__koriSetTotals?.[setId] || 0
};
// If cached data is not available, fetch it
if (!setInfo.name || !setInfo.total) {
console.log('Set info not cached, fetching from API...');
try {
const allSets = await rest('sets/local/full');
const setData = allSets.find(s => s.set_id === setId);
if (setData) {
setInfo = {
name: setData.name || '',
total: setData.printed_total || setData.total || 0,
printed_total: setData.printed_total || setData.total || 0
};
// Update the logo and symbol from the fetched data
logo = setData.local_logo || setData.logo || '';
sym = setData.local_symbol || setData.symbol || '';
}
} catch (error) {
console.error('Failed to fetch set data:', error);
}
}
// Store all cards for sorting
allCards = cards || [];
// Populate variant filter with only variants that exist in this set
populateVariantFilter(allCards);
// Initial render with default filter and sort
renderCards(sortCards(allCards, 'card_id'), variantDefs, setInfo);
// Add event listeners for both dropdowns
sortSelect.addEventListener('change', (e) => {
const sortBy = e.target.value;
renderCards(sortCards(allCards, sortBy), variantDefs, setInfo);
});
variantFilter.addEventListener('change', (e) => {
const sortBy = sortSelect.value;
renderCards(sortCards(allCards, sortBy), variantDefs, setInfo);
});
}).catch(err => {
console.error('Error loading cards:', err);
console.error('Error details:', {
message: err.message,
stack: err.stack,
setId: setId
});
grid.innerHTML = `
Failed to load cards
Set ID: ${setId}
`;
});
}
// Build (and cache) a set_id -> symbol map for Search view
async function ensureSymbolsMap(shadow, stage){
if (stage.__koriSetSymbols && stage.__koriSetCodes) return stage.__koriSetSymbols;
try{
const sets = await rest('sets/local/full');
const map = {}; const codes = {};
sets.forEach(s=>{ if (s.set_id) { map[s.set_id] = (s.local_symbol||s.symbol||'') || ''; codes[s.set_id] = (s.code||'').toUpperCase(); } });
stage.__koriSetSymbols = map;
stage.__koriSetCodes = codes;
return map;
}catch(_){
stage.__koriSetSymbols = {};
stage.__koriSetCodes = {};
return {};
}
}
function viewSearch(shadow, stage){
setActive(shadow,'search');
// Add filter and sort dropdowns to search page (variant filter will be populated dynamically)
const searchFilterSortDropdowns = `
Sort by:
Card ID
Highest Price
Lowest Price
`;
stage.innerHTML = `SEARCH
${searchFilterSortDropdowns}
`;
const q = shadow.getElementById('q'); const go = shadow.getElementById('go'); const res = shadow.getElementById('results');
const searchSortSelect = shadow.getElementById('searchSortSelect');
const searchVariantFilter = shadow.getElementById('searchVariantFilter');
// Store search results for sorting
let searchResults = [];
// Function to populate search variant filter dropdown with only variants that exist in the search results
function populateSearchVariantFilter(cards) {
const uniqueVariants = new Set();
cards.forEach(card => {
const variantLabel = getVariantLabel(card);
if (variantLabel) {
uniqueVariants.add(variantLabel);
}
});
// Clear existing options except "All Variants"
searchVariantFilter.innerHTML = 'All Variants ';
// Add options for each unique variant found
Array.from(uniqueVariants).sort().forEach(variant => {
const option = document.createElement('option');
option.value = variant;
option.textContent = variant;
searchVariantFilter.appendChild(option);
});
}
// Function to filter search results by variant
function filterSearchResultsByVariant(cards, variantFilter) {
if (variantFilter === 'all') return cards;
return cards.filter(card => {
const variantLabel = getVariantLabel(card);
return variantLabel === variantFilter;
});
}
// Function to render search results with current filter and sort
function renderSearchResults(cards, variantDefs) {
if(!cards||!cards.length){
res.innerHTML='No results
';
return;
}
// Apply variant filter
const filteredCards = filterSearchResultsByVariant(cards, searchVariantFilter.value);
if(!filteredCards.length){
res.innerHTML='No results for selected variant
';
return;
}
res.innerHTML = filteredCards.map(c=>{
const img = imgOf(c);
const vLabel = getVariantLabel(c);
const vKey = getVariantKey(c);
const setCode = c.set_id;
const imgTag = `
${img ? `
`
: `
`}
${OVERLAY_SETS.has(setCode.toUpperCase()) ? variantImageOverlayHTML(setCode, vKey) : ''}
${variantPillHTML(vLabel, vKey)}
${sym ? `
` : `
`}
${stripVariantFromName(c.name)||''}
${imgTag}
${meta}
${sku}
${priceDisplay}
`;
}).join('');
}
// Function to sort search results based on selected option
function sortSearchResults(cards, sortBy) {
const sortedCards = [...cards];
switch(sortBy) {
case 'card_id':
return sortedCards.sort((a, b) => {
const aNum = parseInt(a.card_number) || 0;
const bNum = parseInt(b.card_number) || 0;
return aNum - bNum;
});
case 'price_high':
return sortedCards.sort((a, b) => {
const aPrice = getVariantPrice(a);
const bPrice = getVariantPrice(b);
return bPrice - aPrice;
});
case 'price_low':
return sortedCards.sort((a, b) => {
const aPrice = getVariantPrice(a);
const bPrice = getVariantPrice(b);
return aPrice - bPrice;
});
default:
return sortedCards;
}
}
// Helper function to get the price for this specific variant (reuse from sets view)
function getVariantPrice(card) {
if (!card.prices || !Array.isArray(card.prices)) return 0;
const variantIndex = getVariantIndex(card, getVariantKey(card));
return variantIndex >= 0 && card.prices[variantIndex] > 0 ? card.prices[variantIndex] : 0;
}
const run = async ()=>{
const s=(q.value||'').trim();
if (s.length<2){ res.innerHTML=''; return; }
res.innerHTML='Searching…
';
await ensureSymbolsMap(shadow, stage);
rest('cards/search-local?query='+encodeURIComponent(s)+'&expandVariants=1').then(async rows=>{
if(!rows||!rows.length){
res.innerHTML='No results
';
return;
}
// Get variant definitions for debug buttons
const variantDefs = await getVariantDefinitions();
// Store search results for sorting
searchResults = rows || [];
// Populate variant filter with only variants that exist in the search results
populateSearchVariantFilter(searchResults);
// Initial render with default filter and sort
renderSearchResults(sortSearchResults(searchResults, 'card_id'), variantDefs);
// Add event listeners for both dropdowns
searchSortSelect.addEventListener('change', (e) => {
const sortBy = e.target.value;
renderSearchResults(sortSearchResults(searchResults, sortBy), variantDefs);
});
searchVariantFilter.addEventListener('change', (e) => {
const sortBy = searchSortSelect.value;
renderSearchResults(sortSearchResults(searchResults, sortBy), variantDefs);
});
}).catch(()=>res.innerHTML='Search failed
');
};
go.addEventListener('click', run);
q.addEventListener('keypress', e=>{ if(e.key==='Enter') run(); });
}
function showToast(shadow, msg){
const t = document.createElement('div'); t.className='toast'; t.textContent = msg || '';
shadow.appendChild(t);
setTimeout(()=>{t.remove();}, 1800);
}
// ------- Modal (inside Shadow DOM) -------
function openModal(shadow, card_id, cardData){
const overlay = document.createElement('div');
overlay.className = 'overlay';
// Prepare data
const variantLabel = String(cardData?.variant || 'Normal');
const tablePrice = cardData?.table_price || (cardData?.prices ? Object.values(cardData.prices)[0] : 0);
// Check if light mode is active (inside shadow DOM)
const isLightMode = shadow.querySelector('.app')?.classList.contains('light-mode');
overlay.innerHTML = ``;
overlay.addEventListener('click', ev=>{ if(ev.target===overlay) overlay.remove(); });
shadow.appendChild(overlay);
// Check stock status and update UI
const checkStockStatus = async () => {
if (!cardData?.sku) {
return { inStock: false, currentStock: 0, currentPrice: 0 };
}
try {
const response = await ajax('koriv2_check_stock', { sku: cardData.sku });
// Handle nested response structure
const stockData = response.data?.data || response.data || {};
return {
inStock: response.success && stockData.stock > 0,
currentStock: stockData.stock || 0,
currentPrice: stockData.price || 0
};
} catch (error) {
return { inStock: false, currentStock: 0, currentPrice: 0 };
}
};
checkStockStatus().then(stockInfo => {
const stockInfoDiv = overlay.querySelector('#stockInfo');
const priceInput = overlay.querySelector('#mPrice');
const qtyInput = overlay.querySelector('#mQty');
if (stockInfo.inStock) {
stockInfoDiv.innerHTML = `
✓ Already in Stock
Current Stock: ${stockInfo.currentStock}
Current Price: £${stockInfo.currentPrice}
`;
priceInput.value = stockInfo.currentPrice;
qtyInput.value = stockInfo.currentStock;
qtyInput.setAttribute('data-original-stock', stockInfo.currentStock);
} else {
stockInfoDiv.innerHTML = `
⚠ Not in Stock
This will create a new product listing
`;
}
});
const $s = s=>overlay.querySelector(s);
$s('#mCancel').onclick = ()=>overlay.remove();
$s('#mDebug').onclick = async (e) => {
e.preventDefault();
try {
// Fetch complete card data for eBay URL generation using search endpoint
const response = await fetch(`${REST}cards/search-local?query=${encodeURIComponent(cardData.card_id)}&expandVariants=true`);
if (response.ok) {
const searchResults = await response.json();
if (searchResults && searchResults.length > 0) {
const fullCardData = searchResults[0]; // Get the first match
// Get set information from the sets endpoint
const setResponse = await fetch(`${REST}sets/local/full`);
const sets = setResponse.ok ? await setResponse.json() : [];
const setInfo = sets.find(s => s.set_id === fullCardData.set_id) || {};
// Get variant definitions (same as sets/search views)
const variantDefs = await getVariantDefinitions();
const ebayUrl = buildEbayUrl(fullCardData, variantDefs, {
name: setInfo.name || fullCardData.set_name,
total: setInfo.printed_total || setInfo.total || fullCardData.set_total
});
window.open(ebayUrl, '_blank');
} else {
// Fallback: try to build URL with available data
const ebayUrl = buildEbayUrl(cardData, [], { name: cardData?.set_name });
window.open(ebayUrl, '_blank');
}
} else {
// Fallback: try to build URL with available data
const ebayUrl = buildEbayUrl(cardData, [], { name: cardData?.set_name });
window.open(ebayUrl, '_blank');
}
} catch (error) {
console.error('Error fetching card data for debug:', error);
// Fallback: try to build URL with available data
const ebayUrl = buildEbayUrl(cardData, [], { name: cardData?.set_name });
window.open(ebayUrl, '_blank');
}
};
$s('#mSave').onclick = ()=>{
const qty = parseInt($s('#mQty').value||'0',10);
const price = ($s('#mPrice').value||'').trim();
const tablePrice = ($s('#mTablePrice').value||'').trim();
if(!qty || qty<1){ showToast(shadow,'Enter a valid quantity'); return; }
if(!price){ showToast(shadow,'Enter a valid price'); return; }
const saveData = {
card_id,
quantity: qty,
price,
variant: variantLabel,
table_price: tablePrice
};
ajax('koriv2_variant_upsert', saveData).then(()=>{
overlay.remove(); showToast(shadow,'Saved');
}).catch(()=>{ overlay.remove(); showToast(shadow,'Done'); });
};
}
// ------- Router -------
function route(shadow, stage){
const p = (location.pathname||'').toLowerCase();
if (p.includes('/koricollectiblesv2/sets')) return viewSets(shadow, stage);
if (p.includes('/koricollectiblesv2/pricecheck')) return viewPriceCheck(shadow, stage);
if (p.includes('/koricollectiblesv2/dashboard')) return viewDashboard(shadow, stage);
return viewSearch(shadow, stage);
}
// ------- Price Check View -------
function viewPriceCheck(shadow, stage){
setActive(shadow, 'pricecheck');
stage.innerHTML = `
Price Check
Refresh Price Check
Click "Refresh Price Check" to compare in-stock product prices with table prices
Showing cards with £1+ price differences
`;
}
function wireDelegates(shadow, stage){
shadow.addEventListener('click', ev=>{
const m = ev.target.closest('.manage');
if (m){
ev.preventDefault();
const cardData = m.getAttribute('data-card-data');
openModal(shadow, m.getAttribute('data-card-id')||'', cardData ? JSON.parse(cardData) : null);
}
const pill = ev.target.closest('.pill');
if (pill){ setActive(shadow, pill.dataset.nav); }
// Price Check button handler
if (ev.target.id === 'btnRefreshPriceCheck') {
ev.preventDefault();
handlePriceCheck(shadow);
}
});
}
async function handlePriceCheck(shadow) {
const resultsDiv = shadow.getElementById('priceCheckResults');
const loadingDiv = shadow.getElementById('priceCheckLoading');
if (!loadingDiv) {
return; // Not on price check page
}
loadingDiv.innerHTML = 'Checking prices...
';
try {
const response = await ajax('koriv2_price_check');
// Handle both array and object responses
let data = response.data;
if (response.data && response.data.data) {
data = response.data.data;
}
if (response.success && data && Array.isArray(data)) {
displayPriceCheckResults(shadow, data);
loadingDiv.style.display = 'none';
if (resultsDiv) resultsDiv.style.display = 'grid';
} else {
loadingDiv.innerHTML = 'No price differences found or error occurred
';
}
} catch (error) {
loadingDiv.innerHTML = 'Error checking prices
';
}
}
function displayPriceCheckResults(shadow, data) {
const container = shadow.getElementById('priceCheckResults');
if (!container) return;
if (!data.length) {
container.innerHTML = 'No products with significant price differences found
';
return;
}
// Sort by price difference (largest differences first)
data.sort((a, b) => {
const diffA = Math.abs(a.current_price - a.table_price);
const diffB = Math.abs(b.current_price - b.table_price);
return diffB - diffA; // Descending order (largest first)
});
container.innerHTML = data.map(item => {
const priceDiff = item.current_price - item.table_price;
const diffClass = priceDiff > 0 ? 'price-higher' : 'price-lower';
const diffIcon = priceDiff > 0 ? '↗' : '↘';
// Prepare card data for modal
const cardData = {
card_id: item.sku,
sku: item.sku, // Add SKU for modal display
name: item.product_name,
variant: item.variant_name || 'Normal',
current_price: item.current_price,
table_price: item.table_price, // Add table price for modal display
stock_quantity: item.stock_quantity
};
return `
${item.product_name}
${item.sku}${item.variant_name && item.variant_name !== 'Default' ? ` - ${item.variant_name}` : ''}
Current:
£${item.current_price}
Table:
£${item.table_price}
Diff:
${diffIcon} £${Math.abs(priceDiff).toFixed(2)}
Stock:
${item.stock_quantity}
`;
}).join('');
}
// ------- Dashboard (kept from your original) -------
function viewDashboard(shadow, stage){
setActive(shadow,'dashboard');
stage.innerHTML = `
Local-only actions (read from your DB):
REFRESH SETS (LOCAL)
REFRESH CARDS INDEX (LOCAL)
API updates (optional; requires API key in settings):
UPDATE SETS FROM API
UPDATE MISSING CARDS (ALL SETS)
Loading sets…
UPDATE MISSING CARDS (ONE SET)
Pricing Updates (eBay scraping):
UPDATE PRICING (ALL SETS)
KILL SCRIPT
TEST PYTHON
Loading sets…
UPDATE PRICING
Images Management
Convert API images to local images:
Convert Card Images to Local
Convert Set Images to Local
Convert Card Images for Set
Advanced: Tables
SAVE
`;
// Local counts
shadow.getElementById('btnLocalSets').addEventListener('click', e=>{
const b=e.currentTarget; const keep=b.textContent; b.disabled=true;
ajax('koriv2_sets_count').then(r=>showToast(shadow, r?.success?`Found ${r.data.count} sets`:'Error'))
.finally(()=>{b.disabled=false;b.textContent=keep;});
});
shadow.getElementById('btnLocalCards').addEventListener('click', e=>{
const b=e.currentTarget; const keep=b.textContent; b.disabled=true;
ajax('koriv2_cards_count').then(r=>showToast(shadow, r?.success?`Found ${r.data.count} cards`:'Error'))
.finally(()=>{b.disabled=false;b.textContent=keep;});
});
// Prefill tables from REST if available
(async ()=>{
try {
const r = await fetch((window.KORI_REST||'/wp-json/kori/v2/')+'config/tables', {credentials:'same-origin'});
if (r.ok){
const j = await r.json();
if (j && (j.sets_table||j.cards_table)){
const ts = shadow.getElementById('tblSets'); const tc = shadow.getElementById('tblCards');
if (j.sets_table) ts.value = j.sets_table;
if (j.cards_table) tc.value = j.cards_table;
}
}
} catch(_){}
const ts = shadow.getElementById('tblSets'); const tc = shadow.getElementById('tblCards');
if (!ts.value) ts.value = 'wp_koripokemon_sets';
if (!tc.value) tc.value = 'wp_koripokemon_cards';
})();
// Save tables
shadow.getElementById('btnSaveTables').addEventListener('click', async ()=>{
const ts = shadow.getElementById('tblSets').value.trim();
const tc = shadow.getElementById('tblCards').value.trim();
let ok=false;
try{
const r = await fetch((window.KORI_REST||'/wp-json/kori/v2/')+'config/tables', {
method:'POST', credentials:'same-origin',
headers:{'Content-Type':'application/json'},
body: JSON.stringify({sets_table: ts, cards_table: tc})
});
ok = r.ok;
}catch(_){}
if(!ok){
try{
const body = new URLSearchParams({action:'koriv2_save_tables', sets_table: ts, cards_table: tc}).toString();
const r2 = await fetch(window.KORI_AJAX || '/wp-admin/admin-ajax.php', {method:'POST', credentials:'same-origin', headers:{'Content-Type':'application/x-www-form-urlencoded'}, body});
const j2 = await r2.json(); ok = !!(j2 && (j2.success||j2.ok));
}catch(_){}
}
showToast(shadow, ok?'Saved':'Could not save — please check permissions');
});
// ====== Image Conversion Event Handlers ======
shadow.getElementById('btnConvertCardImages')?.addEventListener('click', async ()=>{
const btn = shadow.getElementById('btnConvertCardImages');
const progress = shadow.getElementById('imageProgress');
const keep = btn.textContent;
btn.disabled = true;
progress.textContent = 'Starting card image conversion for all sets...';
try {
// Get all sets first
const setsResponse = await fetch((window.KORI_REST||'/wp-json/kori/v2/')+'sets/local/full', {
credentials: 'same-origin'
});
if (!setsResponse.ok) {
throw new Error('Failed to fetch sets');
}
const sets = await setsResponse.json();
let totalConverted = 0;
let totalSkipped = 0;
let totalErrors = 0;
// Process each set one at a time
for (let i = 0; i < sets.length; i++) {
const set = sets[i];
progress.textContent = `Processing set ${i + 1}/${sets.length}: ${set.name} (${set.set_id})...`;
const response = await fetch((window.KORI_REST||'/wp-json/kori/v2/')+'images/convert-cards', {
method: 'POST',
credentials: 'same-origin',
headers: {'Content-Type': 'application/json'},
body: JSON.stringify({set_id: set.set_id})
});
if (response.ok) {
const result = await response.json();
totalConverted += result.converted || 0;
totalSkipped += result.skipped || 0;
totalErrors += result.errors || 0;
} else {
totalErrors++;
}
}
progress.textContent = `Card image conversion complete! Converted: ${totalConverted}, Skipped: ${totalSkipped}, Errors: ${totalErrors}`;
showToast(shadow, `Card images converted! Converted: ${totalConverted}, Skipped: ${totalSkipped}, Errors: ${totalErrors}`);
} catch (error) {
progress.textContent = 'Error: ' + error.message;
showToast(shadow, 'Error converting card images');
} finally {
btn.disabled = false;
btn.textContent = keep;
}
});
shadow.getElementById('btnConvertSetImages')?.addEventListener('click', async ()=>{
const btn = shadow.getElementById('btnConvertSetImages');
const progress = shadow.getElementById('imageProgress');
const keep = btn.textContent;
btn.disabled = true;
progress.textContent = 'Starting set image conversion...';
try {
const response = await fetch((window.KORI_REST||'/wp-json/kori/v2/')+'images/convert-sets', {
method: 'POST',
credentials: 'same-origin',
headers: {'Content-Type': 'application/json'}
});
if (response.ok) {
const result = await response.json();
progress.textContent = result.message || 'Set images converted successfully!';
showToast(shadow, 'Set images converted successfully!');
} else {
progress.textContent = 'Error converting set images';
showToast(shadow, 'Error converting set images');
}
} catch (error) {
progress.textContent = 'Error: ' + error.message;
showToast(shadow, 'Error converting set images');
} finally {
btn.disabled = false;
btn.textContent = keep;
}
});
shadow.getElementById('btnConvertCardImagesForSet')?.addEventListener('click', async ()=>{
const btn = shadow.getElementById('btnConvertCardImagesForSet');
const progress = shadow.getElementById('imageProgress');
const setIdInput = shadow.getElementById('imageSetId');
const setId = setIdInput.value.trim();
const keep = btn.textContent;
if (!setId) {
showToast(shadow, 'Please enter a set ID');
return;
}
btn.disabled = true;
progress.textContent = `Starting card image conversion for set: ${setId}...`;
try {
const response = await fetch((window.KORI_REST||'/wp-json/kori/v2/')+'images/convert-cards', {
method: 'POST',
credentials: 'same-origin',
headers: {'Content-Type': 'application/json'},
body: JSON.stringify({set_id: setId})
});
if (response.ok) {
const result = await response.json();
progress.textContent = result.message || `Card images converted for set: ${setId}`;
showToast(shadow, `Card images converted for set: ${setId}`);
} else {
progress.textContent = 'Error converting card images for set';
showToast(shadow, 'Error converting card images for set');
}
} catch (error) {
progress.textContent = 'Error: ' + error.message;
showToast(shadow, 'Error converting card images for set');
} finally {
btn.disabled = false;
btn.textContent = keep;
}
});
// ====== API: Update Sets from external API (with progress) ======
(function(){
const btn = shadow.getElementById('btnApiSets');
const status = shadow.getElementById('apiStatus');
btn?.addEventListener('click', async ()=>{
if (!btn) return;
const keep = btn.textContent;
btn.disabled = true;
let dots = 0;
const tick = setInterval(()=>{ dots=(dots+1)%4; btn.textContent = 'Updating…' + '.'.repeat(dots); }, 300);
status.textContent = 'Starting…';
const REST_BASE = (window.KORI_REST||'/wp-json/kori/v2/');
const AJAX_URL = (window.KORI_AJAX || window.ajaxurl || '/wp-admin/admin-ajax.php');
let ok=false, msg='Sets updated';
// Try REST first
try {
const r = await fetch(REST_BASE+'sets/update-from-api', {method:'POST', credentials:'same-origin'});
if (r.ok){
const j = await r.json();
ok = true;
if (j && typeof j === 'object'){
msg = j.message || j.summary || (`Updated ${j.updated||j.count||0} sets`);
}
}
} catch(_){}
// Fallback to admin-ajax
if (!ok){
try{
const body = new URLSearchParams({action:'koriv2_update_sets_api'}).toString();
const r2 = await fetch(AJAX_URL, {method:'POST', credentials:'same-origin', headers:{'Content-Type':'application/x-www-form-urlencoded'}, body});
const j2 = await r2.json();
ok = !!(j2 && (j2.success||j2.ok));
if (ok){
const d = j2.data||{};
msg = d.message || d.summary || (`Updated ${d.updated||d.count||0} sets`);
}
}catch(_){}
}
clearInterval(tick);
btn.textContent = keep;
btn.disabled = false;
status.textContent = ok ? msg : 'Update failed — check server/API key.';
showToast(shadow, ok? msg : 'Update failed');
});
})();
// ====== API: Update MISSING cards (ALL sets) with local vs API comparison + report ======
(function(){
const btn = shadow.getElementById('btnApiCardsAll');
const status = shadow.getElementById('cardsStatus');
if (!btn || !status) return;
async function safeFetch(url, opts={}, timeoutMs=180000){
const ctl = new AbortController();
const t = setTimeout(()=>ctl.abort(), timeoutMs);
try{ return await fetch(url, {...opts, signal: ctl.signal}); }
finally{ clearTimeout(t); }
}
async function fetchRemoteSets(){
const headers = {'Accept':'application/json'};
const key = (window.KORI_V2 && (KORI_V2.apiKey || KORI_V2.tcgApiKey || KORI_V2.PTCG_API_KEY)) || '';
if (key) headers['X-Api-Key'] = key;
const map = {};
let page=1, pageSize=250, more=true, totalCount=null;
while (more){
const r = await safeFetch(`https://api.pokemontcg.io/v2/sets?page=${page}&pageSize=${pageSize}`, {headers});
if (!r.ok) throw new Error('Remote sets fetch failed');
const j = await r.json();
const list = j?.data || j?.sets || [];
list.forEach(s=>{
if (!s || !s.id) return;
map[String(s.id).toLowerCase()] = Number(s.total || s.totalCards || s.printedTotal || 0) || 0;
});
totalCount = Number(j?.totalCount ?? j?.total ?? page*pageSize);
page++; more = (page-1)*pageSize < totalCount;
}
return map;
}
async function localCount(setId){
const rows = await rest('sets/local/'+encodeURIComponent(setId)+'/cards?expandVariants=1');
return Array.isArray(rows) ? rows.length : 0;
}
// NEW: use our real server endpoint (+ ajax fallback)
async function updateOneSet(setId){
const REST_BASE = (window.KORI_REST||'/wp-json/kori/v2/');
const AJAX_URL = (window.KORI_AJAX || window.ajaxurl || '/wp-admin/admin-ajax.php');
// Try REST route first
try{
const r = await safeFetch(REST_BASE+'cards/update-missing-for-set', {
method:'POST',
credentials:'same-origin',
headers:{'Content-Type':'application/json'},
body: JSON.stringify({ set_id:setId })
}, 180000);
if (r.ok){ return await r.json(); }
}catch(_){}
// Fallback to admin-ajax
try{
const body = new URLSearchParams({action:'koriv2_fill_missing_cards_set', set_id:setId}).toString();
const r = await safeFetch(AJAX_URL, {
method:'POST',
credentials:'same-origin',
headers:{'Content-Type':'application/x-www-form-urlencoded'},
body
}, 180000);
const j = await r.json();
if (j && (j.success || j.ok)) return j.data || j;
}catch(_){}
return {added:0};
}
btn.addEventListener('click', async ()=>{
const keep = btn.textContent;
btn.disabled = true;
let dots=0;
const tick = setInterval(()=>{ dots=(dots+1)%4; btn.textContent = 'Scanning…' + '.'.repeat(dots); }, 300);
try{
status.textContent = 'Loading local sets…';
const sets = await rest('sets/local/full');
const ids = (Array.isArray(sets)?sets:[]).map(s=>s.set_id).filter(Boolean);
const meta = {};
(sets||[]).forEach(s=>{ meta[(s.set_id||'').toLowerCase()] = {name:s.name||'', code:s.code||''}; });
// Local counts
const local = {};
for (let i=0;i0 && lc (b.missing-a.missing));
if (!workList.length){
status.textContent = 'All sets look complete locally. Nothing to do.';
localStorage.setItem('kori_last_missing_sets', JSON.stringify([]));
return;
}
// Import per set
let totalAdded = 0;
const report = [];
for (let i=0;i`${r.id} ${r.name?` — ${r.name}`:''} (${r.local} → ${r.api}, +${r.added})${totalAdded} cards in total.
Details:
${details || 'No changes '} `;
showToast(shadow, `Added ${totalAdded} new cards across ${workList.length} set(s).`);
} catch(err){
console.error(err);
status.textContent = 'Update failed — see console.';
showToast(shadow, 'Update failed');
} finally {
clearInterval(tick);
btn.disabled = false;
btn.textContent = keep;
}
});
})();
/* ===== Single-set dropdown: populate options ===== */
(function(){
const ddl = document.querySelector('#kori-v2-root')?.shadowRoot?.getElementById('ddlOneSet');
if (!ddl) return;
(async ()=>{
try{
const sets = await rest('sets/local/full');
const opts = ['Choose a set… ']
.concat((sets||[]).map(s=>{
const id = s.set_id || '';
const code = s.code ? ` (${s.code})` : '';
const name = s.name || '';
return `${id}${code} — ${name} `;
}));
ddl.innerHTML = opts.join('');
const last = localStorage.getItem('kori_one_set_choice') || '';
if (last && ddl.querySelector(`option[value="${last}"]`)) ddl.value = last;
}catch(_){
ddl.innerHTML = 'Failed to load sets ';
}
})();
})();
/* ===== Single-set updater: call server endpoint with progress ===== */
(function(){
const root = document.querySelector('#kori-v2-root');
const shadow = root ? root.shadowRoot : null;
if (!shadow) return;
const btn = shadow.getElementById('btnApiCardsOneSet');
const ddl = shadow.getElementById('ddlOneSet');
const status = shadow.getElementById('oneSetStatus');
if (!btn || !ddl || !status) return;
async function safeFetch(url, opts={}, timeoutMs=180000){
const ctl = new AbortController();
const t = setTimeout(()=>ctl.abort(), timeoutMs);
try { return await fetch(url, {...opts, signal: ctl.signal}); }
finally { clearTimeout(t); }
}
async function updateOneSet(setId){
const REST_BASE = (window.KORI_REST||'/wp-json/kori/v2/');
const AJAX_URL = (window.KORI_AJAX || window.ajaxurl || '/wp-admin/admin-ajax.php');
try{
const r = await safeFetch(REST_BASE+'cards/update-missing-for-set', {
method:'POST',
credentials:'same-origin',
headers:{'Content-Type':'application/json'},
body: JSON.stringify({ set_id:setId })
}, 180000);
if (r.ok) return await r.json();
}catch(_){}
try{
const body = new URLSearchParams({action:'koriv2_fill_missing_cards_set', set_id:setId}).toString();
const r = await safeFetch(AJAX_URL, {
method:'POST',
credentials:'same-origin',
headers:{'Content-Type':'application/x-www-form-urlencoded'},
body
}, 180000);
const j = await r.json();
// eslint-disable-next-line no-unsafe-optional-chaining
if (j && (j.success || j.ok)) return j.data || j;
}catch(_){}
return {added:0};
}
btn.addEventListener('click', async ()=>{
const setId = ddl.value.trim();
if (!setId){ status.textContent = 'Please choose a set first.'; ddl.focus(); return; }
localStorage.setItem('kori_one_set_choice', setId);
const keep = btn.textContent;
btn.disabled = true;
let dots=0;
const tick = setInterval(()=>{ dots=(dots+1)%4; btn.textContent = 'Updating…' + '.'.repeat(dots); }, 300);
status.textContent = `Fetching missing cards for ${setId}…`;
try{
const res = await updateOneSet(setId);
const added = Number(res?.added || res?.new || res?.inserted || 0) || 0;
const scanned = Number(res?.scanned || 0);
const total = Number(res?.total || 0);
status.textContent = `Done ${setId}: +${added} (scanned ${scanned}${total?` / ${total}`:''}).`;
showToast(shadow, `Set ${setId}: added ${added} card(s).`);
}catch(err){
console.error(err);
status.textContent = `Failed to update ${setId}. See console.`;
showToast(shadow, 'Update failed');
}finally{
clearInterval(tick);
btn.disabled = false;
btn.textContent = keep;
}
});
})();
/* ===== Variants (server-backed, AJAX save) ===== */
(function(){
const root = document.querySelector('#kori-v2-root');
const shadow = root ? root.shadowRoot : null;
if (!shadow) return;
const stage = shadow.getElementById('stage');
if (!stage) return;
const wrap = document.createElement('div');
wrap.innerHTML = `
Variants
Variant
Suffix
eBay query
Add row
Save
Saved to WordPress via admin-ajax; loaded via REST (no cache).
`;
stage.appendChild(wrap);
const VAR_LS_KEY = 'kori_variant_defs_v1';
const REST_BASE = (window.KORI_REST||'/wp-json/kori/v2/');
const AJAX_URL = (window.KORI_AJAX || window.ajaxurl || '/wp-admin/admin-ajax.php');
const loadLocal = () => { try { return JSON.parse(localStorage.getItem(VAR_LS_KEY) || '[]'); } catch(e){ return []; } };
const saveLocal = defs => localStorage.setItem(VAR_LS_KEY, JSON.stringify(defs));
async function getDefs(){
try {
const r = await fetch(REST_BASE+'variants/defs?cb='+Date.now(), {credentials:'same-origin'});
if (!r.ok) throw 0;
return await r.json();
} catch(_) {
return loadLocal();
}
}
async function postDefs(defs){
const body = new URLSearchParams({action:'koriv2_save_variant_defs', defs: JSON.stringify(defs)}).toString();
const r2 = await fetch(AJAX_URL, {
method:'POST', credentials:'same-origin',
headers:{'Content-Type':'application/x-www-form-urlencoded'},
body
});
const j2 = await r2.json();
if (j2 && (j2.success || j2.ok)) return {ok:true, saved:(j2.data && j2.data.saved) ? j2.data.saved : defs};
throw new Error('AJAX save failed');
}
function renderRows(defs){
const rowsEl = shadow.getElementById('varRows');
rowsEl.innerHTML = '';
defs.forEach((d, idx) => {
const row = document.createElement('div');
row.className = 'grid';
row.style.gridTemplateColumns = '1fr 160px 2fr 80px';
row.style.gap = '8px';
row.style.alignItems = 'center';
row.dataset.index = idx;
row.innerHTML = `
Delete
`;
rowsEl.appendChild(row);
});
}
let defs = [];
(async ()=>{
defs = await getDefs();
if (!Array.isArray(defs)) defs = [];
defs = defs.map(d => ({
name:(d.name||'').trim(),
suffix:(d.suffix||'').trim().toUpperCase(),
query:(d.query||'').trim()
}));
renderRows(defs);
try{ window.KORI_VARIANT_DEFS = defs.slice(); }catch(_){}
})();
shadow.getElementById('btnAddVar')?.addEventListener('click', () => {
defs.push({ name:'', suffix:'', query:'' });
renderRows(defs);
});
shadow.getElementById('variantsPanel')?.addEventListener('click', (e) => {
const btn = e.target.closest('[data-act=del]');
if (!btn) return;
const row = btn.closest('[data-index]');
const idx = parseInt(row?.dataset.index || '-1', 10);
if (idx >= 0) {
defs.splice(idx, 1);
renderRows(defs);
}
});
shadow.getElementById('variantsPanel')?.addEventListener('input', (e) => {
const row = e.target.closest('[data-index]');
if (!row) return;
const idx = parseInt(row.dataset.index || '-1', 10);
if (idx < 0) return;
const k = e.target.dataset.k;
if (!k) return;
defs[idx][k] = (e.target.value || '').trim();
if (k === 'suffix') defs[idx][k] = defs[idx][k].toUpperCase();
});
shadow.getElementById('btnSaveVars')?.addEventListener('click', async () => {
const cleaned = defs
.map(d => ({ name:d.name.trim(), suffix:d.suffix.trim().toUpperCase(), query:d.query.trim() }))
.filter(d => d.name);
try {
const res = await postDefs(cleaned);
if (res?.ok) {
saveLocal(res.saved || cleaned);
try{ window.KORI_VARIANT_DEFS = (res.saved || cleaned).slice(); }catch(_){}
showToast(shadow, 'Saved');
} else {
throw 0;
}
} catch(_){
showToast(shadow, 'Save failed — are you logged in as admin?');
}
});
})();
// ====== Pricing Updates: eBay scraping with progress ======
(function(){
const btnAll = shadow.getElementById('btnUpdateAllPrices');
const btnSelected = shadow.getElementById('btnUpdateSelectedSetPrices');
const btnKill = shadow.getElementById('btnKillScript');
const btnTest = shadow.getElementById('btnTestScript');
const ddlPriceSet = shadow.getElementById('ddlPriceSet');
const status = shadow.getElementById('pricingStatus');
const progress = shadow.getElementById('pricingProgress');
const output = shadow.getElementById('pricingOutput');
if (!btnAll || !btnSelected || !btnKill || !btnTest || !ddlPriceSet || !status || !progress) return;
// Populate pricing set dropdown
(async ()=>{
try{
const sets = await rest('sets/local/full');
const opts = ['Choose a set for pricing… ']
.concat((sets||[]).map(s=>{
const id = s.set_id || '';
const code = s.code ? ` (${s.code})` : '';
const name = s.name || '';
return `${id}${code} — ${name} `;
}));
ddlPriceSet.innerHTML = opts.join('');
}catch(_){
ddlPriceSet.innerHTML = 'Failed to load sets ';
}
})();
async function updatePricingForSet(setId, isAllSets = false) {
const REST_BASE = (window.KORI_REST||'/wp-json/kori/v2/');
const AJAX_URL = (window.KORI_AJAX || window.ajaxurl || '/wp-admin/admin-ajax.php');
try {
// Try REST endpoint first
const r = await fetch(REST_BASE + 'pricing/update-ebay', {
method: 'POST',
credentials: 'same-origin',
headers: {'Content-Type': 'application/json'},
body: JSON.stringify({
set_id: setId,
all_sets: isAllSets,
progress_callback: true
})
});
if (r.ok) {
const result = await r.json();
return result;
}
} catch(_) {}
// Fallback to admin-ajax
try {
const body = new URLSearchParams({
action: 'koriv2_update_ebay_pricing',
set_id: setId,
all_sets: isAllSets ? '1' : '0'
}).toString();
const r = await fetch(AJAX_URL, {
method: 'POST',
credentials: 'same-origin',
headers: {'Content-Type': 'application/x-www-form-urlencoded'},
body
});
const j = await r.json();
if (j && (j.success || j.ok)) return j.data || j;
} catch(_) {}
return {success: false, message: 'Failed to update pricing'};
}
function showProgress(message) {
progress.style.display = 'block';
progress.textContent = message;
}
function hideProgress() {
progress.style.display = 'none';
}
function showOutput() {
output.style.display = 'block';
output.textContent = '';
}
function hideOutput() {
output.style.display = 'none';
}
function appendOutput(text) {
output.textContent += text + '\n';
output.scrollTop = output.scrollHeight;
}
function updateCurrentCard(cardInfo) {
// Clear the output and show only the current card being processed
output.textContent = cardInfo;
output.scrollTop = output.scrollHeight;
}
async function runPythonScript(setId, allSets) {
const REST_BASE = (window.KORI_REST||'/wp-json/kori/v2/');
appendOutput('🚀 Starting Python script execution...');
appendOutput(`Set ID: ${setId}`);
appendOutput(`All sets: ${allSets}`);
appendOutput('');
try {
// Start the script
const response = await fetch(REST_BASE + 'pricing/update', {
method: 'POST',
credentials: 'same-origin',
headers: {'Content-Type': 'application/json'},
body: JSON.stringify({
set_id: setId,
all_sets: allSets
})
});
if (response.ok) {
const result = await response.json();
if (result.success) {
if (result.is_running) {
// Script is already running, show current progress
appendOutput('⚠️ Script is already running!');
appendOutput('Showing current progress...');
appendOutput('');
// Show any existing output
if (result.output) {
appendOutput('Current output:');
appendOutput(result.output);
appendOutput('');
}
// Start monitoring the existing script
await monitorScriptProgress();
return { success: true, message: 'Monitoring existing script' };
} else {
// New script started
appendOutput('✅ Script started in background!');
appendOutput('');
appendOutput('Command executed:');
appendOutput(result.command);
appendOutput('');
appendOutput('Monitoring progress...');
appendOutput('');
// Start monitoring the log file
await monitorScriptProgress();
return { success: true, message: 'Script completed' };
}
} else {
appendOutput(`❌ ${result.message}`);
return { success: false, message: result.message };
}
} else {
appendOutput(`❌ Error: ${response.status} ${response.statusText}`);
return { success: false, message: 'Script failed' };
}
} catch(error) {
appendOutput(`❌ Network error: ${error.message}`);
return { success: false, message: 'Network error' };
}
}
async function monitorScriptProgress() {
const REST_BASE = (window.KORI_REST||'/wp-json/kori/v2/');
let lastOutputLength = 0;
let isRunning = true;
let currentCardInfo = '';
let currentVariants = [];
let currentVariantCount = 0;
while (isRunning) {
try {
const response = await fetch(REST_BASE + 'pricing/progress', {
method: 'GET',
credentials: 'same-origin'
});
if (response.ok) {
const result = await response.json();
if (result.success && result.output) {
// Only process new content
const currentOutput = result.output;
if (currentOutput.length > lastOutputLength) {
const newContent = currentOutput.substring(lastOutputLength);
// Parse for card progress updates
const lines = newContent.split('\n');
for (const line of lines) {
if (line.trim()) {
// Check if this is a card processing line
const cardMatch = line.match(/\[(\d+)\/(\d+)\] Processing card: (.+)/);
if (cardMatch) {
const [, current, total, cardId] = cardMatch;
currentCardInfo = `[${current}/${total}] Processing card: ${cardId}`;
currentVariants = [];
currentVariantCount = 0;
updateCurrentCardDisplay();
continue;
}
// Check if this is a variants line
const variantsMatch = line.match(/Variants: (\d+)/);
if (variantsMatch) {
currentVariantCount = parseInt(variantsMatch[1]);
updateCurrentCardDisplay();
continue;
}
// Check if this is a variant processing line
const variantMatch = line.match(/\[(\d+)\/(\d+)\] Variant: (.+)/);
if (variantMatch) {
const [, vCurrent, vTotal, variantName] = variantMatch;
const variantIndex = parseInt(vCurrent) - 1;
// Initialize variants array if needed
if (currentVariants.length < vTotal) {
currentVariants = new Array(parseInt(vTotal)).fill(null);
}
currentVariants[variantIndex] = {
name: variantName,
cardName: '',
price: ''
};
updateCurrentCardDisplay();
continue;
}
// Check if this is a card name line
const cardNameMatch = line.match(/Card: (.+)/);
if (cardNameMatch) {
const cardName = cardNameMatch[1];
// Add to the most recent variant
if (currentVariants.length > 0) {
const lastVariantIndex = currentVariants.findLastIndex(v => v !== null);
if (lastVariantIndex >= 0) {
currentVariants[lastVariantIndex].cardName = cardName;
}
}
updateCurrentCardDisplay();
continue;
}
// Check for price information
const priceMatch = line.match(/Average price: £([\d.]+)/);
if (priceMatch) {
const price = priceMatch[1];
// Add to the most recent variant
if (currentVariants.length > 0) {
const lastVariantIndex = currentVariants.findLastIndex(v => v !== null);
if (lastVariantIndex >= 0) {
currentVariants[lastVariantIndex].price = price;
}
}
updateCurrentCardDisplay();
continue;
}
}
}
lastOutputLength = currentOutput.length;
}
// Check if script is still running
if (!result.is_running) {
updateCurrentCard('✅ Script completed successfully!');
isRunning = false;
}
} else {
updateCurrentCard('⏳ Waiting for script to start...');
}
} else {
updateCurrentCard('❌ Error checking progress');
isRunning = false;
}
} catch(error) {
updateCurrentCard(`❌ Error monitoring progress: ${error.message}`);
isRunning = false;
}
// Wait 1 second before checking again for more responsive updates
if (isRunning) {
await new Promise(resolve => setTimeout(resolve, 1000));
}
}
function updateCurrentCardDisplay() {
let displayText = '';
if (currentCardInfo) displayText += currentCardInfo;
if (currentVariantCount > 0) displayText += ` | Variants: ${currentVariantCount}`;
displayText += '\n';
// Show all variants for the current card
currentVariants.forEach((variant, index) => {
if (variant) {
displayText += `[${index + 1}/${currentVariantCount}] ${variant.name}`;
if (variant.cardName) {
displayText += ` | ${variant.cardName}`;
}
if (variant.price) {
displayText += ` | £${variant.price}`;
}
displayText += '\n';
}
});
updateCurrentCard(displayText);
}
}
// Global state for continuous pricing updates
let isContinuousMode = false;
let continuousInterval = null;
let currentCycle = 0;
let progressInterval = null;
// Check if continuous pricing is already running on page load
async function checkContinuousStatus() {
try {
const response = await fetch((window.KORI_REST||'/wp-json/kori/v2/') + 'pricing/status', {
method: 'GET',
credentials: 'same-origin'
});
if (response.ok) {
const result = await response.json();
console.log('Initial status check - Status data:', result);
if (result.is_running && result.is_continuous) {
// Continuous mode is running on server
isContinuousMode = true;
btnAll.textContent = 'Stop Continuous Update';
btnAll.style.background = '#dc2626';
currentCycle = result.current_cycle || 1;
// Add progress information if available
let progressText = '';
if (result.progress_text && result.total_cards > 0) {
progressText = ` - ${result.progress_text}`;
}
console.log('Initial progress text:', progressText);
status.textContent = `Continuous pricing update is running (Cycle ${currentCycle})${progressText}`;
appendOutput('');
appendOutput(`🔄 Continuous pricing update is already running on server (Cycle ${currentCycle})${progressText}`);
// Start progress updates every 5 seconds
if (progressInterval) clearInterval(progressInterval);
progressInterval = setInterval(updateProgressDisplay, 5000);
}
}
} catch (error) {
console.log('Could not check pricing status:', error);
}
}
// Function to update progress display
async function updateProgressDisplay() {
if (!isContinuousMode) return;
try {
const response = await fetch((window.KORI_REST||'/wp-json/kori/v2/') + 'pricing/status', {
method: 'GET',
credentials: 'same-origin'
});
if (response.ok) {
const result = await response.json();
console.log('Progress update - Status data:', result);
if (result.is_running && result.is_continuous) {
let progressText = '';
if (result.progress_text && result.total_cards > 0) {
progressText = ` - ${result.progress_text}`;
}
console.log('Progress text:', progressText);
status.textContent = `Continuous pricing update is running (Cycle ${result.current_cycle || 1})${progressText}`;
} else {
// Continuous mode stopped
isContinuousMode = false;
status.textContent = '';
if (progressInterval) {
clearInterval(progressInterval);
progressInterval = null;
}
}
}
} catch (error) {
console.log('Could not update progress:', error);
}
}
// Test Python script functionality
async function testPythonScript() {
try {
const response = await fetch((window.KORI_REST||'/wp-json/kori/v2/') + 'pricing/test-script', {
method: 'GET',
credentials: 'same-origin'
});
if (response.ok) {
const result = await response.json();
console.log('Python script test result:', result);
appendOutput('');
appendOutput('🔍 Python Script Test Results:');
appendOutput(`Script exists: ${result.script_exists}`);
appendOutput(`Script path: ${result.script_path}`);
appendOutput(`WordPress URL: ${result.wp_url}`);
appendOutput(`Python version: ${result.python_version}`);
appendOutput(`Python return code: ${result.python_return_code}`);
}
} catch (error) {
console.log('Could not test Python script:', error);
appendOutput('');
appendOutput('❌ Could not test Python script: ' + error.message);
}
}
// Check status on page load
checkContinuousStatus();
// Update all sets pricing with toggle functionality
btnAll.addEventListener('click', async () => {
if (isContinuousMode) {
// Stop continuous mode via server
try {
const response = await fetch((window.KORI_REST||'/wp-json/kori/v2/') + 'pricing/stop-continuous', {
method: 'POST',
credentials: 'same-origin',
headers: {'Content-Type': 'application/json'}
});
if (response.ok) {
const result = await response.json();
if (result.success) {
isContinuousMode = false;
btnAll.textContent = 'Update Pricing (All Sets)';
btnAll.style.background = '#155e75';
status.textContent = 'Continuous pricing update stopped';
showToast(shadow, 'Continuous pricing update stopped');
appendOutput('');
appendOutput('🛑 Continuous pricing update stopped');
// Clear progress interval
if (progressInterval) {
clearInterval(progressInterval);
progressInterval = null;
}
} else {
showToast(shadow, 'Failed to stop continuous update');
appendOutput('');
appendOutput('❌ Failed to stop continuous update: ' + result.message);
}
}
} catch (error) {
showToast(shadow, 'Error stopping continuous update');
appendOutput('');
appendOutput('❌ Error stopping continuous update: ' + error.message);
}
return;
}
// Start continuous mode via server
try {
const response = await fetch((window.KORI_REST||'/wp-json/kori/v2/') + 'pricing/start-continuous', {
method: 'POST',
credentials: 'same-origin',
headers: {'Content-Type': 'application/json'}
});
if (response.ok) {
const result = await response.json();
if (result.success) {
isContinuousMode = true;
btnAll.textContent = 'Stop Continuous Update';
btnAll.style.background = '#dc2626';
status.textContent = 'Continuous pricing update started on server';
showToast(shadow, 'Continuous pricing update started');
appendOutput('');
appendOutput('🔄 Continuous pricing update started on server');
appendOutput('The script will run in the background and restart automatically');
// Start progress updates every 5 seconds
if (progressInterval) clearInterval(progressInterval);
progressInterval = setInterval(updateProgressDisplay, 5000);
} else {
showToast(shadow, 'Failed to start continuous update');
appendOutput('');
appendOutput('❌ Failed to start continuous update: ' + result.message);
}
}
} catch (error) {
showToast(shadow, 'Error starting continuous update');
appendOutput('');
appendOutput('❌ Error starting continuous update: ' + error.message);
}
});
// Update selected set pricing
btnSelected.addEventListener('click', async () => {
const setId = ddlPriceSet.value;
if (!setId) {
showToast(shadow, 'Please select a set first');
return;
}
const keep = btnSelected.textContent;
btnSelected.disabled = true;
status.textContent = `Starting pricing update for set: ${setId}`;
showOutput();
appendOutput(`Starting eBay pricing update for set: ${setId}`);
appendOutput('');
try {
// Get set info for progress display
const sets = await rest('sets/local/full');
const setInfo = sets.find(s => s.set_id === setId);
const setName = setInfo ? setInfo.name : setId;
const totalCards = setInfo ? (setInfo.total || setInfo.printed_total || 0) : 0;
appendOutput(`Set: ${setName} (${setId})`);
appendOutput(`Total cards: ${totalCards}`);
appendOutput('');
// Run Python script for this specific set
const result = await runPythonScript(setId, false);
if (result.success) {
const updatedCards = result.updated_cards || result.data?.updated_cards || 0;
status.textContent = `Pricing update completed for ${setName}! Updated ${updatedCards} cards.`;
showToast(shadow, `Pricing update completed for ${setName}!`);
appendOutput('');
appendOutput('✅ Pricing update completed successfully!');
appendOutput(`Updated ${updatedCards} cards in ${setName}.`);
} else {
status.textContent = `Pricing update failed for ${setName}: ${result.message || 'Unknown error'}`;
showToast(shadow, 'Pricing update failed');
appendOutput('');
appendOutput('❌ Pricing update failed: ' + (result.message || 'Unknown error'));
}
} catch (err) {
console.error('❌ Single set pricing update error:', err);
status.textContent = 'Pricing update failed — see console.';
showToast(shadow, 'Pricing update failed');
appendOutput('');
appendOutput('❌ Pricing update failed: ' + err.message);
} finally {
btnSelected.disabled = false;
btnSelected.textContent = keep;
}
});
// Kill script button
btnKill.addEventListener('click', async () => {
// First stop continuous mode if it's running
if (isContinuousMode) {
try {
const response = await fetch((window.KORI_REST||'/wp-json/kori/v2/') + 'pricing/stop-continuous', {
method: 'POST',
credentials: 'same-origin',
headers: {'Content-Type': 'application/json'}
});
if (response.ok) {
const result = await response.json();
if (result.success) {
isContinuousMode = false;
btnAll.textContent = 'Update Pricing (All Sets)';
btnAll.style.background = '#155e75';
status.textContent = '';
appendOutput('');
appendOutput('🛑 Continuous mode stopped by kill script');
// Clear progress interval
if (progressInterval) {
clearInterval(progressInterval);
progressInterval = null;
}
}
}
} catch (error) {
console.log('Could not stop continuous mode:', error);
}
}
const keep = btnKill.textContent;
btnKill.disabled = true;
btnKill.textContent = 'KILLING...';
try {
const response = await fetch((window.KORI_REST||'/wp-json/kori/v2/') + 'pricing/kill', {
method: 'POST',
credentials: 'same-origin',
headers: {'Content-Type': 'application/json'}
});
if (response.ok) {
const result = await response.json();
if (result.success) {
status.textContent = 'Script killed successfully';
showToast(shadow, 'Script killed successfully');
appendOutput('');
appendOutput('🛑 Script killed successfully');
} else {
status.textContent = `Failed to kill script: ${result.message}`;
showToast(shadow, 'Failed to kill script');
appendOutput('');
appendOutput(`❌ Failed to kill script: ${result.message}`);
}
} else {
status.textContent = 'Error killing script';
showToast(shadow, 'Error killing script');
appendOutput('');
appendOutput('❌ Error killing script');
}
} catch (error) {
status.textContent = 'Error killing script';
showToast(shadow, 'Error killing script');
appendOutput('');
appendOutput(`❌ Error killing script: ${error.message}`);
} finally {
btnKill.disabled = false;
btnKill.textContent = keep;
}
});
// Test Python script button
btnTest.addEventListener('click', async () => {
const keep = btnTest.textContent;
btnTest.disabled = true;
btnTest.textContent = 'TESTING...';
try {
await testPythonScript();
} catch (error) {
appendOutput('');
appendOutput('❌ Test failed: ' + error.message);
} finally {
btnTest.disabled = false;
btnTest.textContent = keep;
}
});
})();
}
function sizeSymbols(shadow){
// keep callable if needed later
}
// ------- Boot -------
function boot(){
const mounted = mountRoot(); if (!mounted) return;
const {shadow, stage} = mounted;
route(shadow, stage);
wireDelegates(shadow, stage);
window.addEventListener('popstate', ()=>route(shadow, stage));
const mo = new MutationObserver(()=>{
const root = document.getElementById('kori-v2-root');
if (!root){ boot(); }
});
mo.observe(document.body, {childList:true, subtree:true});
}
if (document.readyState === 'loading') {
document.addEventListener('DOMContentLoaded', boot);
} else {
boot();
}
})();
` : ``}