Skip to content

M
MBetterc
Commit 126fa697 authored by Stefy Lanza (nextime / spora )'s avatar Stefy Lanza (nextime / spora )
Browse files
Options

Version 1.2.7: Fix API client health monitoring and add betting mode configuration 

- Fixed 'Unhealthy components detected: api_client' warning by implementing comprehensive heartbeat system
- Added heartbeat calls in main loop, HTTP requests, database operations, and error handling
- Added betting mode configuration UI in web dashboard with database persistence
- Created Migration_015_AddBettingModeTable for betting_modes table
- Added betting mode API endpoints (GET/POST /api/betting-mode)
- Updated documentation with betting mode configuration and API client health monitoring
- Enhanced error handling to prevent thread hangs and maintain health status
- Added troubleshooting section for API client health issues
parent 4ddf7439
Show whitespace changes
Inline Side-by-side
Showing with 4785 additions and 1811 deletions
CHANGELOG.md
View file @ 126fa697
......@@ -2,6 +2,34 @@
All notable changes to this project will be documented in this file.
## [1.2.7] - 2025-08-26
### Added
- **Betting Mode Configuration**: Complete betting mode management system with web dashboard integration
- **Database Migration System**: Migration_015_AddBettingModeTable for betting_modes table with proper schema
- **Betting Mode API**: RESTful endpoints for getting and setting user betting modes
- **Configuration UI Enhancement**: Added betting mode settings section to configuration page
### Fixed
- **API Client Health Monitoring**: Resolved "Unhealthy components detected: ['api_client']" warning
- **Heartbeat System**: Implemented comprehensive heartbeat updates throughout API client operations
- **Thread Health Checks**: Enhanced error handling to prevent thread hangs and maintain health status
- **Database Operation Protection**: Added heartbeat calls during potentially slow database operations
- **HTTP Request Protection**: Added heartbeat calls before and after HTTP requests to prevent timeouts
### Enhanced
- **Error Handling**: Improved API client error handling with heartbeat updates even during failures
- **Logging**: Added debug logging for heartbeat updates during error handling
- **Performance**: Optimized heartbeat system to minimize overhead while ensuring health monitoring
- **Configuration Persistence**: Enhanced betting mode configuration with database persistence
### Technical Details
- **API Client Heartbeat**: Added heartbeat calls in main loop, HTTP requests, database operations, and error handling
- **Betting Mode Model**: Created BettingModeModel with user-specific settings and database constraints
- **Migration System**: Added Migration_015 with proper SQLite schema and indexing
- **Web Dashboard Integration**: Complete betting mode UI with real-time feedback and validation
- **Cross-Platform Compatibility**: Betting mode system works consistently across all supported platforms
## [1.2.6] - 2025-08-26
### Added
......
DOCUMENTATION.md
View file @ 126fa697
......@@ -160,6 +160,33 @@ Edit configuration through the web dashboard or modify JSON files directly:
}
```
### Betting Mode Configuration
The application supports two betting modes that can be configured per user:
#### Betting Modes
- **All Bets on Start**: Place all bets simultaneously when games begin (default)
- **One Bet at a Time**: Place bets individually for more controlled betting
#### Configuration
Betting mode is configured through the web dashboard:
1. Navigate to Configuration → Betting Mode Settings
2. Select desired betting mode from dropdown
3. Click "Save Betting Mode"
4. Settings are saved per user and persist across sessions
#### API Configuration
```json
{
"betting_mode": {
"user_id": 1,
"mode": "all_bets_on_start",
"created_at": "2025-08-26T11:30:00Z",
"updated_at": "2025-08-26T11:30:00Z"
}
}
```
### Environment Variables
Create a `.env` file in the project root:
......@@ -689,6 +716,43 @@ Content-Type: application/json
}
```
#### Get Betting Mode
```http
GET /api/betting-mode
Authorization: Bearer <token>
```
**Response:**
```json
{
"success": true,
"betting_mode": "all_bets_on_start",
"user_id": 1
}
```
#### Update Betting Mode
```http
POST /api/betting-mode
Authorization: Bearer <token>
Content-Type: application/json
{
"betting_mode": "one_bet_at_a_time"
}
```
**Response:**
```json
{
"success": true,
"message": "Betting mode updated successfully",
"betting_mode": "one_bet_at_a_time"
}
```
## Match Timer System
The application includes a comprehensive match timer system with automatic match progression, visual countdown displays, and command-line timer configuration.
......@@ -978,6 +1042,18 @@ This message is processed by the games thread to change the match status from "b
4. Ensure proper file permissions on database file
5. Verify SQLite installation and compatibility
#### API Client Health Issues
**Symptoms**: "Unhealthy components detected: ['api_client']" warning in logs
**Solutions**:
1. Check API client thread is running and not blocked
2. Verify network connectivity for API endpoints
3. Check API token validity and expiration
4. Review API client logs for specific error messages
5. Ensure database operations are not causing long delays
6. Check for HTTP request timeouts or network issues
7. Verify heartbeat system is functioning (added in version 1.2.7)
#### Performance Issues
**Symptoms**: Interface slow, updates delayed
......
README.md
View file @ 126fa697
......@@ -24,6 +24,14 @@ A cross-platform multimedia client application with video playback, web dashboar
## Recent Improvements
### Version 1.2.7 (August 2025)
- ✅ **API Client Health Monitoring**: Fixed "Unhealthy components detected: ['api_client']" warning by implementing comprehensive heartbeat system
- ✅ **Betting Mode Configuration**: Added complete betting mode management in web dashboard with database persistence
- ✅ **Database Migration System**: Added Migration_015 for betting_modes table with proper schema and constraints
- ✅ **Enhanced Error Handling**: Improved API client error handling to prevent thread hangs and maintain health status
- ✅ **Configuration UI Enhancement**: Added betting mode settings section to configuration page with real-time feedback
### Version 1.2.6 (August 2025)
- ✅ **Automated Game Timer**: New `--start-timer` command line switch that sends START_GAME message after specified delay (default 4 minutes)
......@@ -168,6 +176,9 @@ python main.py --start-timer
# Start with custom timer delay (2 minutes)
python main.py --start-timer 2
# Enable debug mode showing only message bus messages
python main.py --dev-message
# Show help
python main.py --help
```
......@@ -192,6 +203,7 @@ Configuration is stored in SQLite database with automatic versioning. Access the
- System settings
- API token management
- User account management
- Betting mode configuration (all bets on start vs one bet at a time)
### Default Login
......@@ -270,6 +282,10 @@ Threads communicate via Python Queues with structured messages:
- `PUT /api/config/{section}` - Update configuration section
- `GET /api/config/{section}` - Get specific configuration section
#### Betting Mode Management
- `GET /api/betting-mode` - Get current betting mode for user
- `POST /api/betting-mode` - Update betting mode for user
#### Template Management
- `GET /api/templates` - List available overlay templates
- `POST /api/templates/upload` - Upload new template file
......@@ -348,6 +364,11 @@ Threads communicate via Python Queues with structured messages:
**Database errors during operation**
- Fixed in version 1.1 - all database operations now properly handle session closure
**API client showing as unhealthy**
- Fixed in version 1.2.7 - enhanced heartbeat system prevents "Unhealthy components detected: ['api_client']" warnings
- API client now maintains regular heartbeat updates even during long-running operations
- Improved error handling prevents thread hangs that could cause health check failures
### Building Issues
**PyInstaller build fails with missing modules**
......
build.py
View file @ 126fa697
......@@ -475,7 +475,7 @@ The application stores its configuration and database in:
## Web Interface
By default, the web interface is available at: http://localhost:5000
By default, the web interface is available at: http://localhost:5001
Default login credentials:
- Username: admin
......
cookies.txt 0 → 100644
View file @ 126fa697
# Netscape HTTP Cookie File
# https://curl.se/docs/http-cookies.html
# This file was generated by libcurl! Edit at your own risk.
#HttpOnly_127.0.0.1 FALSE / FALSE 0 session .eJwlzj0OwjAMQOG7ZGaof2LHvUyVxLZgTemEuDuV2N-Tvk85csX5LPt7XfEox8vLXoIZkY2FESapD3Yga6kIHNw6JUnidGftW6ZynVul6BGm5lBTEkzlrprNmB6OTdQbior3SjrqmDxti_tRkQ5JqTCEOKyjlBtynbH-GizfH6DyL20.aKzyUQ.JbC1Zst6dLOPb6oWBcnMziVCKFk
#HttpOnly_127.0.0.1 FALSE / FALSE 1787700689 remember_token 2|6839ea0e127e93742c1d52ba7c14f92c9b5b4e4a2fe97bb74c5b862f79ef1ce97a0297989c74f951dd7eba7340fd23ec4cb5e25a37c3dc28d53f13921f5f0776
create_test_matches.py 0 → 100644
View file @ 126fa697
#!/usr/bin/env python3
"""
Script to create test matches for the cashier interface
"""
import sys
from pathlib import Path
from datetime import datetime, date, timedelta
# Add the project root to Python path
project_root = Path(__file__).parent
sys.path.insert(0, str(project_root))
from mbetterclient.database.models import MatchModel
from mbetterclient.database.manager import DatabaseManager
from mbetterclient.config.settings import get_user_data_dir
def create_test_matches():
"""Create some test matches for the cashier interface"""
# Use the default database path
db_path = get_user_data_dir() / "mbetterclient.db"
db_manager = DatabaseManager(str(db_path))
if not db_manager.initialize():
print("Failed to initialize database")
return False
session = db_manager.get_session()
try:
# Check if matches already exist
existing_count = session.query(MatchModel).count()
if existing_count > 0:
print(f"Database already has {existing_count} matches. Skipping creation.")
return True
# Create test matches for today
today = date.today()
now = datetime.now()
# Create matches for fixture 1 (today's matches)
fixture_1_matches = [
MatchModel(
fixture_id=1,
match_number=1,
fighter1_township="Kampala Central",
fighter2_township="Nakawa",
venue_kampala_township="Main Arena",
start_time=datetime.combine(today, datetime.min.time()) + timedelta(hours=10),
status="pending",
created_at=now - timedelta(days=1)
),
MatchModel(
fixture_id=1,
match_number=2,
fighter1_township="Makindye",
fighter2_township="Rubaga",
venue_kampala_township="Main Arena",
start_time=datetime.combine(today, datetime.min.time()) + timedelta(hours=11),
status="pending",
created_at=now - timedelta(days=1)
),
MatchModel(
fixture_id=1,
match_number=3,
fighter1_township="Kawempe",
fighter2_township="Wandegeya",
venue_kampala_township="Secondary Arena",
start_time=datetime.combine(today, datetime.min.time()) + timedelta(hours=14),
status="pending",
created_at=now - timedelta(days=1)
),
MatchModel(
fixture_id=1,
match_number=4,
fighter1_township="Ntinda",
fighter2_township="Kololo",
venue_kampala_township="Main Arena",
start_time=datetime.combine(today, datetime.min.time()) + timedelta(hours=15),
status="pending",
created_at=now - timedelta(days=1)
),
MatchModel(
fixture_id=1,
match_number=5,
fighter1_township="Lubaga",
fighter2_township="Mengo",
venue_kampala_township="Secondary Arena",
start_time=datetime.combine(today, datetime.min.time()) + timedelta(hours=16),
status="pending",
created_at=now - timedelta(days=1)
)
]
# Create matches for fixture 2 (tomorrow's matches)
tomorrow = today + timedelta(days=1)
fixture_2_matches = [
MatchModel(
fixture_id=2,
match_number=1,
fighter1_township="Entebbe",
fighter2_township="Mukono",
venue_kampala_township="Main Arena",
start_time=datetime.combine(tomorrow, datetime.min.time()) + timedelta(hours=10),
status="scheduled",
created_at=now - timedelta(days=1)
),
MatchModel(
fixture_id=2,
match_number=2,
fighter1_township="Jinja",
fighter2_township="Iganga",
venue_kampala_township="Secondary Arena",
start_time=datetime.combine(tomorrow, datetime.min.time()) + timedelta(hours=11),
status="scheduled",
created_at=now - timedelta(days=1)
)
]
# Add all matches to the session
all_matches = fixture_1_matches + fixture_2_matches
for match in all_matches:
session.add(match)
# Commit the changes
session.commit()
print(f"Successfully created {len(all_matches)} test matches:")
print(f" - Fixture 1: {len(fixture_1_matches)} matches (today)")
print(f" - Fixture 2: {len(fixture_2_matches)} matches (tomorrow)")
# Verify the matches were created
total_count = session.query(MatchModel).count()
print(f"Total matches in database: {total_count}")
return True
except Exception as e:
print(f"Error creating test matches: {e}")
session.rollback()
return False
finally:
session.close()
db_manager.close()
if __name__ == "__main__":
print("Creating test matches for cashier interface...")
success = create_test_matches()
if success:
print("\n✅ Test matches created successfully!")
print("The cashier interface should now display pending matches.")
else:
print("\n❌ Failed to create test matches.")
sys.exit(1)
\ No newline at end of file
extract_js.py 0 → 100644
View file @ 126fa697
import re
with open('mbetterclient/web_dashboard/templates/dashboard/fixtures.html', 'r') as f:
content = f.read()
# Extract JavaScript
js_matches = re.findall(r'<script[^>]*>(.*?)</script>', content, re.DOTALL)
if js_matches:
js_code = js_matches[0]
# Write to a temporary file to examine
with open('temp_js.js', 'w') as f:
f.write(js_code)
print("JavaScript extracted and saved to temp_js.js")
print("First 200 characters:")
print(js_code[:200])
print("\nLast 200 characters:")
print(js_code[-200:])
else:
print("No JavaScript found")
\ No newline at end of file
main.py
View file @ 126fa697
......@@ -41,7 +41,7 @@ def setup_signal_handlers(app):
except ImportError:
pass # Qt not available
except Exception as e:
logging.debug(f"Qt shutdown check failed: {e}")
logging.debug("Qt shutdown check failed: {}".format(e))
# Fallback to normal app shutdown if Qt not running
if app:
......@@ -74,6 +74,7 @@ Examples:
python main.py --no-fullscreen # Run in windowed mode
python main.py --web-port 8080 # Custom web dashboard port
python main.py --debug # Enable debug logging
python main.py --dev-message # Show only message bus messages
"""
)
......@@ -127,6 +128,12 @@ Examples:
help='Enable development mode with additional debugging'
)
parser.add_argument(
'--dev-message',
action='store_true',
help='Enable debug mode showing only message bus messages'
)
parser.add_argument(
'--no-qt',
action='store_true',
......@@ -214,7 +221,7 @@ def main():
logger.info("=" * 60)
logger.info("MbetterClient Starting")
logger.info("=" * 60)
logger.info(f"Arguments: {vars(args)}")
logger.info("Arguments: {}".format(vars(args)))
# Create application settings
settings = AppSettings()
......@@ -222,6 +229,7 @@ def main():
settings.web_host = args.web_host
settings.web_port = args.web_port
settings.debug_mode = args.debug or args.dev_mode
settings.dev_message = args.dev_message
settings.enable_qt = not args.no_qt
settings.enable_web = not args.no_web
settings.qt.use_native_overlay = args.native_overlay
......@@ -248,7 +256,7 @@ def main():
settings.database_path = args.db_path
# Create and initialize application
app = MbetterClientApplication(settings)
app = MbetterClientApplication(settings, start_timer=args.start_timer)
# Setup signal handlers for graceful shutdown
setup_signal_handlers(app)
......@@ -270,7 +278,7 @@ def main():
print("\nInterrupted by user")
sys.exit(0)
except Exception as e:
print(f"Fatal error: {e}")
print("Fatal error: {}".format(e))
if args.debug if 'args' in locals() else False:
import traceback
traceback.print_exc()
......
mbetterclient/api_client/client.py
View file @ 126fa697
......@@ -241,6 +241,10 @@ class UpdatesResponseHandler(ResponseHandler):
matches = fixture_data.get('matches', [])
for match_data in matches:
try:
# Update heartbeat during processing to prevent health check failures
if self.api_client:
self.api_client.heartbeat()
# Add fixture-level data to match if available
if 'fixture_id' in fixture_data:
match_data['fixture_id'] = fixture_data['fixture_id']
......@@ -264,6 +268,10 @@ class UpdatesResponseHandler(ResponseHandler):
# Continue processing other matches even if this one fails
continue
# Update heartbeat before potentially slow commit operation
if self.api_client:
self.api_client.heartbeat()
session.commit()
finally:
......@@ -381,9 +389,16 @@ class UpdatesResponseHandler(ResponseHandler):
# Save to persistent storage
zip_path = self.zip_storage_dir / zip_filename
# Update heartbeat before potentially slow file write
if self.api_client:
self.api_client.heartbeat()
with open(zip_path, 'wb') as f:
for chunk in response.iter_content(chunk_size=8192):
f.write(chunk)
# Update heartbeat every few chunks for large files
if self.api_client and f.tell() % (1024 * 1024) == 0: # Every MB
self.api_client.heartbeat()
logger.info(f"Downloaded ZIP file: {zip_filename}")
return True
......@@ -618,21 +633,29 @@ class APIClient(ThreadedComponent):
# Main execution loop
while self.running:
try:
# Update heartbeat at the start of each loop
self.heartbeat()
# Process messages
message = self.message_bus.get_message(self.name, timeout=1.0)
if message:
self._process_message(message)
# Update heartbeat before potentially long operations
self.heartbeat()
# Execute scheduled API requests
self._execute_scheduled_requests()
# Update heartbeat
# Update heartbeat after operations
self.heartbeat()
time.sleep(1.0)
except Exception as e:
logger.error(f"APIClient run loop error: {e}")
# Update heartbeat even in error cases
self.heartbeat()
time.sleep(5.0)
except Exception as e:
......@@ -649,6 +672,9 @@ class APIClient(ThreadedComponent):
def _get_last_fixture_timestamp(self) -> Optional[str]:
"""Get the server activation timestamp of the last active fixture in the database"""
try:
# Update heartbeat before database operation
self.heartbeat()
session = self.db_manager.get_session()
try:
# Get the most recent match with fixture_active_time set
......@@ -656,6 +682,9 @@ class APIClient(ThreadedComponent):
MatchModel.fixture_active_time.isnot(None)
).order_by(MatchModel.fixture_active_time.desc()).first()
# Update heartbeat after database query
self.heartbeat()
if last_active_match and last_active_match.fixture_active_time:
# Return Unix timestamp as string (long integer number)
return str(last_active_match.fixture_active_time)
......@@ -668,11 +697,16 @@ class APIClient(ThreadedComponent):
except Exception as e:
logger.error(f"Failed to get last fixture activation timestamp: {e}")
# Update heartbeat even on error
self.heartbeat()
return None
def _execute_endpoint_request(self, endpoint: APIEndpoint):
"""Execute a single API request with custom retry logic for token-based endpoints"""
try:
# Update heartbeat before starting potentially long operation
self.heartbeat()
endpoint.last_request = datetime.utcnow()
endpoint.total_requests += 1
self.stats['total_requests'] += 1
......@@ -746,6 +780,9 @@ class APIClient(ThreadedComponent):
response = self.session.request(**request_kwargs)
response.raise_for_status()
# Update heartbeat after HTTP request completes
self.heartbeat()
# Debug log the complete response
logger.debug(f"Response status code: {response.status_code}")
logger.debug(f"Response headers: {dict(response.headers)}")
......@@ -762,6 +799,9 @@ class APIClient(ThreadedComponent):
handler = self.response_handlers.get(endpoint.response_handler, self.response_handlers['default'])
processed_data = handler.handle_response(endpoint, response)
# Update heartbeat after response processing
self.heartbeat()
# Update endpoint status
endpoint.last_success = datetime.utcnow()
endpoint.last_error = None
......@@ -787,6 +827,7 @@ class APIClient(ThreadedComponent):
except Exception as e:
# Handle request failure
self.heartbeat() # Update heartbeat even on failure
self._handle_request_failure(endpoint, e)
def _execute_with_custom_retry(self, endpoint: APIEndpoint, request_kwargs: dict) -> bool:
......@@ -801,6 +842,9 @@ class APIClient(ThreadedComponent):
response = self.session.request(**request_kwargs)
response.raise_for_status()
# Update heartbeat after HTTP retry request completes
self.heartbeat()
# Debug log the complete response (retry scenario)
logger.debug(f"Retry response status code: {response.status_code}")
logger.debug(f"Retry response headers: {dict(response.headers)}")
......@@ -817,6 +861,9 @@ class APIClient(ThreadedComponent):
handler = self.response_handlers.get(endpoint.response_handler, self.response_handlers['default'])
processed_data = handler.handle_response(endpoint, response)
# Update heartbeat after response processing
self.heartbeat()
# Update endpoint status - success!
endpoint.last_success = datetime.utcnow()
endpoint.last_error = None
......@@ -849,7 +896,13 @@ class APIClient(ThreadedComponent):
if attempt < max_retries - 1:
logger.warning(f"API retry {attempt + 1} failed for {endpoint.name}: {e}. Waiting {retry_delay}s before next retry.")
time.sleep(retry_delay)
# Sleep in smaller chunks to allow heartbeat updates during long delays
remaining_delay = retry_delay
while remaining_delay > 0 and self.running:
sleep_chunk = min(5.0, remaining_delay) # Sleep in 5-second chunks
time.sleep(sleep_chunk)
self.heartbeat() # Update heartbeat during retry delays
remaining_delay -= sleep_chunk
else:
logger.error(f"All {max_retries} retries failed for {endpoint.name}: {e}")
......@@ -859,12 +912,18 @@ class APIClient(ThreadedComponent):
def _handle_request_failure(self, endpoint: APIEndpoint, error: Exception):
"""Handle request failure and send error message"""
# Update heartbeat when handling failures
self.heartbeat()
endpoint.last_error = str(error)
endpoint.consecutive_failures += 1
self.stats['failed_requests'] += 1
logger.error(f"API request failed: {endpoint.name} - {error}")
# Log heartbeat status for debugging
logger.debug(f"API client heartbeat updated during error handling for {endpoint.name}")
# Send error message
error_message = Message(
type=MessageType.API_RESPONSE,
......
mbetterclient/core/application.py
View file @ 126fa697
......@@ -22,11 +22,14 @@ logger = logging.getLogger(__name__)
class MbetterClientApplication:
"""Main application class that coordinates all components"""
def __init__(self, settings: AppSettings):
def __init__(self, settings: AppSettings, start_timer: Optional[int] = None):
self.settings = settings
self.running = False
self.shutdown_event = threading.Event()
# Store the command line start_timer setting separately (not affected by database override)
self._start_timer_minutes = start_timer
# Core components
self.db_manager: Optional[DatabaseManager] = None
self.config_manager: Optional[ConfigManager] = None
......@@ -146,7 +149,7 @@ class MbetterClientApplication:
def _initialize_message_bus(self) -> bool:
"""Initialize message bus"""
try:
self.message_bus = MessageBus(max_queue_size=1000)
self.message_bus = MessageBus(max_queue_size=1000, dev_message=self.settings.dev_message)
# Register core component
self.message_bus.register_component("core")
......@@ -155,7 +158,6 @@ class MbetterClientApplication:
self.message_bus.subscribe("core", MessageType.SYSTEM_SHUTDOWN, self._handle_shutdown_message)
self.message_bus.subscribe("core", MessageType.CONFIG_UPDATE, self._handle_config_update)
self.message_bus.subscribe("core", MessageType.LOG_ENTRY, self._handle_log_entry)
self.message_bus.subscribe("core", MessageType.START_GAME, self._handle_start_game_message)
logger.info("Message bus initialized")
return True
......@@ -471,6 +473,11 @@ class MbetterClientApplication:
)
self.message_bus.publish(ready_message, broadcast=True)
# Start automated game timer if specified on command line
if self._start_timer_minutes is not None:
logger.info(f"Command line timer enabled, starting {self._start_timer_minutes} minute timer")
self._start_game_timer()
logger.info("MbetterClient application started successfully")
# If Qt player is enabled, run its event loop on the main thread
......@@ -486,7 +493,9 @@ class MbetterClientApplication:
return self.qt_player.run()
else:
# Wait for shutdown with a timeout to prevent indefinite hanging
# No UI components - keep application running in background mode
logger.info("No UI components enabled - running in background mode")
# Wait for shutdown signal (Ctrl+C, etc.)
while self.running and not self.shutdown_event.is_set():
self.shutdown_event.wait(timeout=1.0)
......@@ -551,6 +560,8 @@ class MbetterClientApplication:
self._handle_system_error(message)
elif message.type == MessageType.CONFIG_REQUEST:
self._handle_config_request(message)
elif message.type == MessageType.START_GAME:
self._handle_start_game_message(message)
elif message.type == MessageType.SYSTEM_SHUTDOWN:
self._handle_shutdown_message(message)
else:
......@@ -687,21 +698,13 @@ class MbetterClientApplication:
logger.error(f"Failed to handle log entry: {e}")
def _handle_start_game_message(self, message: Message):
"""Handle START_GAME message by starting the timer"""
"""Handle START_GAME message - only cancel the start-timer as its job is done"""
try:
if not self.settings.timer.enabled:
logger.debug("Timer not enabled, ignoring START_GAME message")
return
# Cancel any existing timer
# The core should only cancel its start-timer when START_GAME is received
# The actual START_GAME processing is done by games_thread
logger.info("START_GAME message received - cancelling command line start-timer as it has completed its job")
self._cancel_game_timer()
# Start new timer
delay_seconds = self.settings.timer.delay_minutes * 60
logger.info(f"START_GAME message received from {message.sender}, starting timer for {self.settings.timer.delay_minutes} minutes ({delay_seconds} seconds)")
self._game_start_timer()
except Exception as e:
logger.error(f"Failed to handle START_GAME message: {e}")
......@@ -713,11 +716,11 @@ class MbetterClientApplication:
def _start_game_timer(self):
"""Start the timer for automated game start"""
if not self.settings.timer.enabled:
if self._start_timer_minutes is None:
return
delay_seconds = self.settings.timer.delay_minutes * 60
logger.info(f"Starting game timer: {self.settings.timer.delay_minutes} minutes ({delay_seconds} seconds)")
delay_seconds = self._start_timer_minutes * 60
logger.info(f"Starting command line game timer: {self._start_timer_minutes} minutes ({delay_seconds} seconds)")
self._game_start_timer = threading.Timer(delay_seconds, self._on_game_timer_expired)
self._game_start_timer.daemon = True
......@@ -725,19 +728,19 @@ class MbetterClientApplication:
def _on_game_timer_expired(self):
"""Called when the game start timer expires"""
logger.info("Game start timer expired, sending START_GAME_DELAYED message")
logger.info("Game start timer expired, sending START_GAME message")
try:
# Create and send START_GAME_DELAYED message
start_game_delayed_message = MessageBuilder.start_game_delayed(
# Create and send START_GAME message
start_game_message = MessageBuilder.start_game(
sender="timer",
delay_minutes=self.settings.timer.delay_minutes
fixture_id=None # Let the games thread find the best fixture
)
self.message_bus.publish(start_game_delayed_message, broadcast=True)
self.message_bus.publish(start_game_message, broadcast=True)
logger.info("START_GAME_DELAYED message sent successfully")
logger.info("START_GAME message sent successfully")
except Exception as e:
logger.error(f"Failed to send START_GAME_DELAYED message: {e}")
logger.error(f"Failed to send START_GAME message: {e}")
def _cancel_game_timer(self):
"""Cancel the game start timer if it's running"""
......
mbetterclient/core/games_thread.py
View file @ 126fa697
......@@ -97,65 +97,55 @@ class GamesThread(ThreadedComponent):
self.game_active = False
def _handle_start_game(self, message: Message):
"""Handle START_GAME message"""
"""Handle START_GAME message with comprehensive logic"""
try:
fixture_id = message.data.get("fixture_id")
logger.info(f"Processing START_GAME message from {message.sender}")
if not fixture_id:
# If no fixture_id provided, find the last fixture with pending matches
fixture_id = self._find_last_fixture_with_pending_matches()
fixture_id = message.data.get("fixture_id")
if fixture_id:
logger.info(f"Starting game for fixture: {fixture_id}")
self.current_fixture_id = fixture_id
self.game_active = True
# If fixture_id is provided, check if it's in terminal state
if self._is_fixture_all_terminal(fixture_id):
logger.info(f"Fixture {fixture_id} is in terminal state - discarding START_GAME message")
self._send_response(message, "discarded", f"Fixture {fixture_id} is already completed")
return
# Send game started confirmation
response = Message(
type=MessageType.GAME_STATUS,
sender=self.name,
recipient=message.sender,
data={
"status": "started",
"fixture_id": fixture_id,
"timestamp": time.time()
},
correlation_id=message.correlation_id
)
self.message_bus.publish(response)
else:
logger.warning("No fixture with pending matches found")
# Fixture is not terminal, activate it
logger.info(f"Activating provided fixture: {fixture_id}")
self._activate_fixture(fixture_id, message)
return
# Send error response
error_response = Message(
type=MessageType.GAME_STATUS,
sender=self.name,
recipient=message.sender,
data={
"status": "error",
"error": "No fixture with pending matches found",
"timestamp": time.time()
},
correlation_id=message.correlation_id
)
self.message_bus.publish(error_response)
# No fixture_id provided - check today's fixtures
if self._has_today_fixtures_all_terminal():
logger.info("All today's fixtures are in terminal states - discarding START_GAME message")
self._send_response(message, "discarded", "All today's fixtures are already completed")
return
# Step 2: Handle matches currently in "ingame" status
ingame_handled = self._handle_ingame_matches(message)
if ingame_handled:
# Message was handled (either discarded or processed) - return
return
# Step 3: Check if there are active fixtures with today's date
active_fixture = self._find_active_today_fixture()
if active_fixture:
logger.info(f"Found active fixture for today: {active_fixture}")
self._activate_fixture(active_fixture, message)
return
# Step 4: No active fixtures found - initialize new fixture
logger.info("No active fixtures found - initializing new fixture")
new_fixture_id = self._initialize_new_fixture()
if new_fixture_id:
self._activate_fixture(new_fixture_id, message)
else:
logger.warning("Could not initialize new fixture")
self._send_response(message, "error", "Could not initialize new fixture")
except Exception as e:
logger.error(f"Failed to handle START_GAME message: {e}")
# Send error response
error_response = Message(
type=MessageType.GAME_STATUS,
sender=self.name,
recipient=message.sender,
data={
"status": "error",
"error": str(e),
"timestamp": time.time()
},
correlation_id=message.correlation_id
)
self.message_bus.publish(error_response)
self._send_response(message, "error", str(e))
def _handle_schedule_games(self, message: Message):
"""Handle SCHEDULE_GAMES message - change status of pending matches to scheduled"""
......@@ -251,8 +241,14 @@ class GamesThread(ThreadedComponent):
try:
logger.debug(f"GamesThread processing message: {message}")
# Messages are handled by subscribed handlers, but we can add additional processing here
if message.type == MessageType.GAME_UPDATE:
# Handle messages directly since broadcast messages don't trigger subscription handlers
if message.type == MessageType.START_GAME:
self._handle_start_game(message)
elif message.type == MessageType.SCHEDULE_GAMES:
self._handle_schedule_games(message)
elif message.type == MessageType.SYSTEM_SHUTDOWN:
self._handle_shutdown_message(message)
elif message.type == MessageType.GAME_UPDATE:
self._handle_game_update(message)
except Exception as e:
......@@ -371,6 +367,534 @@ class GamesThread(ThreadedComponent):
except Exception as e:
logger.error(f"Failed to monitor game state: {e}")
def _send_response(self, original_message: Message, status: str, message: str = None):
"""Send response message back to the sender"""
try:
response_data = {
"status": status,
"timestamp": time.time()
}
if message:
response_data["message"] = message
response = Message(
type=MessageType.GAME_STATUS,
sender=self.name,
recipient=original_message.sender,
data=response_data,
correlation_id=original_message.correlation_id
)
self.message_bus.publish(response)
except Exception as e:
logger.error(f"Failed to send response: {e}")
def _is_fixture_all_terminal(self, fixture_id: str) -> bool:
"""Check if all matches in a fixture are in terminal states (done, cancelled, failed, paused)"""
try:
session = self.db_manager.get_session()
try:
# Get all matches for this fixture
matches = session.query(MatchModel).filter(
MatchModel.fixture_id == fixture_id,
MatchModel.active_status == True
).all()
if not matches:
return False # No matches means not terminal
# Check if all matches are in terminal states
terminal_states = ['done', 'cancelled', 'failed', 'paused']
return all(match.status in terminal_states for match in matches)
finally:
session.close()
except Exception as e:
logger.error(f"Failed to check if fixture {fixture_id} is terminal: {e}")
return False
def _has_today_fixtures_all_terminal(self) -> bool:
"""Check if all fixtures with today's matches are in terminal states"""
try:
session = self.db_manager.get_session()
try:
# Get today's date
today = datetime.now().date()
# Find all fixtures that have matches with today's start_time
fixtures_with_today_matches = session.query(MatchModel.fixture_id).filter(
MatchModel.start_time.isnot(None),
MatchModel.start_time >= datetime.combine(today, datetime.min.time()),
MatchModel.start_time < datetime.combine(today, datetime.max.time())
).distinct().all()
if not fixtures_with_today_matches:
return False # No today's fixtures
# Check each fixture
for fixture_row in fixtures_with_today_matches:
fixture_id = fixture_row.fixture_id
if not self._is_fixture_all_terminal(fixture_id):
return False # Found a non-terminal fixture
return True # All fixtures are terminal
finally:
session.close()
except Exception as e:
logger.error(f"Failed to check today's fixtures terminal status: {e}")
return False
def _handle_ingame_matches(self, message: Message) -> bool:
"""Handle matches currently in 'ingame' status. Returns True if message was handled."""
try:
session = self.db_manager.get_session()
try:
# Get today's date
today = datetime.now().date()
# Find fixtures with ingame matches today
ingame_matches = session.query(MatchModel).filter(
MatchModel.start_time.isnot(None),
MatchModel.start_time >= datetime.combine(today, datetime.min.time()),
MatchModel.start_time < datetime.combine(today, datetime.max.time()),
MatchModel.status == 'ingame',
MatchModel.active_status == True
).all()
if not ingame_matches:
return False # No ingame matches, continue processing
# Get unique fixture IDs
fixture_ids = list(set(match.fixture_id for match in ingame_matches))
for fixture_id in fixture_ids:
# Check if timer is running for this fixture
# This is a simplified check - in real implementation you'd check the match_timer component
timer_running = self._is_timer_running_for_fixture(fixture_id)
if not timer_running:
# Timer not running, change status to failed
logger.info(f"Timer not running for fixture {fixture_id}, changing ingame matches to failed")
self._change_fixture_matches_status(fixture_id, 'ingame', 'failed')
# Check if this was the only non-terminal fixture
if self._is_only_non_terminal_fixture(fixture_id):
logger.info("This was the only non-terminal fixture - discarding START_GAME message")
self._send_response(message, "discarded", "Timer not running and no other active fixtures")
return True
else:
# Timer is running, check for other pending/bet/scheduled matches
other_active_matches = session.query(MatchModel).filter(
MatchModel.fixture_id == fixture_id,
MatchModel.status.in_(['pending', 'bet', 'scheduled']),
MatchModel.active_status == True
).all()
if other_active_matches:
# Change first pending/bet/scheduled match to bet status
first_match = other_active_matches[0]
if first_match.status != 'bet':
logger.info(f"Changing match {first_match.match_number} status to bet")
first_match.status = 'bet'
session.commit()
# Timer is running, discard the message
logger.info(f"Timer running for fixture {fixture_id} - discarding START_GAME message")
self._send_response(message, "discarded", "Timer already running for active fixture")
return True
return False # Continue processing
finally:
session.close()
except Exception as e:
logger.error(f"Failed to handle ingame matches: {e}")
return False
def _is_timer_running_for_fixture(self, fixture_id: str) -> bool:
"""Check if timer is running for a specific fixture"""
# This is a simplified implementation
# In a real implementation, you'd check the match_timer component status
return self.current_fixture_id == fixture_id and self.game_active
def _change_fixture_matches_status(self, fixture_id: str, from_status: str, to_status: str):
"""Change status of matches in a fixture from one status to another"""
try:
session = self.db_manager.get_session()
try:
matches = session.query(MatchModel).filter(
MatchModel.fixture_id == fixture_id,
MatchModel.status == from_status,
MatchModel.active_status == True
).all()
for match in matches:
logger.info(f"Changing match {match.match_number} status from {from_status} to {to_status}")
match.status = to_status
session.commit()
finally:
session.close()
except Exception as e:
logger.error(f"Failed to change match statuses: {e}")
def _is_only_non_terminal_fixture(self, fixture_id: str) -> bool:
"""Check if this is the only non-terminal fixture"""
try:
session = self.db_manager.get_session()
try:
# Get today's date
today = datetime.now().date()
# Find all fixtures with today's matches
all_fixtures = session.query(MatchModel.fixture_id).filter(
MatchModel.start_time.isnot(None),
MatchModel.start_time >= datetime.combine(today, datetime.min.time()),
MatchModel.start_time < datetime.combine(today, datetime.max.time())
).distinct().all()
# Check each fixture except the current one
terminal_states = ['done', 'cancelled', 'failed', 'paused']
non_terminal_count = 0
for fixture_row in all_fixtures:
fid = fixture_row.fixture_id
if fid == fixture_id:
continue
# Check if this fixture has non-terminal matches
non_terminal_matches = session.query(MatchModel).filter(
MatchModel.fixture_id == fid,
MatchModel.status.notin_(terminal_states),
MatchModel.active_status == True
).all()
if non_terminal_matches:
non_terminal_count += 1
return non_terminal_count == 0
finally:
session.close()
except Exception as e:
logger.error(f"Failed to check if only non-terminal fixture: {e}")
return False
def _find_active_today_fixture(self) -> Optional[str]:
"""Find an active fixture with today's date"""
try:
session = self.db_manager.get_session()
try:
# Get today's date
today = datetime.now().date()
# Find fixtures with today's matches that are not in terminal states
terminal_states = ['done', 'cancelled', 'failed', 'paused']
active_matches = session.query(MatchModel).filter(
MatchModel.start_time.isnot(None),
MatchModel.start_time >= datetime.combine(today, datetime.min.time()),
MatchModel.start_time < datetime.combine(today, datetime.max.time()),
MatchModel.status.notin_(terminal_states),
MatchModel.active_status == True
).order_by(MatchModel.start_time.asc()).all()
if active_matches:
return active_matches[0].fixture_id
return None
finally:
session.close()
except Exception as e:
logger.error(f"Failed to find active today fixture: {e}")
return None
def _initialize_new_fixture(self) -> Optional[str]:
"""Initialize a new fixture by finding the first one with no start_time set"""
try:
session = self.db_manager.get_session()
try:
# Find the first fixture with no start_time set
fixtures_no_start_time = session.query(MatchModel.fixture_id).filter(
MatchModel.start_time.is_(None),
MatchModel.active_status == True
).distinct().order_by(MatchModel.created_at.asc()).all()
if not fixtures_no_start_time:
return None
fixture_id = fixtures_no_start_time[0].fixture_id
logger.info(f"Initializing new fixture: {fixture_id}")
# Set start_time to now for all matches in this fixture
now = datetime.utcnow()
matches = session.query(MatchModel).filter(
MatchModel.fixture_id == fixture_id,
MatchModel.active_status == True
).all()
for match in matches:
match.start_time = now
match.status = 'scheduled'
logger.debug(f"Set start_time for match {match.match_number}")
session.commit()
return fixture_id
finally:
session.close()
except Exception as e:
logger.error(f"Failed to initialize new fixture: {e}")
return None
def _activate_fixture(self, fixture_id: str, message: Message):
"""Activate a fixture and start the game"""
try:
logger.info(f"🎯 ACTIVATING FIXTURE: {fixture_id}")
# Check if fixture is already active to prevent double activation
if self.current_fixture_id == fixture_id and self.game_active:
logger.warning(f"Fixture {fixture_id} is already active - ignoring duplicate activation")
self._send_response(message, "already_active", f"Fixture {fixture_id} already active")
return
# Set current fixture
self.current_fixture_id = fixture_id
self.game_active = True
# Step 1 & 2: Change match statuses in a single transaction
logger.info(f"🔄 Starting match status changes for fixture {fixture_id}")
self._schedule_and_apply_betting_logic(fixture_id)
# Send game started confirmation
logger.info(f"✅ Fixture {fixture_id} activated successfully")
self._send_response(message, "started", f"Fixture {fixture_id} activated")
# Start match timer
logger.info(f"⏰ Starting match timer for fixture {fixture_id}")
self._start_match_timer(fixture_id)
# Refresh dashboard statuses
self._refresh_dashboard_statuses()
except Exception as e:
logger.error(f"❌ Failed to activate fixture {fixture_id}: {e}")
import traceback
logger.error(f"Stack trace: {traceback.format_exc()}")
self._send_response(message, "error", f"Failed to activate fixture: {str(e)}")
def _schedule_and_apply_betting_logic(self, fixture_id: str):
"""Change match statuses in a single transaction: first to 'scheduled', then apply betting logic"""
try:
logger.info(f"🔄 Starting match status update for fixture {fixture_id}")
# Get betting mode configuration from database (default to 'all_bets_on_start')
betting_mode = self._get_betting_mode_config()
logger.info(f"📋 Using betting mode: {betting_mode}")
session = self.db_manager.get_session()
try:
# First, let's see what matches exist for this fixture
all_matches = session.query(MatchModel).filter(
MatchModel.fixture_id == fixture_id,
MatchModel.active_status == True
).all()
if not all_matches:
logger.warning(f"⚠️ No matches found for fixture {fixture_id}")
return
logger.info(f"📊 Found {len(all_matches)} total matches in fixture {fixture_id}")
for match in all_matches:
logger.info(f" Match {match.match_number}: {match.fighter1_township} vs {match.fighter2_township} - Status: {match.status}")
# Step 1: Change ALL matches in the fixture to 'scheduled' status first
terminal_states = ['done', 'cancelled', 'failed', 'paused']
matches = session.query(MatchModel).filter(
MatchModel.fixture_id == fixture_id,
MatchModel.status.notin_(terminal_states),
MatchModel.active_status == True
).all()
logger.info(f"📋 Found {len(matches)} non-terminal matches to process")
scheduled_count = 0
for match in matches:
if match.status != 'scheduled':
logger.info(f"🔄 Changing match {match.match_number} status from '{match.status}' to 'scheduled'")
match.status = 'scheduled'
scheduled_count += 1
else:
logger.info(f"✅ Match {match.match_number} already scheduled")
# Flush to make sure scheduled status is available for next step
if scheduled_count > 0:
session.flush()
logger.info(f"✅ Scheduled {scheduled_count} matches in fixture {fixture_id}")
else:
logger.info("📋 No matches needed scheduling")
# Step 2: Apply betting logic based on configuration
if betting_mode == 'all_bets_on_start':
logger.info("🎰 Applying 'all_bets_on_start' logic")
# Change ALL scheduled matches to 'bet' status
scheduled_matches = session.query(MatchModel).filter(
MatchModel.fixture_id == fixture_id,
MatchModel.status == 'scheduled',
MatchModel.active_status == True
).all()
logger.info(f"📋 Found {len(scheduled_matches)} scheduled matches to change to 'bet'")
bet_count = 0
for match in scheduled_matches:
logger.info(f"🎰 Changing match {match.match_number} status to 'bet' (all bets on start)")
match.status = 'bet'
bet_count += 1
if bet_count > 0:
logger.info(f"✅ Changed {bet_count} matches to 'bet' status (all bets on start mode)")
else:
logger.warning("⚠️ No scheduled matches found to change to 'bet' status")
else: # 'one_bet_at_a_time'
logger.info("🎯 Applying 'one_bet_at_a_time' logic")
# Change only the FIRST scheduled match to 'bet' status
first_match = session.query(MatchModel).filter(
MatchModel.fixture_id == fixture_id,
MatchModel.status == 'scheduled',
MatchModel.active_status == True
).order_by(MatchModel.match_number.asc()).first()
if first_match:
logger.info(f"🎯 Changing first match {first_match.match_number} status to 'bet' (one bet at a time)")
first_match.status = 'bet'
else:
logger.warning("⚠️ No scheduled match found to change to 'bet' status")
# Commit all changes in a single transaction
logger.info("💾 Committing database changes...")
session.commit()
logger.info(f"✅ Successfully updated match statuses for fixture {fixture_id} with betting mode: {betting_mode}")
# Send notification to web dashboard about fixture status update
try:
from .message_bus import Message, MessageType
status_update_message = Message(
type=MessageType.CUSTOM,
sender=self.name,
recipient="web_dashboard",
data={
"fixture_status_update": {
"fixture_id": fixture_id,
"betting_mode": betting_mode,
"timestamp": time.time()
}
}
)
self.message_bus.publish(status_update_message)
logger.info(f"📢 Broadcast fixture status update notification for {fixture_id}")
except Exception as msg_e:
logger.warning(f"Failed to send fixture status update notification: {msg_e}")
# Verify the changes were applied
final_matches = session.query(MatchModel).filter(
MatchModel.fixture_id == fixture_id,
MatchModel.active_status == True
).all()
logger.info(f"🔍 Final match statuses for fixture {fixture_id}:")
for match in final_matches:
logger.info(f" Match {match.match_number}: {match.status}")
finally:
session.close()
except Exception as e:
logger.error(f"❌ Failed to schedule and apply betting logic: {e}")
import traceback
logger.error(f"Stack trace: {traceback.format_exc()}")
# Try to rollback in case of error
try:
if 'session' in locals():
session.rollback()
except Exception as rollback_e:
logger.error(f"Failed to rollback: {rollback_e}")
def _get_betting_mode_config(self) -> str:
"""Get betting mode configuration from database (default: 'all_bets_on_start')"""
try:
session = self.db_manager.get_session()
try:
from ..database.models import BettingModeModel
# Get the first betting mode configuration (assuming it's system-wide)
# If user-specific, this would need to be modified to get user context
betting_mode_entry = session.query(BettingModeModel).first()
if betting_mode_entry:
return betting_mode_entry.mode
else:
# Default to 'all_bets_on_start' if no configuration found
return 'all_bets_on_start'
finally:
session.close()
except Exception as e:
logger.error(f"Failed to get betting mode config: {e}")
# Default fallback
return 'all_bets_on_start'
def _refresh_dashboard_statuses(self):
"""Refresh dashboard statuses by sending update messages"""
try:
# Send refresh message to web dashboard
refresh_message = Message(
type=MessageType.GAME_STATUS,
sender=self.name,
data={
"action": "refresh",
"timestamp": time.time()
}
)
self.message_bus.publish(refresh_message, broadcast=True)
except Exception as e:
logger.error(f"Failed to refresh dashboard statuses: {e}")
def _start_match_timer(self, fixture_id: str):
"""Start the match timer for the fixture"""
try:
# Send message to match timer component
timer_message = Message(
type=MessageType.START_GAME,
sender=self.name,
recipient="match_timer",
data={
"fixture_id": fixture_id,
"action": "start_timer",
"timestamp": time.time()
}
)
self.message_bus.publish(timer_message)
logger.info(f"Started match timer for fixture {fixture_id}")
except Exception as e:
logger.error(f"Failed to start match timer: {e}")
def _cleanup(self):
"""Perform cleanup operations"""
try:
......
mbetterclient/core/match_timer.py
View file @ 126fa697
......@@ -61,6 +61,11 @@ class MatchTimerComponent(ThreadedComponent):
while self.running:
try:
# Process any pending messages first
message = self.message_bus.get_message(self.name, timeout=0.1)
if message:
self._process_message(message)
current_time = time.time()
# Check if timer needs to be updated
......@@ -72,7 +77,9 @@ class MatchTimerComponent(ThreadedComponent):
# Timer reached zero, start next match
self._on_timer_expired()
else:
# Update last activity
# Send periodic timer updates (every 1 second)
if current_time - self._last_update >= 1.0:
self._send_timer_update()
self._last_update = current_time
# Check if we should stop the timer (no more matches)
......@@ -92,6 +99,22 @@ class MatchTimerComponent(ThreadedComponent):
logger.info("MatchTimer component stopped")
def _process_message(self, message):
"""Process incoming messages directly"""
try:
logger.debug(f"MatchTimer processing message: {message}")
# Handle messages directly since some messages don't trigger subscription handlers
if message.type == MessageType.START_GAME:
self._handle_start_game(message)
elif message.type == MessageType.SCHEDULE_GAMES:
self._handle_schedule_games(message)
elif message.type == MessageType.CUSTOM:
self._handle_custom_message(message)
except Exception as e:
logger.error(f"Failed to process message: {e}")
def shutdown(self):
"""Shutdown the match timer"""
with self._timer_lock:
......
mbetterclient/core/message_bus.py
View file @ 126fa697
......@@ -134,8 +134,9 @@ class Message:
class MessageBus:
"""Central message bus for inter-thread communication"""
def __init__(self, max_queue_size: int = 1000):
def __init__(self, max_queue_size: int = 1000, dev_message: bool = False):
self.max_queue_size = max_queue_size
self.dev_message = dev_message
self._queues: Dict[str, Queue] = {}
self._handlers: Dict[str, Dict[MessageType, List[Callable]]] = {}
self._global_handlers: Dict[MessageType, List[Callable]] = {}
......@@ -144,6 +145,9 @@ class MessageBus:
self._message_history: List[Message] = []
self._max_history = 1000
if dev_message:
logger.info("MessageBus initialized with dev_message mode enabled")
else:
logger.info("MessageBus initialized")
def register_component(self, component_name: str) -> Queue:
......@@ -200,8 +204,9 @@ class MessageBus:
# Add to message history
self._add_to_history(message)
# Log the message
logger.debug(f"Publishing message: {message}")
# Log the message (only in dev_message mode)
if self.dev_message:
logger.info(f"📨 MESSAGE_BUS: {message}")
if broadcast or message.recipient is None:
# Broadcast to all components
......
mbetterclient/database/migrations.py
View file @ 126fa697
......@@ -982,6 +982,55 @@ class Migration_014_AddExtractionAndGameConfigTables(DatabaseMigration):
return False
class Migration_015_AddBettingModeTable(DatabaseMigration):
"""Add betting_modes table for user betting preferences"""
def __init__(self):
super().__init__("015", "Add betting_modes table for user betting preferences")
def up(self, db_manager) -> bool:
"""Create betting_modes table"""
try:
with db_manager.engine.connect() as conn:
# Create betting_modes table
conn.execute(text("""
CREATE TABLE IF NOT EXISTS betting_modes (
id INTEGER PRIMARY KEY AUTOINCREMENT,
user_id INTEGER NOT NULL UNIQUE,
mode VARCHAR(50) NOT NULL DEFAULT 'all_bets_on_start',
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE
)
"""))
# Create indexes for betting_modes table
conn.execute(text("""
CREATE INDEX IF NOT EXISTS ix_betting_modes_user_id ON betting_modes(user_id)
"""))
conn.commit()
logger.info("Betting modes table created successfully")
return True
except Exception as e:
logger.error(f"Failed to create betting modes table: {e}")
return False
def down(self, db_manager) -> bool:
"""Drop betting_modes table"""
try:
with db_manager.engine.connect() as conn:
conn.execute(text("DROP TABLE IF EXISTS betting_modes"))
conn.commit()
logger.info("Betting modes table dropped")
return True
except Exception as e:
logger.error(f"Failed to drop betting modes table: {e}")
return False
# Registry of all migrations in order
MIGRATIONS: List[DatabaseMigration] = [
Migration_001_InitialSchema(),
......@@ -998,6 +1047,7 @@ MIGRATIONS: List[DatabaseMigration] = [
Migration_012_RemoveFixtureIdUniqueConstraint(),
Migration_013_AddStatusFieldToMatches(),
Migration_014_AddExtractionAndGameConfigTables(),
Migration_015_AddBettingModeTable(),
]
......
mbetterclient/database/models.py
View file @ 126fa697
......@@ -20,6 +20,7 @@ class MatchStatus(str, Enum):
SCHEDULED = "scheduled"
BET = "bet"
INGAME = "ingame"
DONE = "done"
CANCELLED = "cancelled"
FAILED = "failed"
PAUSED = "paused"
......@@ -95,6 +96,7 @@ class UserModel(BaseModel):
# Relationships
api_tokens = relationship('ApiTokenModel', back_populates='user', cascade='all, delete-orphan')
log_entries = relationship('LogEntryModel', back_populates='user')
betting_mode = relationship('BettingModeModel', back_populates='user', cascade='all, delete-orphan', uselist=False)
def set_password(self, password: str):
"""Set password hash using SHA-256 with salt (consistent with AuthManager)"""
......@@ -482,7 +484,7 @@ class MatchModel(BaseModel):
result = Column(String(255), comment='Match result/outcome')
done = Column(Boolean, default=False, nullable=False, comment='Match completion flag (0=pending, 1=done)')
running = Column(Boolean, default=False, nullable=False, comment='Match running flag (0=not running, 1=running)')
status = Column(Enum('pending', 'scheduled', 'bet', 'ingame', 'cancelled', 'failed', 'paused'), default='pending', nullable=False, comment='Match status enum')
status = Column(Enum('pending', 'scheduled', 'bet', 'ingame', 'done', 'cancelled', 'failed', 'paused'), default='pending', nullable=False, comment='Match status enum')
fixture_active_time = Column(Integer, nullable=True, comment='Unix timestamp when fixture became active on server')
# File metadata
......@@ -658,3 +660,21 @@ class GameConfigModel(BaseModel):
def __repr__(self):
return f'<GameConfig {self.config_key}={self.config_value}>'
class BettingModeModel(BaseModel):
"""Betting mode configuration"""
__tablename__ = 'betting_modes'
__table_args__ = (
Index('ix_betting_modes_user_id', 'user_id'),
UniqueConstraint('user_id', name='uq_betting_modes_user_id'),
)
user_id = Column(Integer, ForeignKey('users.id'), nullable=False, unique=True, comment='User who owns this betting mode setting')
mode = Column(String(50), nullable=False, default='all_bets_on_start', comment='Betting mode: all_bets_on_start or one_bet_at_a_time')
# Relationships
user = relationship('UserModel', back_populates='betting_mode')
def __repr__(self):
return f'<BettingMode user_id={self.user_id} mode={self.mode}>'
\ No newline at end of file
mbetterclient/web_dashboard/api.py
View file @ 126fa697
......@@ -538,8 +538,45 @@ class DashboardAPI:
def _get_components_status(self) -> Dict[str, Any]:
"""Get status of all components"""
# This would normally maintain a cache of component status
# or query components through message bus
try:
from flask import g
# Get main application from Flask context
main_app = g.get('main_app')
if main_app and hasattr(main_app, 'thread_manager'):
# Get real component status from thread manager
components_status = {}
# Get all registered components
component_names = main_app.thread_manager.get_component_names()
for component_name in component_names:
if main_app.thread_manager.is_component_running(component_name):
if main_app.thread_manager.is_component_healthy(component_name):
components_status[component_name] = "running"
else:
components_status[component_name] = "unhealthy"
else:
components_status[component_name] = "stopped"
# Always show web dashboard as running since we're responding
components_status["web_dashboard"] = "running"
# Always show message bus as running since we can query it
components_status["message_bus"] = "running"
return components_status
else:
# Fallback to hardcoded values if main app not available
return {
"qt_player": "unknown",
"web_dashboard": "running",
"api_client": "unknown",
"message_bus": "running"
}
except Exception as e:
logger.error(f"Failed to get real component status: {e}")
# Fallback to hardcoded values on error
return {
"qt_player": "unknown",
"web_dashboard": "running",
......
mbetterclient/web_dashboard/app.py
View file @ 126fa697
......@@ -298,8 +298,16 @@ class WebDashboard(ThreadedComponent):
def _process_message(self, message: Message):
"""Process received message"""
try:
# Messages are handled by subscribed handlers
pass
logger.debug(f"WebDashboard processing message: {message}")
# Handle messages directly since some messages don't trigger subscription handlers
if message.type == MessageType.CONFIG_UPDATE:
self._handle_config_update(message)
elif message.type == MessageType.SYSTEM_STATUS:
self._handle_system_status(message)
elif message.type == MessageType.CUSTOM:
self._handle_custom_message(message)
except Exception as e:
logger.error(f"Failed to process message: {e}")
......@@ -336,6 +344,7 @@ class WebDashboard(ThreadedComponent):
"""Handle custom messages (like timer state responses)"""
try:
response = message.data.get("response")
timer_update = message.data.get("timer_update")
if response == "timer_state":
# Update stored timer state
......@@ -355,6 +364,26 @@ class WebDashboard(ThreadedComponent):
}
logger.debug("Timer stopped")
elif timer_update:
# Handle periodic timer updates from match_timer component
self.current_timer_state.update(timer_update)
logger.debug(f"Timer update received: {timer_update}")
# Broadcast timer update to connected clients via global message bus
try:
timer_update_message = Message(
type=MessageType.CUSTOM,
sender=self.name,
data={
"timer_update": timer_update,
"timestamp": time.time()
}
)
self.message_bus.publish(timer_update_message, broadcast=True)
logger.debug("Timer update broadcasted to clients")
except Exception as broadcast_e:
logger.error(f"Failed to broadcast timer update: {broadcast_e}")
except Exception as e:
logger.error(f"Failed to handle custom message: {e}")
......
mbetterclient/web_dashboard/routes.py
View file @ 126fa697
......@@ -1299,12 +1299,12 @@ def get_cashier_pending_matches():
for fixture_row in all_fixtures:
fixture_id = fixture_row.fixture_id
# Check if all matches in this fixture are pending
# Check if all matches in this fixture are pending, scheduled, or bet
fixture_matches = session.query(MatchModel).filter_by(fixture_id=fixture_id).all()
if fixture_matches and all(match.status == 'pending' for match in fixture_matches):
if fixture_matches and all(match.status in ['pending', 'scheduled', 'bet'] for match in fixture_matches):
selected_fixture_id = fixture_id
logger.info(f"Selected fixture {selected_fixture_id} - all matches are pending")
logger.info(f"Selected fixture {selected_fixture_id} - all matches are in playable status (pending/scheduled/bet)")
break
# If no fixture with all pending matches found, use the first fixture by creation date
......@@ -1663,12 +1663,12 @@ def start_next_match():
for fixture_row in all_fixtures:
fixture_id = fixture_row.fixture_id
# Check if all matches in this fixture are pending
# Check if all matches in this fixture are pending, scheduled, or bet
fixture_matches = session.query(MatchModel).filter_by(fixture_id=fixture_id).all()
if fixture_matches and all(match.status == 'pending' for match in fixture_matches):
if fixture_matches and all(match.status in ['pending', 'scheduled', 'bet'] for match in fixture_matches):
selected_fixture_id = fixture_id
logger.info(f"Selected fixture {selected_fixture_id} - all matches are pending")
logger.info(f"Selected fixture {selected_fixture_id} - all matches are in playable status (pending/scheduled/bet)")
break
# If no fixture with all pending matches found, use the first fixture by creation date
......@@ -1815,21 +1815,51 @@ def notifications():
}
notification_queue.append(notification_data)
notification_received.set()
elif message.type == MessageType.CUSTOM and "timer_update" in message.data:
# Handle timer updates from match_timer component
notification_data = {
"type": "TIMER_UPDATE",
"data": message.data["timer_update"],
"timestamp": message.timestamp,
"sender": message.sender
}
notification_queue.append(notification_data)
notification_received.set()
elif message.type == MessageType.CUSTOM and "fixture_status_update" in message.data:
# Handle fixture status updates from games_thread
notification_data = {
"type": "FIXTURE_STATUS_UPDATE",
"data": message.data["fixture_status_update"],
"timestamp": message.timestamp,
"sender": message.sender
}
notification_queue.append(notification_data)
notification_received.set()
# Subscribe to relevant message types
if api_bp.message_bus:
api_bp.message_bus.subscribe_global(MessageType.START_GAME, message_handler)
api_bp.message_bus.subscribe_global(MessageType.MATCH_START, message_handler)
api_bp.message_bus.subscribe_global(MessageType.GAME_STATUS, message_handler)
api_bp.message_bus.subscribe_global(MessageType.CUSTOM, message_handler)
# Wait for notification or timeout
notification_received.wait(timeout=timeout)
# Unsubscribe from messages
# Unsubscribe from messages safely
if api_bp.message_bus:
api_bp.message_bus._global_handlers[MessageType.START_GAME].remove(message_handler)
api_bp.message_bus._global_handlers[MessageType.MATCH_START].remove(message_handler)
api_bp.message_bus._global_handlers[MessageType.GAME_STATUS].remove(message_handler)
try:
# Use proper unsubscribe methods instead of direct removal
for msg_type in [MessageType.START_GAME, MessageType.MATCH_START, MessageType.GAME_STATUS, MessageType.CUSTOM]:
try:
if hasattr(api_bp.message_bus, '_global_handlers') and msg_type in api_bp.message_bus._global_handlers:
handlers = api_bp.message_bus._global_handlers[msg_type]
if message_handler in handlers:
handlers.remove(message_handler)
except (AttributeError, KeyError, ValueError) as e:
logger.debug(f"Handler cleanup warning for {msg_type}: {e}")
except Exception as e:
logger.warning(f"Error during notification cleanup: {e}")
if notification_queue:
# Return the first notification received
......
mbetterclient/web_dashboard/static/js/dashboard.js
View file @ 126fa697
......@@ -14,7 +14,7 @@ window.Dashboard = (function() {
// Initialize dashboard
function init(userConfig) {
config = Object.assign({
statusUpdateInterval: 30000,
statusUpdateInterval: 5000,
apiEndpoint: '/api',
user: null
}, userConfig);
......@@ -450,84 +450,178 @@ window.Dashboard = (function() {
});
}
// Match Timer functionality
// Server-side Match Timer functionality
let matchTimerInterval = null;
let matchTimerSeconds = 0;
let matchTimerRunning = false;
let serverTimerState = {
running: false,
remaining_seconds: 0,
total_seconds: 0,
fixture_id: null,
match_id: null,
start_time: null
};
let lastServerSync = 0;
let cachedMatchInterval = null; // Cache the match interval configuration
const SYNC_INTERVAL = 30000; // Sync with server every 30 seconds
function initMatchTimer() {
// Get match interval configuration
apiRequest('GET', '/match-timer/config')
console.log('Initializing server-only match timer (no local countdown)...');
// Load match interval config once at initialization
loadMatchIntervalConfig().then(function(intervalSeconds) {
console.log('Match timer config loaded at initialization:', intervalSeconds, 'seconds');
// Initial sync with server
syncWithServerTimer();
// REMOVED: No periodic sync - rely on notifications
// REMOVED: No local countdown - rely on server updates only
}).catch(function(error) {
console.error('Failed to load match timer config at initialization:', error);
// Use default and continue
cachedMatchInterval = 20 * 60; // Default 20 minutes
// Initial sync with server
syncWithServerTimer();
});
}
function syncWithServerTimer() {
const now = Date.now();
apiRequest('GET', '/match-timer/state')
.then(function(data) {
if (data.success) {
// Update server state
serverTimerState = {
running: data.running || false,
remaining_seconds: data.remaining_seconds || 0,
total_seconds: data.total_seconds || 0,
fixture_id: data.fixture_id || null,
match_id: data.match_id || null,
start_time: data.start_time || null
};
lastServerSync = now;
console.log('Synced with server timer:', serverTimerState);
// Update display immediately
updateMatchTimerDisplay();
// No local countdown needed - server handles everything
console.log('Server timer state updated, display refreshed');
} else {
console.error('Failed to sync with server timer:', data);
}
})
.catch(function(error) {
console.error('Failed to sync with server timer:', error);
// Continue with local countdown if server is unavailable
});
}
function loadMatchIntervalConfig() {
// Only load config if we don't have it cached
if (cachedMatchInterval !== null) {
return Promise.resolve(cachedMatchInterval);
}
return apiRequest('GET', '/match-timer/config')
.then(function(data) {
if (data.success && data.match_interval) {
matchTimerSeconds = data.match_interval * 60; // Convert minutes to seconds
startMatchTimer();
cachedMatchInterval = data.match_interval * 60; // Convert minutes to seconds
console.log('Loaded match interval config:', cachedMatchInterval, 'seconds');
return cachedMatchInterval;
} else {
console.error('Failed to get match timer config:', data);
// Fallback to 20 minutes
matchTimerSeconds = 20 * 60;
startMatchTimer();
cachedMatchInterval = 20 * 60;
return cachedMatchInterval;
}
})
.catch(function(error) {
console.error('Failed to initialize match timer:', error);
console.error('Failed to load match timer config:', error);
// Fallback to 20 minutes
matchTimerSeconds = 20 * 60;
startMatchTimer();
cachedMatchInterval = 20 * 60;
return cachedMatchInterval;
});
}
function startMatchTimer() {
if (matchTimerInterval) {
function startLocalCountdown() {
// DISABLE local countdown - rely only on server updates
console.log('Local countdown disabled - using server-only updates');
if (matchTimerInterval && matchTimerInterval !== 'sync') {
clearInterval(matchTimerInterval);
}
matchTimerRunning = true;
// Only update display, no local counting
updateMatchTimerDisplay();
matchTimerInterval = setInterval(function() {
if (matchTimerSeconds > 0) {
matchTimerSeconds--;
updateMatchTimerDisplay();
} else {
// Timer reached 0, start next match
startNextMatch();
}
}, 1000);
}
function stopMatchTimer() {
matchTimerRunning = false;
if (matchTimerInterval) {
function stopLocalCountdown() {
if (matchTimerInterval && matchTimerInterval !== 'sync') {
clearInterval(matchTimerInterval);
matchTimerInterval = null;
}
}
function resetMatchTimer(seconds) {
matchTimerSeconds = seconds || (20 * 60); // Default to 20 minutes
if (!matchTimerRunning) {
startMatchTimer();
function updateMatchTimerDisplay() {
let displaySeconds = serverTimerState.remaining_seconds;
// Update status text based on timer state
const timerStatus = document.getElementById('timer-status');
if (timerStatus) {
if (serverTimerState.running) {
timerStatus.textContent = 'Timer running';
timerStatus.className = 'text-success';
} else {
timerStatus.textContent = 'Waiting for games to start...';
timerStatus.className = 'text-muted';
}
updateMatchTimerDisplay();
}
function updateMatchTimerDisplay() {
const minutes = Math.floor(matchTimerSeconds / 60);
const seconds = matchTimerSeconds % 60;
const timeString = minutes.toString().padStart(2, '0') + ':' + seconds.toString().padStart(2, '0');
// If server timer is not running, show configured interval
if (!serverTimerState.running) {
// Use cached config if available, otherwise load it
if (cachedMatchInterval !== null) {
updateTimerElements(cachedMatchInterval);
} else {
// Only load config if not cached (should happen at initialization)
// Don't load it here to avoid repeated API calls
updateTimerElements(20 * 60); // Use default 20 minutes
}
} else {
updateTimerElements(displaySeconds);
}
}
function updateTimerElements(seconds) {
const minutes = Math.floor(seconds / 60);
const remainingSeconds = seconds % 60;
const timeString = minutes.toString().padStart(2, '0') + ':' + remainingSeconds.toString().padStart(2, '0');
// Update status bar timer
const statusTimer = document.getElementById('match-timer');
if (statusTimer) {
statusTimer.textContent = timeString;
// Change color when timer is low
if (matchTimerSeconds <= 60) { // Last minute
// Change color based on time remaining
if (seconds <= 60) { // Last minute
statusTimer.className = 'badge bg-danger text-white';
} else if (matchTimerSeconds <= 300) { // Last 5 minutes
} else if (seconds <= 300) { // Last 5 minutes
statusTimer.className = 'badge bg-warning text-dark';
} else {
statusTimer.className = 'badge bg-warning text-dark';
statusTimer.className = 'badge bg-secondary text-white';
}
// Add pulse animation for last minute
if (seconds <= 60) {
statusTimer.style.animation = 'timerPulse 0.5s infinite';
} else {
statusTimer.style.animation = '';
}
}
......@@ -535,54 +629,76 @@ window.Dashboard = (function() {
const navbarTimer = document.getElementById('match-timer-display');
if (navbarTimer) {
navbarTimer.textContent = timeString;
navbarTimer.className = matchTimerSeconds <= 60 ? 'text-danger fw-bold' : 'text-warning fw-bold';
navbarTimer.className = seconds <= 60 ? 'text-danger fw-bold' : 'text-warning fw-bold';
}
// Update admin dashboard timer if present
const adminTimer = document.getElementById('admin-match-timer');
if (adminTimer) {
adminTimer.textContent = timeString;
adminTimer.className = seconds <= 60 ? 'text-danger fw-bold' : 'text-warning fw-bold';
}
}
function startNextMatch() {
console.log('Match timer reached 0, starting next match...');
function onServerTimerExpired() {
console.log('Server timer expired, match should be starting...');
apiRequest('POST', '/match-timer/start-match')
.then(function(data) {
if (data.success) {
console.log('Match started successfully:', data);
showNotification('Match ' + data.match_number + ' started successfully', 'success');
// Reset timer to configured interval
apiRequest('GET', '/match-timer/config')
.then(function(configData) {
if (configData.success && configData.match_interval) {
resetMatchTimer(configData.match_interval * 60);
} else {
resetMatchTimer(20 * 60); // Fallback
}
})
.catch(function(error) {
console.error('Failed to get timer config for reset:', error);
resetMatchTimer(20 * 60); // Fallback
// Show notification that match is starting
showNotification('Match timer expired - starting next match...', 'info');
// Reload match interval config when timer reaches 0 and needs reset
loadMatchIntervalConfig().then(function(intervalSeconds) {
console.log('Reloaded match interval config for reset:', intervalSeconds, 'seconds');
// Reset timer with the (possibly updated) configuration
serverTimerState.remaining_seconds = intervalSeconds;
serverTimerState.total_seconds = intervalSeconds;
// Sync with server to get updated state
setTimeout(function() {
syncWithServerTimer();
}, 2000); // Wait 2 seconds for server to process
});
} else {
console.error('Failed to start match:', data.error);
showNotification('Failed to start match: ' + (data.error || 'Unknown error'), 'error');
}
function onStartGameMessage() {
console.log('Received START_GAME message, initializing timer...');
// Stop timer if no matches are available
if (data.error && data.error.includes('No suitable fixture found')) {
stopMatchTimer();
// Load config and start timer when games start
loadMatchIntervalConfig().then(function(intervalSeconds) {
console.log('Loaded config for game start:', intervalSeconds, 'seconds');
// Set timer state for the first time
serverTimerState.running = true;
serverTimerState.remaining_seconds = intervalSeconds;
serverTimerState.total_seconds = intervalSeconds;
// Update display
updateMatchTimerDisplay();
showNotification('No matches available. Timer stopped.', 'info');
} else {
// Reset timer and try again later
resetMatchTimer(20 * 60);
startLocalCountdown();
showNotification('Games started - match timer is now running', 'success');
});
}
// Legacy functions for backward compatibility
function startMatchTimer() {
startServerTimer();
}
})
.catch(function(error) {
console.error('Failed to start next match:', error);
showNotification('Error starting match: ' + error.message, 'error');
// Reset timer and continue
resetMatchTimer(20 * 60);
});
function stopMatchTimer() {
stopServerTimer();
}
function resetMatchTimer(seconds) {
// This is now handled by the server
syncWithServerTimer();
}
function startNextMatch() {
// This is now handled by the server-side timer
console.log('startNextMatch called - now handled by server-side timer');
}
// Utility functions
......
mbetterclient/web_dashboard/templates/base.html
View file @ 126fa697
......@@ -365,13 +365,21 @@
case 'GAME_STATUS':
handleGameStatus(data, timestamp);
break;
case 'TIMER_UPDATE':
handleTimerUpdate(data, timestamp);
break;
case 'FIXTURE_STATUS_UPDATE':
handleFixtureStatusUpdate(data, timestamp);
break;
default:
console.log('Unknown notification type:', type);
}
// Show notification to user
// Show notification to user (except for timer and fixture status updates)
if (type !== 'TIMER_UPDATE' && type !== 'FIXTURE_STATUS_UPDATE') {
showNotificationToast(type, data);
}
}
function handleStartGame(data, timestamp) {
console.log('Handling START_GAME notification:', data);
......@@ -383,6 +391,11 @@
matchTimerElement.className = 'badge bg-success';
}
// Trigger timer initialization in Dashboard.js if available
if (typeof Dashboard !== 'undefined' && Dashboard.onStartGameMessage) {
Dashboard.onStartGameMessage();
}
// Trigger custom event for page-specific handling
const event = new CustomEvent('startGame', {
detail: { data, timestamp }
......@@ -400,6 +413,11 @@
matchTimerElement.className = 'badge bg-primary';
}
// Force sync with match timer component
if (typeof Dashboard !== 'undefined' && Dashboard.syncWithServerTimer) {
Dashboard.syncWithServerTimer();
}
// Trigger custom event for page-specific handling
const event = new CustomEvent('matchStart', {
detail: { data, timestamp }
......@@ -421,6 +439,13 @@
systemStatusElement.className = `badge bg-${getStatusColor(status)}`;
}
// If this is a timer-related status, sync with timer
if (status === 'started' && data.action === 'refresh') {
if (typeof Dashboard !== 'undefined' && Dashboard.syncWithServerTimer) {
Dashboard.syncWithServerTimer();
}
}
// Trigger custom event for page-specific handling
const event = new CustomEvent('gameStatus', {
detail: { data, timestamp }
......@@ -428,6 +453,112 @@
document.dispatchEvent(event);
}
function handleTimerUpdate(data, timestamp) {
console.log('Handling TIMER_UPDATE notification:', data);
// Update timer displays directly from server data ONLY
if (data.running !== undefined && data.remaining_seconds !== undefined) {
// Clear any existing client-side timers
if (window.clientTimerInterval) {
clearInterval(window.clientTimerInterval);
window.clientTimerInterval = null;
}
// Update all timer elements with server data
updateTimerElements(data.remaining_seconds, data.running);
// Store server data for potential interpolation
window.lastServerUpdate = {
remaining_seconds: data.remaining_seconds,
timestamp: Date.now(),
running: data.running
};
// Update timer status text
const timerStatus = document.getElementById('timer-status');
if (timerStatus) {
if (data.running) {
timerStatus.textContent = 'Timer running';
timerStatus.className = 'text-success';
} else {
timerStatus.textContent = 'Waiting for games to start...';
timerStatus.className = 'text-muted';
}
}
// Trigger custom event for page-specific handling
const event = new CustomEvent('timerUpdate', {
detail: { data, timestamp }
});
document.dispatchEvent(event);
}
}
function handleFixtureStatusUpdate(data, timestamp) {
console.log('Handling FIXTURE_STATUS_UPDATE notification:', data);
// Trigger automatic refresh if on fixtures page
const currentPage = window.location.pathname;
if (currentPage === '/fixtures' || currentPage.startsWith('/fixtures/')) {
// Check if loadFixtures function exists (fixtures page)
if (typeof loadFixtures === 'function') {
console.log('Auto-refreshing fixtures due to status update');
loadFixtures();
}
// Check if loadFixtureDetails function exists (fixture details page)
if (typeof loadFixtureDetails === 'function') {
console.log('Auto-refreshing fixture details due to status update');
loadFixtureDetails();
}
}
// Trigger custom event for page-specific handling
const event = new CustomEvent('fixtureStatusUpdate', {
detail: { data, timestamp }
});
document.dispatchEvent(event);
}
function updateTimerElements(seconds, isRunning) {
const minutes = Math.floor(seconds / 60);
const remainingSeconds = seconds % 60;
const timeString = minutes.toString().padStart(2, '0') + ':' + remainingSeconds.toString().padStart(2, '0');
console.log(`Updating timer elements: ${timeString} (${seconds}s, running: ${isRunning})`);
// Update status bar timer
const statusTimer = document.getElementById('match-timer');
if (statusTimer) {
statusTimer.textContent = timeString;
if (!isRunning) {
statusTimer.className = 'badge bg-warning text-dark';
statusTimer.style.animation = '';
} else if (seconds <= 60) { // Last minute
statusTimer.className = 'badge bg-danger text-white';
statusTimer.style.animation = 'timerPulse 0.5s infinite';
} else if (seconds <= 300) { // Last 5 minutes
statusTimer.className = 'badge bg-warning text-dark';
statusTimer.style.animation = '';
} else {
statusTimer.className = 'badge bg-success text-white';
statusTimer.style.animation = '';
}
}
// Update admin dashboard timer if present
const adminTimer = document.getElementById('admin-match-timer');
if (adminTimer) {
adminTimer.textContent = timeString;
if (isRunning) {
adminTimer.className = seconds <= 60 ? 'h3 mb-2 text-danger fw-bold' : 'h3 mb-2 text-success fw-bold';
} else {
adminTimer.className = 'h3 mb-2 text-muted';
}
}
}
function showNotificationToast(type, data) {
// Create and show a toast notification
const toastHtml = `
......
mbetterclient/web_dashboard/templates/dashboard/cashier.html
View file @ 126fa697
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Cashier Dashboard - {{ app_name }}</title>
<!-- CSS from CDN -->
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css">
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css">
<link rel="stylesheet" href="{{ url_for('static', filename='css/dashboard.css') }}">
<style>
.navbar-clock {
background: rgba(255, 255, 255, 0.1);
border: 2px solid rgba(255, 255, 255, 0.3);
border-radius: 8px;
padding: 8px 16px;
font-family: 'Courier New', monospace;
font-weight: bold;
font-size: 1.2rem;
color: #ffffff;
text-shadow: 1px 1px 2px rgba(0, 0, 0, 0.5);
box-shadow: 0 2px 4px rgba(0, 0, 0, 0.2);
transition: all 0.3s ease;
}
.navbar-clock:hover {
background: rgba(255, 255, 255, 0.2);
border-color: rgba(255, 255, 255, 0.5);
transform: translateY(-1px);
box-shadow: 0 4px 8px rgba(0, 0, 0, 0.3);
}
.navbar-clock i {
color: #ffffff;
filter: drop-shadow(1px 1px 1px rgba(0, 0, 0, 0.5));
}
#clock-time {
font-size: 1.3rem;
letter-spacing: 2px;
}
/* Responsive adjustments */
@media (max-width: 768px) {
.navbar-clock {
font-size: 1rem;
padding: 6px 12px;
}
#clock-time {
font-size: 1.1rem;
letter-spacing: 1px;
}
}
</style>
</head>
<body>
<!-- Simplified Navigation Bar for Cashier -->
<nav class="navbar navbar-expand-lg navbar-dark bg-primary">
<div class="container-fluid">
<a class="navbar-brand" href="#">
<i class="fas fa-cash-register me-2"></i>{{ app_name }} - Cashier
</a>
<ul class="navbar-nav ms-auto">
<!-- Digital Clock -->
<li class="nav-item d-flex align-items-center me-3">
<div id="digital-clock" class="navbar-clock">
<i class="fas fa-clock me-2"></i>
<span id="clock-time">--:--:--</span>
</div>
</li>
<!-- Match Timer -->
<li class="nav-item d-flex align-items-center me-3">
<div id="match-timer-navbar" class="navbar-timer">
<i class="fas fa-stopwatch me-2"></i>
<span id="match-timer-display">--:--</span>
</div>
</li>
<li class="nav-item">
<a class="nav-link" href="{{ url_for('auth.logout') }}">
<i class="fas fa-sign-out-alt me-1"></i>Logout
</a>
</li>
</ul>
</div>
</nav>
<main class="container-fluid mt-4">
{% with messages = get_flashed_messages(with_categories=true) %}
{% if messages %}
{% for category, message in messages %}
<div class="alert alert-{{ 'danger' if category == 'error' else category }} alert-dismissible fade show" role="alert">
{% if category == 'error' %}
<i class="fas fa-exclamation-triangle me-2"></i>
{% elif category == 'success' %}
<i class="fas fa-check-circle me-2"></i>
{% elif category == 'info' %}
<i class="fas fa-info-circle me-2"></i>
{% endif %}
{{ message }}
<button type="button" class="btn-close" data-bs-dismiss="alert"></button>
</div>
{% endfor %}
{% endif %}
{% endwith %}
{% extends "base.html" %}
<div class="row">
{% block content %}
<div class="row">
<div class="col-12">
<h1 class="mb-4">
<i class="fas fa-cash-register me-2"></i>Cashier Dashboard
<small class="text-muted">Welcome, {{ current_user.username }}</small>
</h1>
</div>
</div>
</div>
<!-- Quick Actions for Cashier -->
<div class="row mb-4">
<!-- Quick Actions for Cashier -->
<div class="row mb-4">
<div class="col-12">
<div class="card">
<div class="card-header">
......@@ -142,14 +36,19 @@
<i class="fas fa-edit me-2"></i>Update Display Overlay
</button>
</div>
<div class="col-md-4 mb-3">
<button class="btn btn-outline-info w-100" id="btn-refresh-matches">
<i class="fas fa-sync-alt me-2"></i>Refresh Matches
</button>
</div>
</div>
</div>
</div>
</div>
</div>
<!-- Main Content Layout -->
<div class="row">
<!-- Main Content Layout -->
<div class="row">
<!-- Pending Matches from First Fixture - Left Side -->
<div class="col-lg-9 col-md-8">
<div class="card mb-4">
......@@ -212,9 +111,6 @@
</div>
</div>
<!-- Betting Mode Configuration - Hidden for Cashier Users -->
<!-- This feature is only available to admin users -->
<!-- Session Information -->
<div class="card mb-4">
<div class="card-header">
......@@ -264,11 +160,10 @@
</div>
</div>
</div>
</div>
</main>
</div>
<!-- Video Control Modal -->
<div class="modal fade" id="playVideoModal" tabindex="-1">
<!-- Video Control Modal -->
<div class="modal fade" id="playVideoModal" tabindex="-1">
<div class="modal-dialog">
<div class="modal-content">
<div class="modal-header">
......@@ -300,10 +195,10 @@
</div>
</div>
</div>
</div>
</div>
<!-- Overlay Update Modal -->
<div class="modal fade" id="updateOverlayModal" tabindex="-1">
<!-- Overlay Update Modal -->
<div class="modal fade" id="updateOverlayModal" tabindex="-1">
<div class="modal-dialog">
<div class="modal-content">
<div class="modal-header">
......@@ -340,309 +235,18 @@
</div>
</div>
</div>
</div>
<!-- System Status Bar -->
<div id="status-bar" class="fixed-bottom bg-light border-top p-2 d-none d-lg-block">
<div class="container-fluid">
<div class="row align-items-center text-small">
<div class="col-auto">
<span class="text-muted">Status:</span>
<span id="system-status" class="badge bg-success">Online</span>
</div>
<div class="col-auto">
<span class="text-muted">Video:</span>
<span id="video-status" class="badge bg-secondary">Stopped</span>
</div>
<div class="col-auto">
<span class="text-muted">Last Updated:</span>
<span id="last-updated" class="text-muted">--</span>
</div>
<div class="col text-end">
<small class="text-muted">{{ app_name }} v{{ app_version }}</small>
</div>
</div>
</div>
</div>
<!-- JavaScript from CDN and local -->
<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
<script src="{{ url_for('static', filename='js/dashboard.js') }}"></script>
</div>
{% endblock %}
<script id="dashboard-config" type="application/json">
{
"statusUpdateInterval": 30000,
"apiEndpoint": "/api",
"user": {
"id": {{ current_user.id | tojson }},
"username": {{ current_user.username | tojson }},
"is_admin": {{ current_user.is_admin | tojson }}
}
}
</script>
<script>
// Initialize dashboard
document.addEventListener('DOMContentLoaded', function() {
if (typeof Dashboard !== 'undefined') {
var config = JSON.parse(document.getElementById('dashboard-config').textContent);
Dashboard.init(config);
}
// Initialize digital clock
initializeClock();
// Initialize long polling for notifications
initializeNotifications();
{% block scripts %}
<script>
document.addEventListener('DOMContentLoaded', function() {
// Load available templates on page load
loadAvailableTemplates();
// Load pending matches for cashier dashboard
loadPendingMatches();
// Betting mode functionality removed for cashier users
});
function initializeClock() {
const clockElement = document.getElementById('clock-time');
if (!clockElement) return;
let serverTimeOffset = 0; // Offset between server and client time
let lastServerTime = null;
function fetchServerTime() {
return fetch('/api/server-time')
.then(response => response.json())
.then(data => {
if (data.success) {
const serverTimestamp = data.timestamp;
const clientTimestamp = Date.now();
serverTimeOffset = serverTimestamp - clientTimestamp;
lastServerTime = serverTimestamp;
return serverTimestamp;
} else {
throw new Error('Failed to get server time');
}
})
.catch(error => {
console.error('Error fetching server time:', error);
// Fallback to client time if server time is unavailable
return Date.now();
});
}
function updateClock() {
const now = Date.now() + serverTimeOffset;
const date = new Date(now);
const hours = String(date.getHours()).padStart(2, '0');
const minutes = String(date.getMinutes()).padStart(2, '0');
const seconds = String(date.getSeconds()).padStart(2, '0');
const timeString = `${hours}:${minutes}:${seconds}`;
clockElement.textContent = timeString;
}
// Fetch server time initially and set up updates
fetchServerTime().then(() => {
// Update immediately with server time
updateClock();
// Update display every second (using client time + offset)
setInterval(updateClock, 1000);
// Sync with server time every 30 seconds
setInterval(fetchServerTime, 30000);
});
}
// Function to load and display pending matches
function loadPendingMatches() {
fetch('/api/cashier/pending-matches')
.then(response => response.json())
.then(data => {
const container = document.getElementById('pending-matches-container');
const countBadge = document.getElementById('pending-matches-count');
if (data.success) {
// Update count badge
countBadge.textContent = data.total;
countBadge.className = data.total > 0 ? 'badge bg-warning ms-2' : 'badge bg-success ms-2';
if (data.total === 0) {
container.innerHTML = `
<div class="text-center text-muted">
<i class="fas fa-check-circle me-2"></i>No pending matches found
</div>
`;
} else {
// Create matches table
let tableHtml = `
<div class="table-responsive">
<table class="table table-striped table-hover">
<thead class="table-dark">
<tr>
<th><i class="fas fa-hashtag me-1"></i>Match #</th>
<th><i class="fas fa-user-friends me-1"></i>Fighter 1</th>
<th><i class="fas fa-user-friends me-1"></i>Fighter 2</th>
<th><i class="fas fa-map-marker-alt me-1"></i>Venue</th>
<th><i class="fas fa-clock me-1"></i>Start Time</th>
<th><i class="fas fa-info-circle me-1"></i>Status</th>
</tr>
</thead>
<tbody>
`;
data.matches.forEach(match => {
const startTime = match.start_time ?
new Date(match.start_time).toLocaleString() : 'Not scheduled';
// Get status from the match object (new status column)
const status = match.status || 'pending';
let statusBadge = '';
switch (status) {
case 'scheduled':
statusBadge = '<span class="badge bg-primary"><i class="fas fa-calendar-check me-1"></i>Scheduled</span>';
break;
case 'ingame':
statusBadge = '<span class="badge bg-info"><i class="fas fa-play me-1"></i>In Game</span>';
break;
case 'completed':
statusBadge = '<span class="badge bg-success"><i class="fas fa-check me-1"></i>Completed</span>';
break;
case 'cancelled':
statusBadge = '<span class="badge bg-secondary"><i class="fas fa-times me-1"></i>Cancelled</span>';
break;
case 'failed':
statusBadge = '<span class="badge bg-danger"><i class="fas fa-exclamation-triangle me-1"></i>Failed</span>';
break;
case 'paused':
statusBadge = '<span class="badge bg-warning"><i class="fas fa-pause me-1"></i>Paused</span>';
break;
default:
statusBadge = '<span class="badge bg-warning"><i class="fas fa-clock me-1"></i>Pending</span>';
}
tableHtml += `
<tr>
<td><strong>${match.match_number}</strong></td>
<td>${match.fighter1_township}</td>
<td>${match.fighter2_township}</td>
<td>${match.venue_kampala_township}</td>
<td>${startTime}</td>
<td>${statusBadge}</td>
</tr>
`;
});
tableHtml += `
</tbody>
</table>
</div>
`;
container.innerHTML = tableHtml;
}
} else {
container.innerHTML = `
<div class="text-center text-danger">
<i class="fas fa-exclamation-triangle me-2"></i>Error loading matches: ${data.error || 'Unknown error'}
</div>
`;
}
})
.catch(error => {
const container = document.getElementById('pending-matches-container');
container.innerHTML = `
<div class="text-center text-danger">
<i class="fas fa-exclamation-triangle me-2"></i>Error loading matches: ${error.message}
</div>
`;
});
}
// Add event listeners for real-time notifications
document.addEventListener('startGame', function(event) {
console.log('Cashier dashboard: Received startGame event', event.detail);
// Update match timer display
const matchTimerElement = document.getElementById('match-timer-display');
if (matchTimerElement) {
matchTimerElement.textContent = 'Starting...';
}
// Refresh pending matches to show updated status
loadPendingMatches();
// Show notification to cashier
showNotification('Games are starting! Match timer activated.', 'success');
});
document.addEventListener('matchStart', function(event) {
console.log('Cashier dashboard: Received matchStart event', event.detail);
// Reset and start the match timer
const matchTimerElement = document.getElementById('match-timer-display');
if (matchTimerElement) {
matchTimerElement.textContent = '00:00';
// Start counting up from 00:00
startMatchTimer();
}
// Refresh pending matches to show updated status
loadPendingMatches();
// Show notification to cashier
showNotification('Match started! Timer is now running.', 'info');
});
document.addEventListener('gameStatus', function(event) {
console.log('Cashier dashboard: Received gameStatus event', event.detail);
// Refresh pending matches to show updated status
loadPendingMatches();
// Update system status if present
const systemStatusElement = document.getElementById('system-status');
if (systemStatusElement && event.detail.data.status) {
systemStatusElement.textContent = event.detail.data.status;
systemStatusElement.className = `badge bg-${getStatusColor(event.detail.data.status)}`;
}
});
function startMatchTimer() {
let seconds = 0;
const matchTimerElement = document.getElementById('match-timer-display');
if (!matchTimerElement) return;
const timer = setInterval(() => {
seconds++;
const minutes = Math.floor(seconds / 60);
const remainingSeconds = seconds % 60;
const timeString = `${minutes.toString().padStart(2, '0')}:${remainingSeconds.toString().padStart(2, '0')}`;
matchTimerElement.textContent = timeString;
}, 1000);
// Store timer reference for cleanup if needed
matchTimerElement.dataset.timerId = timer;
}
function getStatusColor(status) {
switch (status) {
case 'running': return 'success';
case 'scheduled': return 'warning';
case 'pending': return 'secondary';
case 'completed': return 'info';
case 'error': return 'danger';
default: return 'secondary';
}
}
</script>
<script>
document.addEventListener('DOMContentLoaded', function() {
// Load available templates on page load
loadAvailableTemplates();
// Quick action buttons
document.getElementById('btn-start-games').addEventListener('click', function() {
// Show confirmation dialog for starting games
......@@ -659,17 +263,16 @@
.then(response => response.json())
.then(data => {
if (data.success) {
alert('Games started successfully!');
// Refresh the pending matches list
loadPendingMatches();
// Show success message
showNotification('Games started successfully!', 'success');
} else {
alert('Failed to start games: ' + (data.error || 'Unknown error'));
showNotification('Failed to start games: ' + (data.error || 'Unknown error'), 'error');
}
})
.catch(error => {
alert('Error starting games: ' + error.message);
showNotification('Error starting games: ' + error.message, 'error');
});
}
});
......@@ -682,6 +285,11 @@
new bootstrap.Modal(document.getElementById('updateOverlayModal')).show();
});
document.getElementById('btn-refresh-matches').addEventListener('click', function() {
console.log('🔄 Manual refresh button clicked');
loadPendingMatches();
});
// Confirm actions
document.getElementById('confirm-play-video').addEventListener('click', function() {
const filePath = document.getElementById('video-file-path').value;
......@@ -811,10 +419,216 @@
updateVideoStatus();
// Periodic status updates
setInterval(updateVideoStatus, 10000); // Every 10 seconds
setInterval(updateVideoStatus, 5000); // Every 5 seconds
setInterval(loadPendingMatches, 5000); // Auto-refresh matches every 5 seconds
});
let cachedMatchesData = null;
let isInitialMatchLoad = true;
// Function to load and display pending matches
function loadPendingMatches() {
console.log('🔍 loadPendingMatches() called');
const container = document.getElementById('pending-matches-container');
const countBadge = document.getElementById('pending-matches-count');
if (!container) {
console.error('❌ pending-matches-container not found');
return;
}
console.log('📡 Making API request to /api/cashier/pending-matches');
// Only show loading state on initial load
if (isInitialMatchLoad) {
container.innerHTML = `
<div class="text-center text-muted">
<i class="fas fa-spinner fa-spin me-2"></i>Loading pending matches...
</div>
`;
}
fetch('/api/cashier/pending-matches')
.then(response => {
console.log('📡 API response status:', response.status);
if (!response.ok) {
throw new Error('API request failed: ' + response.status);
}
return response.json();
})
.then(data => {
console.log('📦 API response data:', data);
if (data.success) {
// Check if data has actually changed
const currentDataString = JSON.stringify(data);
if (cachedMatchesData === currentDataString && !isInitialMatchLoad) {
console.log('📦 No changes in match data, skipping update');
return;
}
cachedMatchesData = currentDataString;
// Update count badge
countBadge.textContent = data.total;
countBadge.className = data.total > 0 ? 'badge bg-warning ms-2' : 'badge bg-success ms-2';
updateMatchesTable(data, container);
} else {
if (isInitialMatchLoad) {
container.innerHTML = `
<div class="text-center text-danger">
<i class="fas fa-exclamation-triangle me-2"></i>Error loading matches: ${data.error || 'Unknown error'}
</div>
`;
}
}
})
.catch(error => {
console.error('❌ Error loading matches:', error);
if (isInitialMatchLoad) {
container.innerHTML = `
<div class="text-center text-danger">
<i class="fas fa-exclamation-triangle me-2"></i>Error loading matches: ${error.message}
</div>
`;
}
})
.finally(() => {
isInitialMatchLoad = false;
});
}
function updateMatchesTable(data, container) {
if (data.total === 0) {
container.innerHTML = `
<div class="text-center text-muted">
<i class="fas fa-check-circle me-2"></i>No pending matches found
</div>
`;
return;
}
// Check if table already exists
let tbody = container.querySelector('tbody');
function loadAvailableTemplates() {
if (!tbody) {
// Create new table
container.innerHTML = `
<div class="table-responsive">
<table class="table table-striped table-hover">
<thead class="table-dark">
<tr>
<th><i class="fas fa-hashtag me-1"></i>Match #</th>
<th><i class="fas fa-user-friends me-1"></i>Fighter 1</th>
<th><i class="fas fa-user-friends me-1"></i>Fighter 2</th>
<th><i class="fas fa-map-marker-alt me-1"></i>Venue</th>
<th><i class="fas fa-clock me-1"></i>Start Time</th>
<th><i class="fas fa-info-circle me-1"></i>Status</th>
</tr>
</thead>
<tbody>
</tbody>
</table>
</div>
`;
tbody = container.querySelector('tbody');
}
// Update table rows intelligently
const existingRows = Array.from(tbody.children);
const existingMatches = new Map();
existingRows.forEach(row => {
const matchNumber = row.getAttribute('data-match-number');
if (matchNumber) {
existingMatches.set(matchNumber, row);
}
});
const processedMatches = new Set();
data.matches.forEach(match => {
const matchNumber = match.match_number.toString();
processedMatches.add(matchNumber);
const startTime = match.start_time ?
new Date(match.start_time).toLocaleString() : 'Not scheduled';
const status = match.status || 'pending';
let statusBadge = '';
switch (status) {
case 'scheduled':
statusBadge = '<span class="badge bg-primary"><i class="fas fa-calendar-check me-1"></i>Scheduled</span>';
break;
case 'bet':
statusBadge = '<span class="badge bg-success"><i class="fas fa-dollar-sign me-1"></i>Bet</span>';
break;
case 'ingame':
statusBadge = '<span class="badge bg-info"><i class="fas fa-play me-1"></i>In Game</span>';
break;
case 'completed':
statusBadge = '<span class="badge bg-success"><i class="fas fa-check me-1"></i>Completed</span>';
break;
case 'cancelled':
statusBadge = '<span class="badge bg-secondary"><i class="fas fa-times me-1"></i>Cancelled</span>';
break;
case 'failed':
statusBadge = '<span class="badge bg-danger"><i class="fas fa-exclamation-triangle me-1"></i>Failed</span>';
break;
case 'paused':
statusBadge = '<span class="badge bg-warning"><i class="fas fa-pause me-1"></i>Paused</span>';
break;
default:
statusBadge = '<span class="badge bg-warning"><i class="fas fa-clock me-1"></i>Pending</span>';
}
const newRowHTML = `
<td><strong>${match.match_number}</strong></td>
<td>${match.fighter1_township}</td>
<td>${match.fighter2_township}</td>
<td>${match.venue_kampala_township}</td>
<td>${startTime}</td>
<td>${statusBadge}</td>
`;
const existingRow = existingMatches.get(matchNumber);
if (existingRow) {
// Update existing row only if content changed
if (existingRow.innerHTML !== newRowHTML) {
existingRow.innerHTML = newRowHTML;
existingRow.style.backgroundColor = '#fff3cd'; // Highlight briefly
setTimeout(() => {
existingRow.style.backgroundColor = '';
}, 1000);
}
} else {
// Add new row
const row = document.createElement('tr');
row.setAttribute('data-match-number', matchNumber);
row.innerHTML = newRowHTML;
row.style.backgroundColor = '#d4edda'; // Highlight new row
tbody.appendChild(row);
setTimeout(() => {
row.style.backgroundColor = '';
}, 1000);
}
});
// Remove rows no longer in data
existingMatches.forEach((row, matchNumber) => {
if (!processedMatches.has(matchNumber)) {
row.style.backgroundColor = '#f8d7da'; // Highlight removed row
setTimeout(() => {
if (row.parentNode) {
row.parentNode.removeChild(row);
}
}, 500);
}
});
}
function loadAvailableTemplates() {
fetch('/api/templates')
.then(response => response.json())
.then(data => {
......@@ -872,9 +686,31 @@
videoTemplateSelect.innerHTML = '<option value="default">Default</option>';
overlayTemplateSelect.innerHTML = '<option value="default">Default</option>';
});
}
</script>
<!-- Include the main dashboard.js for timer functionality -->
<script src="{{ url_for('static', filename='js/dashboard.js') }}"></script>
<script>
// Initialize dashboard with timer functionality
document.addEventListener('DOMContentLoaded', function() {
// Initialize Dashboard with timer support
if (typeof Dashboard !== 'undefined') {
Dashboard.init({
user: {
username: '{{ current_user.username }}',
role: 'cashier'
}
});
}
// Betting mode functions removed - not available for cashier users
</script>
</body>
</html>
\ No newline at end of file
// Hook into the start games button to trigger timer notifications
const startGamesBtn = document.getElementById('btn-start-games');
if (startGamesBtn) {
startGamesBtn.addEventListener('click', function() {
// The existing START_GAME logic will trigger the timer
// Dashboard.js will automatically sync with the server timer
});
}
});
</script>
{% endblock %}
mbetterclient/web_dashboard/templates/dashboard/config.html
View file @ 126fa697
......@@ -215,6 +215,27 @@
</div>
</div>
<!-- Betting Mode Settings -->
<div class="card mb-4">
<div class="card-header">
<h5>Betting Mode Settings</h5>
</div>
<div class="card-body">
<form id="betting-mode-config-form">
<div class="mb-3">
<label for="betting-mode" class="form-label">Betting Mode</label>
<select class="form-select" id="betting-mode">
<option value="all_bets_on_start">All Bets on Start - Place all bets when games begin</option>
<option value="one_bet_at_a_time">One Bet at a Time - Place bets individually</option>
</select>
<div class="form-text">Choose how bets are placed during games</div>
</div>
<button type="submit" class="btn btn-primary">Save Betting Mode</button>
</form>
<div id="betting-mode-status" class="mt-3"></div>
</div>
</div>
<!-- API Client Debug Section -->
<div class="card">
<div class="card-header">
......@@ -456,5 +477,74 @@
this.textContent = 'Trigger Manual Request';
});
});
// Load current betting mode on page load
document.addEventListener('DOMContentLoaded', function() {
loadBettingMode();
});
// Load betting mode configuration
function loadBettingMode() {
fetch('/api/betting-mode')
.then(response => response.json())
.then(data => {
if (data.success) {
document.getElementById('betting-mode').value = data.betting_mode || 'all_bets_on_start';
if (data.is_default) {
document.getElementById('betting-mode-status').innerHTML =
'<div class="alert alert-info"><small>Using default betting mode</small></div>';
}
} else {
console.error('Failed to load betting mode:', data.error);
document.getElementById('betting-mode-status').innerHTML =
'<div class="alert alert-warning"><small>Could not load current betting mode</small></div>';
}
})
.catch(error => {
console.error('Error loading betting mode:', error);
document.getElementById('betting-mode-status').innerHTML =
'<div class="alert alert-warning"><small>Error loading betting mode</small></div>';
});
}
// Save betting mode configuration
document.getElementById('betting-mode-config-form').addEventListener('submit', function(e) {
e.preventDefault();
const bettingMode = document.getElementById('betting-mode').value;
const statusDiv = document.getElementById('betting-mode-status');
// Clear previous status
statusDiv.innerHTML = '';
// Save betting mode
fetch('/api/betting-mode', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify({
betting_mode: bettingMode
})
})
.then(response => response.json())
.then(data => {
if (data.success) {
statusDiv.innerHTML = '<div class="alert alert-success">Betting mode saved successfully: ' + data.message + '</div>';
// Auto-hide success message after 3 seconds
setTimeout(() => {
statusDiv.innerHTML = '';
}, 3000);
} else {
statusDiv.innerHTML = '<div class="alert alert-danger">Failed to save betting mode: ' + data.error + '</div>';
}
})
.catch(error => {
console.error('Error saving betting mode:', error);
statusDiv.innerHTML = '<div class="alert alert-danger">Error saving betting mode: ' + error.message + '</div>';
});
});
</script>
{% endblock %}
\ No newline at end of file
mbetterclient/web_dashboard/templates/dashboard/extraction.html
View file @ 126fa697
{% extends "base.html" %}
{% block title %}{{ page_title }}{% endblock %}
{% block content %}
<div class="container-fluid">
<div class="row">
<div class="row">
<div class="col-12">
<div class="d-flex justify-content-between align-items-center mb-3">
<div>
<h1><i class="fas fa-cogs me-2"></i>Extraction Management</h1>
<p class="mb-0">Configure outcome associations for extraction results and manage game settings.</p>
</div>
<div>
<button type="button" class="btn btn-primary" id="save-associations-btn">
<i class="fas fa-save me-1"></i>Save Associations
</button>
</div>
<h1 class="mb-4">
<i class="fas fa-cogs me-2"></i>Extraction Management
<small class="text-muted">Configure outcome associations and time limits</small>
</h1>
</div>
</div>
<!-- Game Configuration -->
<div class="card mb-4">
<!-- UNDER/OVER Configuration -->
<div class="row mb-4">
<div class="col-12">
<div class="card">
<div class="card-header">
<h5><i class="fas fa-cogs me-2"></i>Game Configuration</h5>
<h5 class="card-title mb-0">
<i class="fas fa-clock me-2"></i>UNDER/OVER Time Configuration
</h5>
</div>
<div class="card-body">
<div class="row">
<div class="col-md-6">
<label for="time-limit-input" class="form-label">Time Limit Between UNDER and OVER (seconds)</label>
<div class="input-group">
<input type="number" class="form-control" id="time-limit-input" min="1" max="300" value="90">
<button class="btn btn-outline-primary" type="button" id="update-time-limit-btn">
<i class="fas fa-save me-1"></i>Update
<span class="input-group-text">
<i class="fas fa-stopwatch me-2"></i>Time Limit
</span>
<input type="number" class="form-control" id="under-over-time-limit"
placeholder="90" min="1" max="300" step="1" value="90">
<span class="input-group-text">seconds</span>
<button class="btn btn-outline-primary" id="btn-save-time-limit">
<i class="fas fa-save me-1"></i>Save
</button>
</div>
<small class="form-text text-muted">Default: 90 seconds. Range: 1-300 seconds.</small>
<small class="text-muted mt-1 d-block">
Time limit between UNDER and OVER outcomes (1-300 seconds)
</small>
</div>
<div class="col-md-6">
<label for="cap-input" class="form-label">CAP of Redistributed Bets (%)</label>
<div class="input-group">
<input type="number" class="form-control" id="cap-input" min="20" max="90" step="1" value="70">
<button class="btn btn-outline-primary" type="button" id="update-cap-btn">
<i class="fas fa-save me-1"></i>Update
</button>
</div>
<small class="form-text text-muted">Default: 70%. Range: 20-90%.</small>
</div>
</div>
<div class="row mt-3">
<div class="col-12">
<div class="alert alert-info">
<i class="fas fa-info-circle me-2"></i>
<strong>UNDER/OVER Outcomes:</strong> These outcomes appear separately above the main extraction area and are not included in the drag-and-drop associations below.
<strong>UNDER/OVER Outcomes:</strong> These outcomes appear above the main extraction area
and have a configurable time limit between them.
</div>
</div>
</div>
</div>
</div>
<!-- UNDER/OVER Outcomes Display -->
<div class="card mb-4">
<div class="card-header">
<h5><i class="fas fa-layer-group me-2"></i>UNDER/OVER Outcomes</h5>
</div>
<div class="card-body">
<div class="row">
<div class="col-md-6">
<div class="outcome-item under-over-item" data-outcome="UNDER">
<span class="badge bg-warning fs-6 p-2">UNDER</span>
</div>
</div>
<div class="col-md-6">
<div class="outcome-item under-over-item" data-outcome="OVER">
<span class="badge bg-warning fs-6 p-2">OVER</span>
</div>
</div>
</div>
</div>
</div>
</div>
<!-- Extraction Layout -->
<div class="row">
<!-- Extraction Results Layout -->
<div class="row">
<!-- Available Outcomes Pool -->
<div class="col-md-4">
<div class="card h-100">
<div class="card-header d-flex justify-content-between align-items-center">
<h5><i class="fas fa-list me-2"></i>Available Outcomes</h5>
<span class="badge bg-secondary" id="available-count">0</span>
<div class="card">
<div class="card-header">
<h5 class="card-title mb-0">
<i class="fas fa-list me-2"></i>Available Outcomes
</h5>
</div>
<div class="card-body">
<div id="available-outcomes" class="outcomes-container">
<!-- Available outcomes will be loaded here -->
<div id="outcomes-pool" class="extraction-pool">
<!-- Outcomes will be loaded here -->
<div class="text-center text-muted">
<i class="fas fa-spinner fa-spin me-2"></i>Loading outcomes...
</div>
</div>
<small class="text-muted">Outcomes not associated with all 3 results</small>
</div>
</div>
</div>
......@@ -101,15 +76,17 @@
<div class="row">
<!-- WIN1 Column -->
<div class="col-md-4 mb-3">
<div class="card h-100">
<div class="card-header text-center bg-primary text-white">
<h5 class="mb-0">
<div class="card">
<div class="card-header bg-primary text-white">
<h6 class="card-title mb-0">
<i class="fas fa-trophy me-2"></i>WIN1
</h5>
</h6>
</div>
<div class="card-body">
<div id="win1-column" class="extraction-column outcomes-container" data-result="WIN1">
<!-- WIN1 associated outcomes will be loaded here -->
<div id="win1-column" class="extraction-column" data-result="WIN1">
<div class="text-center text-muted">
<small>Drop outcomes here</small>
</div>
</div>
</div>
</div>
......@@ -117,15 +94,17 @@
<!-- X Column -->
<div class="col-md-4 mb-3">
<div class="card h-100">
<div class="card-header text-center bg-info text-white">
<h5 class="mb-0">
<i class="fas fa-balance-scale me-2"></i>X
</h5>
<div class="card">
<div class="card-header bg-secondary text-white">
<h6 class="card-title mb-0">
<i class="fas fa-equals me-2"></i>X
</h6>
</div>
<div class="card-body">
<div id="x-column" class="extraction-column outcomes-container" data-result="X">
<!-- X associated outcomes will be loaded here -->
<div id="x-column" class="extraction-column" data-result="X">
<div class="text-center text-muted">
<small>Drop outcomes here</small>
</div>
</div>
</div>
</div>
......@@ -133,15 +112,17 @@
<!-- WIN2 Column -->
<div class="col-md-4 mb-3">
<div class="card h-100">
<div class="card-header text-center bg-success text-white">
<h5 class="mb-0">
<i class="fas fa-medal me-2"></i>WIN2
</h5>
<div class="card">
<div class="card-header bg-success text-white">
<h6 class="card-title mb-0">
<i class="fas fa-trophy me-2"></i>WIN2
</h6>
</div>
<div class="card-body">
<div id="win2-column" class="extraction-column outcomes-container" data-result="WIN2">
<!-- WIN2 associated outcomes will be loaded here -->
<div id="win2-column" class="extraction-column" data-result="WIN2">
<div class="text-center text-muted">
<small>Drop outcomes here</small>
</div>
</div>
</div>
</div>
......@@ -149,13 +130,14 @@
</div>
<!-- Trash Bin -->
<div class="row mt-3">
<div class="row">
<div class="col-12">
<div class="card">
<div class="card-body text-center">
<div id="trash-bin" class="trash-bin outcomes-container">
<div id="trash-bin" class="trash-bin">
<i class="fas fa-trash-alt fa-2x text-danger"></i>
<p class="mb-0 mt-2">Drop outcomes here to remove associations</p>
<div class="mt-2">
<strong>Drop to Remove Association</strong>
</div>
</div>
</div>
......@@ -163,102 +145,68 @@
</div>
</div>
</div>
</div>
<!-- Statistics -->
<div class="row mt-4">
<div class="col-md-3">
<div class="card text-center">
<div class="card-body">
<h5 class="card-title text-primary">
<i class="fas fa-list me-2"></i>Total Outcomes
</h5>
<h3 id="total-outcomes" class="text-primary">0</h3>
</div>
</div>
</div>
<div class="col-md-3">
<div class="card text-center">
<div class="card-body">
<h5 class="card-title text-info">
<i class="fas fa-link me-2"></i>Associated
</h5>
<h3 id="associated-outcomes" class="text-info">0</h3>
</div>
</div>
</div>
<div class="col-md-3">
<div class="card text-center">
<div class="card-body">
<h5 class="card-title text-warning">
<i class="fas fa-clock me-2"></i>Available
<!-- Current Associations Display -->
<div class="row mt-4">
<div class="col-12">
<div class="card">
<div class="card-header">
<h5 class="card-title mb-0">
<i class="fas fa-link me-2"></i>Current Associations
</h5>
<h3 id="available-outcomes-count" class="text-warning">0</h3>
</div>
</div>
</div>
<div class="col-md-3">
<div class="card text-center">
<div class="card-body">
<h5 class="card-title text-success">
<i class="fas fa-save me-2"></i>Last Saved
</h5>
<h6 id="last-saved" class="text-success">--</h6>
</div>
<div id="associations-display">
<div class="text-center text-muted">
<i class="fas fa-spinner fa-spin me-2"></i>Loading associations...
</div>
</div>
</div>
</div>
</div>
</div>
{% endblock %}
{% block scripts %}
<style>
.outcomes-container {
.extraction-pool, .extraction-column {
min-height: 200px;
border: 2px dashed #dee2e6;
border-radius: 0.375rem;
padding: 1rem;
background-color: #f8f9fa;
transition: all 0.3s ease;
}
.outcomes-container:hover {
border-color: #adb5bd;
background-color: #e9ecef;
}
.outcome-item {
.extraction-outcome {
display: inline-block;
background-color: #ffffff;
border: 1px solid #dee2e6;
border-radius: 0.25rem;
padding: 0.5rem 0.75rem;
margin: 0.25rem;
cursor: move;
user-select: none;
transition: all 0.2s ease;
}
.outcome-item:hover {
transform: translateY(-2px);
box-shadow: 0 4px 8px rgba(0,0,0,0.1);
.extraction-outcome:hover {
background-color: #e9ecef;
border-color: #adb5bd;
box-shadow: 0 0.125rem 0.25rem rgba(0, 0, 0, 0.075);
}
.outcome-item.dragging {
.extraction-outcome.dragging {
opacity: 0.5;
transform: rotate(5deg);
}
.extraction-column {
min-height: 300px;
}
.extraction-column .outcome-item {
display: block;
margin-bottom: 0.5rem;
}
.trash-bin {
border: 2px dashed #dc3545;
border-radius: 0.5rem;
border-radius: 0.375rem;
padding: 2rem;
background-color: #f8d7da;
transition: all 0.3s ease;
transition: all 0.2s ease;
}
.trash-bin:hover {
......@@ -266,403 +214,364 @@
border-color: #c82333;
}
.trash-bin.drag-over {
background-color: #dc3545;
border-color: #bd2130;
color: white;
}
.under-over-item {
text-align: center;
pointer-events: none;
.extraction-column.drop-target {
border-color: #007bff;
background-color: #e7f3ff;
}
.under-over-item .badge {
font-size: 1.1em;
padding: 0.5rem 1rem;
.trash-bin.drop-target {
border-color: #dc3545;
background-color: #f5c6cb;
}
</style>
<script>
let allOutcomes = [];
let associations = {};
let draggedElement = null;
document.addEventListener('DOMContentLoaded', function() {
loadData();
setupEventListeners();
setupDragAndDrop();
});
function loadData() {
// Load outcomes and associations
Promise.all([
fetch('/api/extraction/outcomes').then(r => r.json()),
fetch('/api/extraction/associations').then(r => r.json()),
fetch('/api/extraction/config').then(r => r.json())
]).then(([outcomesData, associationsData, configData]) => {
if (outcomesData.success) {
allOutcomes = outcomesData.outcomes;
}
if (associationsData.success) {
associations = {};
associationsData.associations.forEach(assoc => {
if (!associations[assoc.extraction_result]) {
associations[assoc.extraction_result] = [];
}
associations[assoc.extraction_result].push(assoc.outcome_name);
});
}
let draggedElement = null;
let draggedOutcome = null;
if (configData.success && configData.config) {
document.getElementById('time-limit-input').value = configData.config.under_over_time_limit || 90;
document.getElementById('cap-input').value = configData.config.redistributed_bets_cap || 70;
}
// Load data on page load
loadAvailableOutcomes();
loadCurrentAssociations();
loadTimeLimitConfig();
renderOutcomes();
updateStatistics();
}).catch(error => {
console.error('Error loading data:', error);
alert('Failed to load extraction data');
// Time limit save button
document.getElementById('btn-save-time-limit').addEventListener('click', function() {
saveTimeLimitConfig();
});
}
function setupEventListeners() {
// Save associations button
document.getElementById('save-associations-btn').addEventListener('click', saveAssociations);
// Update time limit button
document.getElementById('update-time-limit-btn').addEventListener('click', updateTimeLimit);
// Update CAP button
document.getElementById('update-cap-btn').addEventListener('click', updateCap);
}
function setupDragAndDrop() {
// Make outcome items draggable
document.addEventListener('dragstart', handleDragStart);
document.addEventListener('dragend', handleDragEnd);
// Setup drop zones
const dropZones = document.querySelectorAll('.outcomes-container');
dropZones.forEach(zone => {
zone.addEventListener('dragover', handleDragOver);
zone.addEventListener('dragleave', handleDragLeave);
zone.addEventListener('drop', handleDrop);
});
}
// Drag and drop functionality
setupDragAndDrop();
function handleDragStart(e) {
if (e.target.classList.contains('outcome-item')) {
function setupDragAndDrop() {
// Make outcomes draggable
document.addEventListener('dragstart', function(e) {
if (e.target.classList.contains('extraction-outcome')) {
draggedElement = e.target;
draggedOutcome = e.target.dataset.outcome;
e.target.classList.add('dragging');
e.dataTransfer.effectAllowed = 'move';
e.dataTransfer.setData('text/html', e.target.outerHTML);
e.dataTransfer.setData('text/plain', e.target.dataset.outcome);
}
}
});
function handleDragEnd(e) {
if (draggedElement) {
draggedElement.classList.remove('dragging');
document.addEventListener('dragend', function(e) {
if (e.target.classList.contains('extraction-outcome')) {
e.target.classList.remove('dragging');
draggedElement = null;
draggedOutcome = null;
}
// Remove drag-over class from all zones
document.querySelectorAll('.outcomes-container').forEach(zone => {
zone.classList.remove('drag-over');
});
}
function handleDragOver(e) {
// Setup drop zones
document.addEventListener('dragover', function(e) {
if (e.target.classList.contains('extraction-column') ||
e.target.classList.contains('trash-bin') ||
e.target.closest('.extraction-column') ||
e.target.closest('.trash-bin')) {
e.preventDefault();
e.dataTransfer.dropEffect = 'move';
if (e.target.classList.contains('outcomes-container') || e.target.closest('.outcomes-container')) {
const container = e.target.closest('.outcomes-container');
container.classList.add('drag-over');
// Special handling for trash bin
if (container.id === 'trash-bin') {
container.classList.add('drag-over');
}
e.target.classList.add('drop-target');
}
}
});
function handleDragLeave(e) {
if (e.target.classList.contains('outcomes-container') || e.target.closest('.outcomes-container')) {
const container = e.target.closest('.outcomes-container');
container.classList.remove('drag-over');
document.addEventListener('dragleave', function(e) {
if (e.target.classList.contains('extraction-column') ||
e.target.classList.contains('trash-bin')) {
e.target.classList.remove('drop-target');
}
}
});
function handleDrop(e) {
document.addEventListener('drop', function(e) {
if (e.target.classList.contains('extraction-column') ||
e.target.closest('.extraction-column') ||
e.target.classList.contains('trash-bin') ||
e.target.closest('.trash-bin')) {
e.preventDefault();
if (!draggedElement) return;
const dropZone = e.target.closest('.outcomes-container');
if (!dropZone) return;
// Remove drop target styling
document.querySelectorAll('.drop-target').forEach(el => {
el.classList.remove('drop-target');
});
const outcomeName = draggedElement.dataset.outcome;
const sourceContainer = draggedElement.closest('.outcomes-container');
if (!draggedOutcome) return;
// Determine source and destination types
const isFromResultColumn = sourceContainer && sourceContainer.classList.contains('extraction-column');
const isFromAvailable = sourceContainer && sourceContainer.id === 'available-outcomes';
const isToResultColumn = dropZone.classList.contains('extraction-column');
const isToAvailable = dropZone.id === 'available-outcomes';
const isToTrash = dropZone.id === 'trash-bin';
// Determine target
let target = e.target;
if (e.target.closest('.extraction-column')) {
target = e.target.closest('.extraction-column');
} else if (e.target.closest('.trash-bin')) {
target = e.target.closest('.trash-bin');
}
if (isToTrash) {
if (isFromResultColumn) {
// Remove from specific result when dragged from result column to trash
const sourceResult = sourceContainer.dataset.result;
removeAssociation(outcomeName, sourceResult);
} else {
// Remove from all associations when dragged from available to trash
removeAssociation(outcomeName);
if (target.classList.contains('extraction-column')) {
// Move to extraction result column
const extractionResult = target.dataset.result;
moveOutcomeToResult(draggedOutcome, extractionResult);
} else if (target.classList.contains('trash-bin')) {
// Remove association
removeOutcomeAssociation(draggedOutcome);
}
renderOutcomes();
} else if (isToAvailable) {
// Remove all associations when dragged to available outcomes
removeAssociation(outcomeName);
renderOutcomes();
} else if (isToResultColumn) {
const destinationResult = dropZone.dataset.result;
// Always add the association - allow multiple associations
addAssociation(outcomeName, destinationResult);
renderOutcomes();
}
dropZone.classList.remove('drag-over');
updateStatistics();
// Auto-save associations after each drop (no alerts for drag & drop)
saveAssociations(false);
}
function addAssociation(outcomeName, extractionResult) {
// Add to association (allow multiple associations)
if (!associations[extractionResult]) {
associations[extractionResult] = [];
});
}
// Only add if not already associated with this result
if (!associations[extractionResult].includes(outcomeName)) {
associations[extractionResult].push(outcomeName);
}
}
function loadAvailableOutcomes() {
fetch('/api/extraction/outcomes')
.then(response => response.json())
.then(data => {
if (data.success) {
const pool = document.getElementById('outcomes-pool');
pool.innerHTML = '';
function removeAssociation(outcomeName, specificResult = null) {
if (specificResult) {
// Remove from specific result only
if (associations[specificResult]) {
associations[specificResult] = associations[specificResult].filter(outcome => outcome !== outcomeName);
}
// Separate UNDER/OVER from other outcomes
const underOverOutcomes = [];
const regularOutcomes = [];
data.outcomes.forEach(outcome => {
if (outcome === 'UNDER' || outcome === 'OVER') {
underOverOutcomes.push(outcome);
} else {
// Remove from all associations
Object.keys(associations).forEach(result => {
associations[result] = associations[result].filter(outcome => outcome !== outcomeName);
});
regularOutcomes.push(outcome);
}
}
function renderOutcomes() {
const availableContainer = document.getElementById('available-outcomes');
const win1Container = document.getElementById('win1-column');
const xContainer = document.getElementById('x-column');
const win2Container = document.getElementById('win2-column');
});
// Clear containers
availableContainer.innerHTML = '';
win1Container.innerHTML = '';
xContainer.innerHTML = '';
win2Container.innerHTML = '';
// Display UNDER/OVER separately
if (underOverOutcomes.length > 0) {
const underOverSection = document.createElement('div');
underOverSection.className = 'mb-3';
underOverSection.innerHTML = `
<h6 class="text-muted mb-2">
<i class="fas fa-clock me-1"></i>UNDER/OVER Outcomes
</h6>
<div class="alert alert-warning">
<small>These outcomes appear above the main extraction area with time limits.</small>
</div>
`;
pool.appendChild(underOverSection);
}
// Separate UNDER/OVER from regular outcomes
const regularOutcomes = allOutcomes.filter(outcome => !['UNDER', 'OVER'].includes(outcome));
const underOverOutcomes = allOutcomes.filter(outcome => ['UNDER', 'OVER'].includes(outcome));
// Display regular outcomes
if (regularOutcomes.length > 0) {
const regularSection = document.createElement('div');
regularSection.innerHTML = `
<h6 class="text-muted mb-2">
<i class="fas fa-list me-1"></i>Regular Outcomes
</h6>
`;
// Render regular outcomes
regularOutcomes.forEach(outcome => {
const outcomeElement = createOutcomeElement(outcome);
// Count how many results this outcome is associated with
const associatedResults = Object.keys(associations).filter(result =>
associations[result].includes(outcome)
);
const outcomeElement = document.createElement('div');
outcomeElement.className = 'extraction-outcome';
outcomeElement.draggable = true;
outcomeElement.dataset.outcome = outcome;
outcomeElement.textContent = outcome;
regularSection.appendChild(outcomeElement);
});
// Always show outcome in available outcomes unless associated with ALL 3 results
if (associatedResults.length < 3) {
availableContainer.appendChild(outcomeElement.cloneNode(true));
pool.appendChild(regularSection);
}
// Show outcome in each associated result column
associatedResults.forEach(result => {
const container = getContainerForResult(result);
if (container) {
container.appendChild(outcomeElement.cloneNode(true));
} else {
document.getElementById('outcomes-pool').innerHTML =
'<div class="alert alert-danger">Failed to load outcomes</div>';
}
})
.catch(error => {
console.error('Error loading outcomes:', error);
document.getElementById('outcomes-pool').innerHTML =
'<div class="alert alert-danger">Error loading outcomes</div>';
});
});
}
function createOutcomeElement(outcome) {
const element = document.createElement('div');
element.className = 'outcome-item';
element.dataset.outcome = outcome;
element.draggable = true;
// All outcome labels should be red
let badgeClass = 'bg-danger';
element.innerHTML = `<span class="badge ${badgeClass}">${outcome}</span>`;
return element;
}
function getContainerForResult(result) {
switch (result) {
case 'WIN1': return document.getElementById('win1-column');
case 'X': return document.getElementById('x-column');
case 'WIN2': return document.getElementById('win2-column');
default: return null;
}
}
function updateStatistics() {
const totalOutcomes = allOutcomes.filter(outcome => !['UNDER', 'OVER'].includes(outcome)).length;
const associatedCount = Object.values(associations).reduce((sum, outcomes) => sum + outcomes.length, 0);
function loadCurrentAssociations() {
fetch('/api/extraction/associations')
.then(response => response.json())
.then(data => {
if (data.success) {
// Clear existing associations from columns
document.querySelectorAll('.extraction-column').forEach(column => {
const placeholder = column.querySelector('.text-center');
if (placeholder) {
column.innerHTML = '';
column.appendChild(placeholder);
} else {
column.innerHTML = '<div class="text-center text-muted"><small>Drop outcomes here</small></div>';
}
});
// Count outcomes that are NOT associated with all 3 results (these appear in available)
const availableCount = allOutcomes.filter(outcome => {
if (['UNDER', 'OVER'].includes(outcome)) return false;
const associatedResults = Object.keys(associations).filter(result =>
associations[result].includes(outcome)
);
return associatedResults.length < 3;
}).length;
// Add outcomes to their respective columns
data.associations.forEach(assoc => {
addOutcomeToColumn(assoc.outcome_name, assoc.extraction_result);
});
document.getElementById('total-outcomes').textContent = totalOutcomes;
document.getElementById('associated-outcomes').textContent = associatedCount;
document.getElementById('available-outcomes-count').textContent = availableCount;
document.getElementById('available-count').textContent = availableCount;
}
// Update associations display
updateAssociationsDisplay(data.associations);
} else {
document.getElementById('associations-display').innerHTML =
'<div class="alert alert-danger">Failed to load associations</div>';
}
})
.catch(error => {
console.error('Error loading associations:', error);
document.getElementById('associations-display').innerHTML =
'<div class="alert alert-danger">Error loading associations</div>';
});
}
function saveAssociations(showAlerts = true) {
const saveBtn = document.getElementById('save-associations-btn');
const originalText = saveBtn.innerHTML;
function addOutcomeToColumn(outcomeName, extractionResult) {
const column = document.querySelector(`[data-result="${extractionResult}"]`);
if (!column) return;
if (showAlerts) {
saveBtn.disabled = true;
saveBtn.innerHTML = '<i class="fas fa-spinner fa-spin me-1"></i>Saving...';
// Remove placeholder if present
const placeholder = column.querySelector('.text-center');
if (placeholder) {
placeholder.remove();
}
// Convert associations to API format
const associationsData = [];
Object.keys(associations).forEach(result => {
associations[result].forEach(outcome => {
associationsData.push({
outcome_name: outcome,
extraction_result: result
});
});
});
// Add outcome element
const outcomeElement = document.createElement('div');
outcomeElement.className = 'extraction-outcome';
outcomeElement.draggable = true;
outcomeElement.dataset.outcome = outcomeName;
outcomeElement.textContent = outcomeName;
column.appendChild(outcomeElement);
}
function moveOutcomeToResult(outcomeName, extractionResult) {
// Save association to server
fetch('/api/extraction/associations', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify({ associations: associationsData })
body: JSON.stringify({
associations: [{
outcome_name: outcomeName,
extraction_result: extractionResult
}]
})
})
.then(response => response.json())
.then(data => {
if (data.success) {
document.getElementById('last-saved').textContent = new Date().toLocaleTimeString();
if (showAlerts) {
alert('Associations saved successfully!');
}
// Reload associations to reflect changes
loadCurrentAssociations();
loadAvailableOutcomes(); // Refresh available outcomes
} else {
if (showAlerts) {
alert('Error saving associations: ' + (data.error || 'Unknown error'));
}
alert('Failed to save association: ' + (data.error || 'Unknown error'));
}
})
.catch(error => {
console.error('Error:', error);
if (showAlerts) {
alert('Failed to save associations: ' + error.message);
}
})
.finally(() => {
if (showAlerts) {
saveBtn.disabled = false;
saveBtn.innerHTML = originalText;
}
console.error('Error saving association:', error);
alert('Error saving association: ' + error.message);
});
}
function updateTimeLimit() {
const timeLimitInput = document.getElementById('time-limit-input');
const timeLimit = parseInt(timeLimitInput.value);
if (timeLimit < 1 || timeLimit > 300) {
alert('Time limit must be between 1 and 300 seconds');
return;
}
const updateBtn = document.getElementById('update-time-limit-btn');
const originalText = updateBtn.innerHTML;
updateBtn.disabled = true;
updateBtn.innerHTML = '<i class="fas fa-spinner fa-spin me-1"></i>Updating...';
function removeOutcomeAssociation(outcomeName) {
// For now, we'll need to get all associations and remove the specific one
// In a full implementation, you might want a specific delete endpoint
fetch('/api/extraction/associations')
.then(response => response.json())
.then(data => {
if (data.success) {
// Filter out the association to remove
const updatedAssociations = data.associations.filter(
assoc => assoc.outcome_name !== outcomeName
);
fetch('/api/extraction/config', {
// Save updated associations
fetch('/api/extraction/associations', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify({
config_key: 'under_over_time_limit',
config_value: timeLimit.toString(),
value_type: 'int'
associations: updatedAssociations
})
})
.then(response => response.json())
.then(data => {
if (data.success) {
alert('Time limit updated successfully!');
loadCurrentAssociations();
loadAvailableOutcomes();
} else {
alert('Error updating time limit: ' + (data.error || 'Unknown error'));
alert('Failed to remove association: ' + (data.error || 'Unknown error'));
}
});
}
})
.catch(error => {
console.error('Error:', error);
alert('Failed to update time limit: ' + error.message);
console.error('Error removing association:', error);
alert('Error removing association: ' + error.message);
});
}
function updateAssociationsDisplay(associations) {
const display = document.getElementById('associations-display');
if (associations.length === 0) {
display.innerHTML = '<div class="text-center text-muted">No associations configured</div>';
return;
}
// Group associations by extraction result
const grouped = {};
associations.forEach(assoc => {
if (!grouped[assoc.extraction_result]) {
grouped[assoc.extraction_result] = [];
}
grouped[assoc.extraction_result].push(assoc.outcome_name);
});
let html = '<div class="row">';
Object.keys(grouped).forEach(result => {
html += `
<div class="col-md-4 mb-3">
<div class="card">
<div class="card-header">
<strong>${result}</strong>
</div>
<div class="card-body">
<div class="d-flex flex-wrap">
${grouped[result].map(outcome =>
`<span class="badge bg-secondary me-1 mb-1">${outcome}</span>`
).join('')}
</div>
</div>
</div>
</div>
`;
});
html += '</div>';
display.innerHTML = html;
}
function loadTimeLimitConfig() {
fetch('/api/extraction/config')
.then(response => response.json())
.then(data => {
if (data.success && data.config && data.config.under_over_time_limit) {
document.getElementById('under-over-time-limit').value = data.config.under_over_time_limit;
}
})
.finally(() => {
updateBtn.disabled = false;
updateBtn.innerHTML = originalText;
.catch(error => {
console.error('Error loading time limit config:', error);
});
}
}
function updateCap() {
const capInput = document.getElementById('cap-input');
const cap = parseInt(capInput.value);
function saveTimeLimitConfig() {
const timeLimitInput = document.getElementById('under-over-time-limit');
const timeLimitValue = parseInt(timeLimitInput.value);
if (cap < 20 || cap > 90) {
alert('CAP must be between 20 and 90 percent');
if (!timeLimitValue || timeLimitValue < 1 || timeLimitValue > 300) {
alert('Please enter a valid time limit between 1 and 300 seconds');
return;
}
const updateBtn = document.getElementById('update-cap-btn');
const originalText = updateBtn.innerHTML;
const saveBtn = document.getElementById('btn-save-time-limit');
const originalText = saveBtn.innerHTML;
updateBtn.disabled = true;
updateBtn.innerHTML = '<i class="fas fa-spinner fa-spin me-1"></i>Updating...';
// Show loading state
saveBtn.disabled = true;
saveBtn.innerHTML = '<i class="fas fa-spinner fa-spin me-1"></i>Saving...';
fetch('/api/extraction/config', {
method: 'POST',
......@@ -670,27 +579,28 @@ function updateCap() {
'Content-Type': 'application/json',
},
body: JSON.stringify({
config_key: 'redistributed_bets_cap',
config_value: cap.toString(),
config_key: 'under_over_time_limit',
config_value: timeLimitValue,
value_type: 'int'
})
})
.then(response => response.json())
.then(data => {
if (data.success) {
alert('CAP updated successfully!');
alert('Time limit saved successfully!');
} else {
alert('Error updating CAP: ' + (data.error || 'Unknown error'));
alert('Failed to save time limit: ' + (data.error || 'Unknown error'));
}
})
.catch(error => {
console.error('Error:', error);
alert('Failed to update CAP: ' + error.message);
alert('Error saving time limit: ' + error.message);
})
.finally(() => {
updateBtn.disabled = false;
updateBtn.innerHTML = originalText;
// Restore button state
saveBtn.disabled = false;
saveBtn.innerHTML = originalText;
});
}
}
});
</script>
{% endblock %}
\ No newline at end of file
mbetterclient/web_dashboard/templates/dashboard/fixture_details.html
View file @ 126fa697
......@@ -10,12 +10,15 @@
<nav aria-label="breadcrumb">
<ol class="breadcrumb">
<li class="breadcrumb-item"><a href="{{ url_for('main.fixtures') }}">Fixtures</a></li>
<li class="breadcrumb-item active" aria-current="page">Match Details</li>
<li class="breadcrumb-item active" aria-current="page">Fixture Details</li>
</ol>
</nav>
<div class="d-flex justify-content-between align-items-center mb-4">
<div>
<h1><i class="fas fa-boxing me-2"></i>Fixture Details</h1>
<p class="mb-0 text-muted">All matches in this fixture</p>
</div>
<a href="{{ url_for('main.fixtures') }}" class="btn btn-outline-secondary">
<i class="fas fa-arrow-left me-1"></i>Back to Fixtures
</a>
......@@ -37,65 +40,95 @@
<!-- Fixture Details Content -->
<div id="fixture-content" style="display: none;">
<!-- Match Information Card -->
<!-- Fixture Information Card -->
<div class="row">
<div class="col-lg-8">
<div class="col-12">
<div class="card mb-4">
<div class="card-header">
<h5><i class="fas fa-info-circle me-2"></i>Match Information</h5>
<h5><i class="fas fa-info-circle me-2"></i>Fixture Information</h5>
</div>
<div class="card-body">
<div class="row">
<div class="col-md-6">
<div class="col-md-4">
<table class="table table-borderless">
<tr>
<td><strong>Match Number:</strong></td>
<td><span class="badge bg-primary fs-6" id="match-number"></span></td>
<td><strong>Fixture ID:</strong></td>
<td><span class="badge bg-primary fs-6" id="fixture-id"></span></td>
</tr>
<tr>
<td><strong>Fighter 1:</strong></td>
<td><span class="fw-bold text-primary" id="fighter1"></span></td>
<td><strong>Status:</strong></td>
<td><span id="fixture-status-badge"></span></td>
</tr>
<tr>
<td><strong>Fighter 2:</strong></td>
<td><span class="fw-bold text-primary" id="fighter2"></span></td>
<td><strong>Match Count:</strong></td>
<td><span class="fw-bold" id="match-count"></span></td>
</tr>
</table>
</div>
<div class="col-md-4">
<table class="table table-borderless">
<tr>
<td><strong>Venue:</strong></td>
<td><span id="venue"></span></td>
</tr>
<tr>
<td><strong>Fixture ID:</strong></td>
<td><small class="text-muted" id="fixture-id"></small></td>
<td><strong>Start Time:</strong></td>
<td><span id="start-time" class="text-muted">Not set</span></td>
</tr>
<tr>
<td><strong>Created:</strong></td>
<td><small class="text-muted" id="created-at"></small></td>
</tr>
</table>
</div>
<div class="col-md-6">
<div class="col-md-4">
<table class="table table-borderless">
<tr>
<td><strong>Status:</strong></td>
<td><span id="status-badge"></span></td>
<td><strong>Sample Fighters:</strong></td>
<td><small class="text-muted" id="sample-fighters"></small></td>
</tr>
<tr>
<td><strong>Active:</strong></td>
<td><span id="active-status"></span></td>
</tr>
<tr>
<td><strong>Start Time:</strong></td>
<td><span id="start-time" class="text-muted">Not set</span></td>
</tr>
<tr>
<td><strong>End Time:</strong></td>
<td><span id="end-time" class="text-muted">Not set</span></td>
<td><strong>Active Time:</strong></td>
<td><small class="text-muted" id="active-time"></small></td>
</tr>
</table>
</div>
</div>
</div>
</div>
</div>
</div>
<!-- Matches in Fixture -->
<div class="row">
<div class="col-12">
<div class="card mb-4">
<div class="card-header d-flex justify-content-between align-items-center">
<h5><i class="fas fa-list me-2"></i>Matches in This Fixture</h5>
<span id="matches-count" class="badge bg-secondary">0 matches</span>
</div>
<div class="card-body p-0">
<div class="table-responsive">
<table class="table table-hover mb-0">
<thead class="table-light">
<tr>
<td><strong>Result:</strong></td>
<td><span id="result" class="text-muted">Not available</span></td>
<th>Match #</th>
<th>Fighters</th>
<th>Status</th>
<th>Start Time</th>
<th>Result</th>
<th>Outcomes</th>
<th>Actions</th>
</tr>
</thead>
<tbody id="matches-tbody">
<!-- Matches will be loaded here -->
</tbody>
</table>
</div>
</div>
</div>
</div>
</div>
<!-- Match Outcomes Card -->
......@@ -133,29 +166,23 @@
<!-- Side Panel -->
<div class="col-lg-4">
<!-- Upload Status Card -->
<!-- Fixture Summary Card -->
<div class="card mb-4">
<div class="card-header">
<h5><i class="fas fa-cloud-upload-alt me-2"></i>Upload Status</h5>
<h5><i class="fas fa-chart-bar me-2"></i>Fixture Summary</h5>
</div>
<div class="card-body">
<div class="mb-3">
<label class="form-label">ZIP Upload Status</label>
<div id="upload-status-badge"></div>
</div>
<div class="mb-3" id="progress-container" style="display: none;">
<label class="form-label">Upload Progress</label>
<div class="progress">
<div class="progress-bar" role="progressbar" id="progress-bar" style="width: 0%">0%</div>
<label class="form-label">Status Distribution</label>
<div id="status-summary">
<!-- Status summary will be populated by JavaScript -->
</div>
</div>
<div class="mb-3" id="zip-file-info" style="display: none;">
<label class="form-label">ZIP File</label>
<div class="small text-muted">
<div><strong>Filename:</strong> <span id="zip-filename"></span></div>
<div><strong>SHA1:</strong> <span id="zip-sha1sum" class="font-monospace"></span></div>
<div class="mb-3">
<label class="form-label">Upload Status</label>
<div id="upload-summary">
<!-- Upload summary will be populated by JavaScript -->
</div>
</div>
</div>
......@@ -164,7 +191,7 @@
<!-- File Information Card -->
<div class="card mb-4">
<div class="card-header">
<h5><i class="fas fa-file me-2"></i>File Information</h5>
<h5><i class="fas fa-file me-2"></i>Source File</h5>
</div>
<div class="card-body">
<div class="mb-3">
......@@ -180,16 +207,16 @@
<!-- Timestamps Card -->
<div class="card">
<div class="card-header">
<h5><i class="fas fa-clock me-2"></i>Timestamps</h5>
<h5><i class="fas fa-clock me-2"></i>Fixture Timestamps</h5>
</div>
<div class="card-body">
<div class="mb-2">
<label class="form-label small">Created</label>
<div class="text-muted small" id="created-at"></div>
<div class="text-muted small" id="fixture-created-at"></div>
</div>
<div>
<label class="form-label small">Last Updated</label>
<div class="text-muted small" id="updated-at"></div>
<div class="text-muted small" id="fixture-updated-at"></div>
</div>
</div>
</div>
......@@ -202,17 +229,23 @@
<script id="fixture-config" type="application/json">
{
"matchId": {{ match_id | tojson }}
"fixtureId": {{ fixture_id | tojson }}
}
</script>
<script>
const config = JSON.parse(document.getElementById('fixture-config').textContent);
const matchId = config.matchId;
const fixtureId = config.fixtureId;
let cachedFixtureData = null;
let isInitialLoad = true;
// Load fixture details on page load
document.addEventListener('DOMContentLoaded', function() {
loadFixtureDetails();
// Set up auto-refresh every 5 seconds
setInterval(loadFixtureDetails, 5000);
});
function loadFixtureDetails() {
......@@ -220,26 +253,48 @@ function loadFixtureDetails() {
const errorMessage = document.getElementById('error-message');
const content = document.getElementById('fixture-content');
// Only show loading state on initial load
if (isInitialLoad) {
loading.style.display = 'block';
errorMessage.style.display = 'none';
content.style.display = 'none';
}
fetch(`/api/fixtures/${matchId}`)
fetch(`/api/fixtures/${fixtureId}`)
.then(response => response.json())
.then(data => {
if (data.success) {
renderFixtureDetails(data.match);
// Check if data has actually changed
const currentDataString = JSON.stringify(data);
if (cachedFixtureData === currentDataString && !isInitialLoad) {
console.log('📦 No changes in fixture data, skipping update');
return;
}
cachedFixtureData = currentDataString;
if (isInitialLoad) {
renderFixtureDetails(data.fixture, data.matches);
content.style.display = 'block';
} else {
updateFixtureDetails(data.fixture, data.matches);
}
} else {
if (isInitialLoad) {
showError(data.error || 'Failed to load fixture details');
}
}
})
.catch(error => {
console.error('Error:', error);
if (isInitialLoad) {
showError('Network error: ' + error.message);
}
})
.finally(() => {
if (isInitialLoad) {
loading.style.display = 'none';
isInitialLoad = false;
}
});
}
......@@ -248,125 +303,282 @@ function showError(message) {
document.getElementById('error-message').style.display = 'block';
}
function renderFixtureDetails(match) {
// Basic match information
document.getElementById('match-number').textContent = '#' + match.match_number;
document.getElementById('fighter1').textContent = match.fighter1_township;
document.getElementById('fighter2').textContent = match.fighter2_township;
document.getElementById('venue').textContent = match.venue_kampala_township;
document.getElementById('fixture-id').textContent = match.fixture_id;
// Status information
document.getElementById('status-badge').innerHTML = getStatusBadge(match);
document.getElementById('active-status').innerHTML = match.active_status
? '<span class="badge bg-success">Active</span>'
: '<span class="badge bg-secondary">Inactive</span>';
// Times and result
if (match.start_time) {
document.getElementById('start-time').textContent = new Date(match.start_time).toLocaleString();
function renderFixtureDetails(fixture, matches) {
// Basic fixture information
document.getElementById('fixture-id').textContent = fixture.fixture_id;
document.getElementById('fixture-status-badge').innerHTML = getFixtureStatusBadge(fixture);
document.getElementById('match-count').textContent = fixture.match_count + ' matches';
document.getElementById('venue').textContent = fixture.venue_kampala_township;
// Start time
if (fixture.start_time) {
document.getElementById('start-time').textContent = new Date(fixture.start_time).toLocaleString();
document.getElementById('start-time').classList.remove('text-muted');
}
if (match.end_time) {
document.getElementById('end-time').textContent = new Date(match.end_time).toLocaleString();
document.getElementById('end-time').classList.remove('text-muted');
// Sample fighters (from first match)
if (matches.length > 0) {
const firstMatch = matches[0];
document.getElementById('sample-fighters').textContent = firstMatch.fighter1_township + ' vs ' + firstMatch.fighter2_township;
}
if (match.result) {
document.getElementById('result').textContent = match.result;
document.getElementById('result').classList.remove('text-muted');
// Active time
if (fixture.fixture_active_time) {
document.getElementById('active-time').textContent = new Date(fixture.fixture_active_time * 1000).toLocaleString();
}
// File information
document.getElementById('filename').textContent = match.filename;
document.getElementById('file-sha1sum').textContent = match.file_sha1sum;
// File information (from first match)
if (matches.length > 0) {
const firstMatch = matches[0];
document.getElementById('filename').textContent = firstMatch.filename;
document.getElementById('file-sha1sum').textContent = firstMatch.file_sha1sum;
}
// Upload status
renderUploadStatus(match);
// Timestamps
document.getElementById('created-at').textContent = new Date(fixture.created_at).toLocaleString();
document.getElementById('fixture-created-at').textContent = new Date(fixture.created_at).toLocaleString();
// Outcomes
renderOutcomes(match.outcomes || []);
// Render matches table
renderMatchesTable(matches);
// Timestamps
document.getElementById('created-at').textContent = new Date(match.created_at).toLocaleString();
document.getElementById('updated-at').textContent = new Date(match.updated_at).toLocaleString();
// Render fixture summary
renderFixtureSummary(matches);
}
function renderUploadStatus(match) {
const uploadBadge = document.getElementById('upload-status-badge');
const progressContainer = document.getElementById('progress-container');
const zipFileInfo = document.getElementById('zip-file-info');
uploadBadge.innerHTML = getUploadStatusBadge(match);
function updateFixtureDetails(fixture, matches) {
// Update fixture information that might have changed
const statusBadge = document.getElementById('fixture-status-badge');
const newStatusBadge = getFixtureStatusBadge(fixture);
if (statusBadge.innerHTML !== newStatusBadge) {
statusBadge.innerHTML = newStatusBadge;
statusBadge.style.backgroundColor = '#fff3cd';
setTimeout(() => {
statusBadge.style.backgroundColor = '';
}, 1000);
}
// Show progress bar if uploading
if (match.zip_upload_status === 'uploading') {
const progress = match.zip_upload_progress || 0;
const progressBar = document.getElementById('progress-bar');
progressBar.style.width = progress + '%';
progressBar.textContent = progress.toFixed(1) + '%';
progressContainer.style.display = 'block';
// Update match count
const matchCountEl = document.getElementById('match-count');
const newMatchCount = fixture.match_count + ' matches';
if (matchCountEl.textContent !== newMatchCount) {
matchCountEl.textContent = newMatchCount;
}
// Show ZIP file info if available
if (match.zip_filename) {
document.getElementById('zip-filename').textContent = match.zip_filename;
if (match.zip_sha1sum) {
document.getElementById('zip-sha1sum').textContent = match.zip_sha1sum;
// Update start time if changed
if (fixture.start_time) {
const startTimeEl = document.getElementById('start-time');
const newStartTime = new Date(fixture.start_time).toLocaleString();
if (startTimeEl.textContent !== newStartTime) {
startTimeEl.textContent = newStartTime;
startTimeEl.classList.remove('text-muted');
}
zipFileInfo.style.display = 'block';
}
}
function renderOutcomes(outcomes) {
const noOutcomes = document.getElementById('no-outcomes');
const outcomesContainer = document.getElementById('outcomes-table-container');
const outcomesCount = document.getElementById('outcomes-count');
const tbody = document.getElementById('outcomes-tbody');
// Update matches table with smooth transitions
updateMatchesTable(matches);
outcomesCount.textContent = outcomes.length + ' outcomes';
// Update fixture summary
renderFixtureSummary(matches);
}
if (outcomes.length === 0) {
noOutcomes.style.display = 'block';
outcomesContainer.style.display = 'none';
return;
}
function renderMatchesTable(matches) {
const tbody = document.getElementById('matches-tbody');
const matchesCount = document.getElementById('matches-count');
noOutcomes.style.display = 'none';
outcomesContainer.style.display = 'block';
matchesCount.textContent = matches.length + ' matches';
tbody.innerHTML = '';
outcomes.forEach(outcome => {
matches.forEach(match => {
const row = document.createElement('tr');
const startTimeDisplay = match.start_time ? new Date(match.start_time).toLocaleString() : 'Not set';
const resultDisplay = match.result || 'Not available';
const outcomesCount = match.outcome_count || 0;
row.innerHTML = `
<td><span class="badge bg-light text-dark">${outcome.column_name}</span></td>
<td><strong class="text-primary">${outcome.float_value}</strong></td>
<td><small class="text-muted">${new Date(outcome.updated_at).toLocaleString()}</small></td>
<td><strong>#${match.match_number}</strong></td>
<td>
<div class="fw-bold">${match.fighter1_township}</div>
<small class="text-muted">vs</small>
<div class="fw-bold">${match.fighter2_township}</div>
</td>
<td>${getStatusBadge(match)}</td>
<td><small class="text-info">${startTimeDisplay}</small></td>
<td><small class="text-muted">${resultDisplay}</small></td>
<td><span class="badge bg-light text-dark">${outcomesCount} outcomes</span></td>
<td>
<a href="/matches/${match.id}/${fixtureId}" class="btn btn-sm btn-outline-primary">
<i class="fas fa-eye me-1"></i>View
</a>
</td>
`;
row.setAttribute('data-match-id', match.id);
tbody.appendChild(row);
});
}
function getStatusBadge(fixture) {
if (fixture.done) {
return '<span class="badge bg-success"><i class="fas fa-check me-1"></i>Completed</span>';
} else if (fixture.running) {
return '<span class="badge bg-info"><i class="fas fa-play me-1"></i>Running</span>';
function updateMatchesTable(matches) {
const tbody = document.getElementById('matches-tbody');
const matchesCount = document.getElementById('matches-count');
matchesCount.textContent = matches.length + ' matches';
// Get existing rows
const existingRows = Array.from(tbody.children);
const existingMatches = new Map();
existingRows.forEach(row => {
const matchId = row.getAttribute('data-match-id');
if (matchId) {
existingMatches.set(parseInt(matchId), row);
}
});
const processedMatches = new Set();
matches.forEach(match => {
processedMatches.add(match.id);
const startTimeDisplay = match.start_time ? new Date(match.start_time).toLocaleString() : 'Not set';
const resultDisplay = match.result || 'Not available';
const outcomesCount = match.outcome_count || 0;
const newRowHTML = `
<td><strong>#${match.match_number}</strong></td>
<td>
<div class="fw-bold">${match.fighter1_township}</div>
<small class="text-muted">vs</small>
<div class="fw-bold">${match.fighter2_township}</div>
</td>
<td>${getStatusBadge(match)}</td>
<td><small class="text-info">${startTimeDisplay}</small></td>
<td><small class="text-muted">${resultDisplay}</small></td>
<td><span class="badge bg-light text-dark">${outcomesCount} outcomes</span></td>
<td>
<a href="/matches/${match.id}/${fixtureId}" class="btn btn-sm btn-outline-primary">
<i class="fas fa-eye me-1"></i>View
</a>
</td>
`;
const existingRow = existingMatches.get(match.id);
if (existingRow) {
// Update existing row only if content changed
if (existingRow.innerHTML !== newRowHTML) {
existingRow.innerHTML = newRowHTML;
existingRow.style.backgroundColor = '#fff3cd'; // Highlight briefly
setTimeout(() => {
existingRow.style.backgroundColor = '';
}, 1000);
}
} else {
// Add new row
const row = document.createElement('tr');
row.setAttribute('data-match-id', match.id);
row.innerHTML = newRowHTML;
row.style.backgroundColor = '#d4edda'; // Highlight new row
tbody.appendChild(row);
setTimeout(() => {
row.style.backgroundColor = '';
}, 1000);
}
});
// Remove rows no longer in data
existingMatches.forEach((row, matchId) => {
if (!processedMatches.has(matchId)) {
row.style.backgroundColor = '#f8d7da'; // Highlight removed row
setTimeout(() => {
if (row.parentNode) {
row.parentNode.removeChild(row);
}
}, 500);
}
});
}
function renderFixtureSummary(matches) {
// Calculate status distribution
const statusCounts = {};
const uploadCounts = {};
matches.forEach(match => {
// Count statuses
const status = match.status || 'unknown';
statusCounts[status] = (statusCounts[status] || 0) + 1;
// Count upload statuses
const uploadStatus = match.zip_upload_status || 'pending';
uploadCounts[uploadStatus] = (uploadCounts[uploadStatus] || 0) + 1;
});
// Render status summary
const statusSummary = document.getElementById('status-summary');
statusSummary.innerHTML = Object.entries(statusCounts)
.map(([status, count]) => `<div class="small"><span class="badge bg-secondary">${status}</span> ${count}</div>`)
.join('');
// Render upload summary
const uploadSummary = document.getElementById('upload-summary');
uploadSummary.innerHTML = Object.entries(uploadCounts)
.map(([status, count]) => `<div class="small"><span class="badge bg-light text-dark">${status}</span> ${count}</div>`)
.join('');
}
function getFixtureStatusBadge(fixture) {
const status = fixture.fixture_status;
switch (status) {
case 'pending':
return '<span class="badge bg-warning"><i class="fas fa-clock me-1"></i>Pending</span>';
case 'running':
return '<span class="badge bg-info"><i class="fas fa-play me-1"></i>Running</span>';
case 'scheduled':
return '<span class="badge bg-secondary"><i class="fas fa-calendar me-1"></i>Scheduled</span>';
case 'bet':
return '<span class="badge bg-primary"><i class="fas fa-money-bill me-1"></i>Bet</span>';
case 'ingame':
return '<span class="badge bg-success"><i class="fas fa-gamepad me-1"></i>In Game</span>';
case 'end':
return '<span class="badge bg-dark"><i class="fas fa-stop me-1"></i>End</span>';
default:
return '<span class="badge bg-secondary"><i class="fas fa-question me-1"></i>Unknown</span>';
}
}
function getUploadStatusBadge(fixture) {
const status = fixture.zip_upload_status || 'pending';
const progress = fixture.zip_upload_progress || 0;
function getStatusBadge(match) {
const status = match.status;
switch (status) {
case 'pending':
return '<span class="badge bg-warning"><i class="fas fa-clock me-1"></i>Pending</span>';
case 'scheduled':
return '<span class="badge bg-secondary"><i class="fas fa-calendar me-1"></i>Scheduled</span>';
case 'bet':
return '<span class="badge bg-primary"><i class="fas fa-money-bill me-1"></i>Bet</span>';
case 'ingame':
return '<span class="badge bg-success"><i class="fas fa-gamepad me-1"></i>In Game</span>';
case 'end':
return '<span class="badge bg-dark"><i class="fas fa-stop me-1"></i>End</span>';
case 'cancelled':
return '<span class="badge bg-danger"><i class="fas fa-times me-1"></i>Cancelled</span>';
case 'failed':
return '<span class="badge bg-danger"><i class="fas fa-exclamation-triangle me-1"></i>Failed</span>';
case 'paused':
return '<span class="badge bg-warning"><i class="fas fa-pause me-1"></i>Paused</span>';
default:
return '<span class="badge bg-secondary"><i class="fas fa-question me-1"></i>Unknown</span>';
}
}
function getUploadStatusBadge(match) {
const status = match.zip_upload_status || 'pending';
const progress = match.zip_upload_progress || 0;
switch (status) {
case 'completed':
return '<span class="badge bg-success"><i class="fas fa-check me-1"></i>Completed</span>';
case 'uploading':
return `<span class="badge bg-info"><i class="fas fa-spinner fa-spin me-1"></i>Uploading (${progress.toFixed(1)}%)</span>`;
return '<span class="badge bg-info"><i class="fas fa-spinner fa-spin me-1"></i>Uploading (' + progress.toFixed(1) + '%)</span>';
case 'failed':
return '<span class="badge bg-danger"><i class="fas fa-times me-1"></i>Failed</span>';
default:
......
mbetterclient/web_dashboard/templates/dashboard/fixtures.html
View file @ 126fa697
......@@ -9,7 +9,7 @@
<div class="d-flex justify-content-between align-items-center mb-3">
<div>
<h1><i class="fas fa-list-ul me-2"></i>Fixtures</h1>
<p class="mb-0">View and manage synchronized boxing match fixtures.</p>
<p class="mb-0">View and manage synchronized boxing match fixtures with status tracking.</p>
</div>
{% if current_user.is_admin %}
<div>
......@@ -27,15 +27,6 @@
</div>
<div class="card-body">
<div class="row">
<div class="col-md-3">
<label for="status-filter" class="form-label">Status</label>
<select class="form-select" id="status-filter">
<option value="">All Status</option>
<option value="pending">Pending</option>
<option value="running">Running</option>
<option value="done">Completed</option>
</select>
</div>
<div class="col-md-3">
<label for="upload-filter" class="form-label">Upload Status</label>
<select class="form-select" id="upload-filter">
......@@ -46,6 +37,13 @@
<option value="failed">Failed</option>
</select>
</div>
<div class="col-md-3">
<label for="past-filter" class="form-label">Past Fixtures</label>
<select class="form-select" id="past-filter">
<option value="hide">Hide Past</option>
<option value="show">Show Past</option>
</select>
</div>
<div class="col-md-4">
<label for="search-input" class="form-label">Search Fighters</label>
<input type="text" class="form-control" id="search-input" placeholder="Search by fighter names or venue">
......@@ -122,11 +120,12 @@
<table class="table table-hover mb-0" id="fixtures-table">
<thead class="table-light">
<tr>
<th>Match #</th>
<th>Fixture #</th>
<th>Fighters</th>
<th>Venue</th>
<th>Status</th>
<th>Upload Status</th>
<th>Start Time</th>
<th>Created</th>
<th>Actions</th>
</tr>
......@@ -143,7 +142,7 @@
<div id="empty-state" class="text-center my-5" style="display: none;">
<i class="fas fa-inbox fa-4x text-muted mb-3"></i>
<h4 class="text-muted">No Fixtures Found</h4>
<p class="text-muted">No synchronized fixtures found. Check your API synchronization settings.</p>
<p class="text-muted">No synchronized fixtures found. Check your API synchronization settings or upload fixture files.</p>
</div>
</div>
</div>
......@@ -158,8 +157,8 @@ document.addEventListener('DOMContentLoaded', function() {
// Event listeners
document.getElementById('refresh-btn').addEventListener('click', loadFixtures);
document.getElementById('status-filter').addEventListener('change', filterFixtures);
document.getElementById('upload-filter').addEventListener('change', filterFixtures);
document.getElementById('past-filter').addEventListener('change', filterFixtures);
document.getElementById('search-input').addEventListener('input', filterFixtures);
// Reset fixtures button (admin only)
......@@ -167,13 +166,21 @@ document.addEventListener('DOMContentLoaded', function() {
if (resetBtn) {
resetBtn.addEventListener('click', resetFixtures);
}
// Auto-refresh fixtures every 5 seconds
setInterval(loadFixtures, 5000);
});
let isInitialLoad = true;
function loadFixtures() {
const loading = document.getElementById('loading');
const refreshBtn = document.getElementById('refresh-btn');
// Only show loading spinner on initial load or manual refresh
if (isInitialLoad || refreshBtn.disabled) {
loading.style.display = 'block';
}
refreshBtn.disabled = true;
fetch('/api/fixtures')
......@@ -184,48 +191,134 @@ function loadFixtures() {
updateSummaryCards();
filterFixtures(); // This will also render the table
} else {
if (isInitialLoad) {
alert('Error loading fixtures: ' + (data.error || 'Unknown error'));
}
}
})
.catch(error => {
console.error('Error:', error);
if (isInitialLoad) {
alert('Failed to load fixtures: ' + error.message);
}
})
.finally(() => {
loading.style.display = 'none';
refreshBtn.disabled = false;
isInitialLoad = false;
});
}
function updateSummaryCards() {
const totalCount = allFixtures.length;
const pendingCount = allFixtures.filter(f => !f.running && !f.done).length;
const runningCount = allFixtures.filter(f => f.running && !f.done).length;
const completedCount = allFixtures.filter(f => f.done).length;
const pendingCount = allFixtures.filter(f => f.fixture_status === 'pending').length;
const runningCount = allFixtures.filter(f => f.fixture_status === 'running').length;
const scheduledCount = allFixtures.filter(f => f.fixture_status === 'scheduled').length;
const betCount = allFixtures.filter(f => f.fixture_status === 'bet').length;
const ingameCount = allFixtures.filter(f => f.fixture_status === 'ingame').length;
const endCount = allFixtures.filter(f => f.fixture_status === 'end').length;
document.getElementById('total-count').textContent = totalCount;
document.getElementById('pending-count').textContent = pendingCount;
document.getElementById('running-count').textContent = runningCount;
document.getElementById('completed-count').textContent = completedCount;
// Update the summary cards to show more status types
const summaryCards = document.getElementById('summary-cards');
const betInGameCount = betCount + ingameCount;
summaryCards.innerHTML = `
<div class="col-md-2">
<div class="card text-center">
<div class="card-body">
<h5 class="card-title text-primary">
<i class="fas fa-list me-2"></i>Total Fixtures
</h5>
<h3 id="total-count" class="text-primary">` + totalCount + `</h3>
</div>
</div>
</div>
<div class="col-md-2">
<div class="card text-center">
<div class="card-body">
<h5 class="card-title text-warning">
<i class="fas fa-clock me-2"></i>Pending
</h5>
<h3 id="pending-count" class="text-warning">` + pendingCount + `</h3>
</div>
</div>
</div>
<div class="col-md-2">
<div class="card text-center">
<div class="card-body">
<h5 class="card-title text-info">
<i class="fas fa-play me-2"></i>Running
</h5>
<h3 id="running-count" class="text-info">` + runningCount + `</h3>
</div>
</div>
</div>
<div class="col-md-2">
<div class="card text-center">
<div class="card-body">
<h5 class="card-title text-secondary">
<i class="fas fa-calendar me-2"></i>Scheduled
</h5>
<h3 class="text-secondary">` + scheduledCount + `</h3>
</div>
</div>
</div>
<div class="col-md-2">
<div class="card text-center">
<div class="card-body">
<h5 class="card-title text-success">
<i class="fas fa-gamepad me-2"></i>Bet/In Game
</h5>
<h3 class="text-success">` + betInGameCount + `</h3>
</div>
</div>
</div>
<div class="col-md-2">
<div class="card text-center">
<div class="card-body">
<h5 class="card-title text-dark">
<i class="fas fa-stop me-2"></i>End
</h5>
<h3 class="text-dark">` + endCount + `</h3>
</div>
</div>
</div>
`;
}
function filterFixtures() {
const statusFilter = document.getElementById('status-filter').value;
const uploadFilter = document.getElementById('upload-filter').value;
const pastFilter = document.getElementById('past-filter').value;
const searchTerm = document.getElementById('search-input').value.toLowerCase();
// Get today's date (start of day)
const today = new Date();
today.setHours(0, 0, 0, 0);
let filteredFixtures = allFixtures.filter(fixture => {
// Status filter
if (statusFilter) {
if (statusFilter === 'pending' && (fixture.running || fixture.done)) return false;
if (statusFilter === 'running' && (!fixture.running || fixture.done)) return false;
if (statusFilter === 'done' && !fixture.done) return false;
// Past fixtures filter
if (pastFilter === 'hide') {
// Hide past fixtures by default
if (fixture.start_time) {
const fixtureDate = new Date(fixture.start_time);
fixtureDate.setHours(0, 0, 0, 0);
if (fixtureDate < today) {
return false; // Hide past fixtures
}
}
// Show fixtures with no start_time or future/today start_time
}
// If pastFilter is 'show', show all fixtures regardless of date
// Upload filter
if (uploadFilter && fixture.zip_upload_status !== uploadFilter) {
// Upload filter - check the first match's upload status
if (uploadFilter && fixture.matches && fixture.matches.length > 0) {
if (fixture.matches[0].zip_upload_status !== uploadFilter) {
return false;
}
}
// Search filter
if (searchTerm) {
......@@ -254,54 +347,126 @@ function filterFixtures() {
function renderFixturesTable(fixtures) {
const tbody = document.getElementById('fixtures-tbody');
tbody.innerHTML = '';
const existingRows = Array.from(tbody.children);
// Create a map of existing fixtures for comparison
const existingFixtures = new Map();
existingRows.forEach(row => {
const fixtureId = row.getAttribute('data-fixture-id');
if (fixtureId) {
existingFixtures.set(fixtureId, row);
}
});
fixtures.forEach(fixture => {
const row = document.createElement('tr');
row.innerHTML = `
<td><strong>#${fixture.match_number}</strong></td>
// Track which fixtures we've processed
const processedFixtures = new Set();
fixtures.forEach((fixture, index) => {
const fixtureId = fixture.fixture_id.toString();
processedFixtures.add(fixtureId);
const startTimeDisplay = fixture.start_time ? new Date(fixture.start_time).toLocaleString() : 'Not set';
const newRowHTML = `
<td>
<strong>#` + fixture.match_number + `</strong>
<br>
<small class="text-muted">` + fixture.match_count + ` matches</small>
</td>
<td>
<div class="fw-bold">${fixture.fighter1_township}</div>
<div class="fw-bold">` + fixture.fighter1_township + `</div>
<small class="text-muted">vs</small>
<div class="fw-bold">${fixture.fighter2_township}</div>
<div class="fw-bold">` + fixture.fighter2_township + `</div>
</td>
<td>` + fixture.venue_kampala_township + `</td>
<td>` + getFixtureStatusBadge(fixture) + `</td>
<td>` + getUploadStatusBadge(fixture) + `</td>
<td>
<small class="text-info">` + startTimeDisplay + `</small>
</td>
<td>${fixture.venue_kampala_township}</td>
<td>${getStatusBadge(fixture)}</td>
<td>${getUploadStatusBadge(fixture)}</td>
<td>
<small class="text-muted">
${new Date(fixture.created_at).toLocaleString()}
` + new Date(fixture.created_at).toLocaleString() + `
</small>
</td>
<td>
<a href="/fixtures/${fixture.id}" class="btn btn-sm btn-outline-primary">
<a href="/fixtures/` + fixture.fixture_id + `" class="btn btn-sm btn-outline-primary">
<i class="fas fa-eye me-1"></i>Details
</a>
</td>
`;
const existingRow = existingFixtures.get(fixtureId);
if (existingRow) {
// Update existing row only if content has changed
if (existingRow.innerHTML !== newRowHTML) {
existingRow.innerHTML = newRowHTML;
existingRow.style.backgroundColor = '#fff3cd'; // Highlight changed row briefly
setTimeout(() => {
existingRow.style.backgroundColor = '';
}, 1000);
}
} else {
// Add new row
const row = document.createElement('tr');
row.setAttribute('data-fixture-id', fixtureId);
row.innerHTML = newRowHTML;
row.style.backgroundColor = '#d4edda'; // Highlight new row briefly
tbody.appendChild(row);
setTimeout(() => {
row.style.backgroundColor = '';
}, 1000);
}
});
// Remove rows that are no longer in the data
existingFixtures.forEach((row, fixtureId) => {
if (!processedFixtures.has(fixtureId)) {
row.style.backgroundColor = '#f8d7da'; // Highlight removed row briefly
setTimeout(() => {
if (row.parentNode) {
row.parentNode.removeChild(row);
}
}, 500);
}
});
}
function getStatusBadge(fixture) {
if (fixture.done) {
return '<span class="badge bg-success"><i class="fas fa-check me-1"></i>Completed</span>';
} else if (fixture.running) {
return '<span class="badge bg-info"><i class="fas fa-play me-1"></i>Running</span>';
} else {
function getFixtureStatusBadge(fixture) {
const status = fixture.fixture_status;
switch (status) {
case 'pending':
return '<span class="badge bg-warning"><i class="fas fa-clock me-1"></i>Pending</span>';
case 'running':
return '<span class="badge bg-info"><i class="fas fa-play me-1"></i>Running</span>';
case 'scheduled':
return '<span class="badge bg-secondary"><i class="fas fa-calendar me-1"></i>Scheduled</span>';
case 'bet':
return '<span class="badge bg-primary"><i class="fas fa-money-bill me-1"></i>Bet</span>';
case 'ingame':
return '<span class="badge bg-success"><i class="fas fa-gamepad me-1"></i>In Game</span>';
case 'end':
return '<span class="badge bg-dark"><i class="fas fa-stop me-1"></i>End</span>';
default:
return '<span class="badge bg-secondary"><i class="fas fa-question me-1"></i>Unknown</span>';
}
}
function getUploadStatusBadge(fixture) {
const status = fixture.zip_upload_status || 'pending';
const progress = fixture.zip_upload_progress || 0;
// Get upload status from the first match in the fixture
if (!fixture.matches || fixture.matches.length === 0) {
return '<span class="badge bg-secondary"><i class="fas fa-clock me-1"></i>Pending</span>';
}
const firstMatch = fixture.matches[0];
const status = firstMatch.zip_upload_status || 'pending';
const progress = firstMatch.zip_upload_progress || 0;
switch (status) {
case 'completed':
return '<span class="badge bg-success"><i class="fas fa-check me-1"></i>Completed</span>';
case 'uploading':
return `<span class="badge bg-info"><i class="fas fa-spinner fa-spin me-1"></i>Uploading (${progress.toFixed(1)}%)</span>`;
return '<span class="badge bg-info"><i class="fas fa-spinner fa-spin me-1"></i>Uploading (' + progress.toFixed(1) + '%)</span>';
case 'failed':
return '<span class="badge bg-danger"><i class="fas fa-times me-1"></i>Failed</span>';
default:
......
mbetterclient/web_dashboard/templates/dashboard/index.html
View file @ 126fa697
......@@ -39,6 +39,64 @@
</div>
</div>
<!-- Match Timer and Interval Configuration -->
<div class="row mt-3">
<div class="col-md-8">
<div class="input-group">
<span class="input-group-text">
<i class="fas fa-clock me-2"></i>Match Interval
</span>
<input type="number" class="form-control" id="match-interval"
placeholder="20" min="1" max="60" step="1" value="20">
<span class="input-group-text">minutes</span>
<button class="btn btn-outline-primary" id="btn-save-interval">
<i class="fas fa-save me-1"></i>Save
</button>
</div>
<small class="text-muted mt-1 d-block">
Set the interval between matches in minutes (1-60)
</small>
</div>
<div class="col-md-4">
<div class="card bg-light">
<div class="card-body text-center p-3">
<h5 class="card-title mb-2">
<i class="fas fa-stopwatch me-2"></i>Match Timer
</h5>
<div class="h3 mb-2" id="admin-match-timer">--:--</div>
<div class="mt-2">
<small class="text-muted" id="timer-status">Waiting for games to start...</small>
</div>
<div class="mt-2">
<small class="text-info">
<i class="fas fa-info-circle me-1"></i>Timer starts automatically when cashier begins games
</small>
</div>
</div>
</div>
</div>
<div class="col-md-4">
<div class="card bg-light">
<div class="card-body p-3">
<h5 class="card-title mb-3">
<i class="fas fa-dice me-2"></i>Betting Mode
</h5>
<div class="mb-3">
<select class="form-select" id="betting-mode-select">
<option value="all_bets_on_start">All bets on start</option>
<option value="one_bet_at_a_time">One bet at a time</option>
</select>
</div>
<div class="mt-2">
<small class="text-muted">
<i class="fas fa-info-circle me-1"></i>Choose how bets are placed during matches
</small>
</div>
</div>
</div>
</div>
</div>
{% if current_user.is_admin %}
<!-- Admin Only Actions -->
<div class="row mt-3 pt-3 border-top">
......@@ -238,6 +296,12 @@ document.addEventListener('DOMContentLoaded', function() {
// Load available templates on page load
loadAvailableTemplates();
// Load match interval configuration
loadMatchInterval();
// Load betting mode configuration
loadBettingMode();
// Quick action buttons
document.getElementById('btn-play-video').addEventListener('click', function() {
new bootstrap.Modal(document.getElementById('playVideoModal')).show();
......@@ -251,6 +315,16 @@ document.addEventListener('DOMContentLoaded', function() {
window.location.href = '/tokens';
});
// Match interval save button
document.getElementById('btn-save-interval').addEventListener('click', function() {
saveMatchInterval();
});
// Betting mode select
document.getElementById('betting-mode-select').addEventListener('change', function() {
saveBettingMode(this.value);
});
// Admin shutdown button (only exists if user is admin)
const shutdownBtn = document.getElementById('btn-shutdown-app');
if (shutdownBtn) {
......@@ -395,10 +469,114 @@ document.addEventListener('DOMContentLoaded', function() {
updateVideoStatus();
// Periodic updates
setInterval(updateSystemStatus, 30000); // 30 seconds
setInterval(updateVideoStatus, 10000); // 10 seconds
setInterval(updateSystemStatus, 5000); // 5 seconds
setInterval(updateVideoStatus, 5000); // 5 seconds
});
function loadMatchInterval() {
fetch('/api/config/match-interval')
.then(response => response.json())
.then(data => {
if (data.success && data.match_interval) {
document.getElementById('match-interval').value = data.match_interval;
}
})
.catch(error => {
console.error('Error loading match interval:', error);
// Keep default value if loading fails
});
}
function saveMatchInterval() {
const intervalInput = document.getElementById('match-interval');
const intervalValue = parseInt(intervalInput.value);
if (!intervalValue || intervalValue < 1 || intervalValue > 60) {
alert('Please enter a valid interval between 1 and 60 minutes');
return;
}
const saveBtn = document.getElementById('btn-save-interval');
const originalText = saveBtn.innerHTML;
// Show loading state
saveBtn.disabled = true;
saveBtn.innerHTML = '<i class="fas fa-spinner fa-spin me-1"></i>Saving...';
fetch('/api/config/match-interval', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify({
match_interval: intervalValue
})
})
.then(response => response.json())
.then(data => {
if (data.success) {
// Reload the match interval to confirm the saved value
loadMatchInterval();
alert('Match interval saved successfully!');
} else {
alert('Failed to save match interval: ' + (data.error || 'Unknown error'));
}
})
.catch(error => {
alert('Error saving match interval: ' + error.message);
})
.finally(() => {
// Restore button state
saveBtn.disabled = false;
saveBtn.innerHTML = originalText;
});
}
function loadBettingMode() {
fetch('/api/betting-mode')
.then(response => response.json())
.then(data => {
if (data.success) {
const select = document.getElementById('betting-mode-select');
if (select) {
select.value = data.betting_mode;
}
} else {
console.error('Failed to load betting mode:', data.error);
}
})
.catch(error => {
console.error('Error loading betting mode:', error);
});
}
function saveBettingMode(mode) {
fetch('/api/betting-mode', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify({
betting_mode: mode
})
})
.then(response => response.json())
.then(data => {
if (data.success) {
console.log('Betting mode saved successfully:', mode);
} else {
console.error('Failed to save betting mode:', data.error);
// Revert the select if save failed
loadBettingMode();
}
})
.catch(error => {
console.error('Error saving betting mode:', error);
// Revert the select if save failed
loadBettingMode();
});
}
function loadAvailableTemplates() {
fetch('/api/templates')
.then(response => response.json())
......@@ -458,5 +636,6 @@ function loadAvailableTemplates() {
overlayTemplateSelect.innerHTML = '<option value="default">Default</option>';
});
}
</script>
{% endblock %}
mbetterclient/web_dashboard/templates/dashboard/match_details.html 0 → 100644
View file @ 126fa697
{% extends "base.html" %}
{% block title %}{{ page_title }}{% endblock %}
{% block content %}
<div class="container-fluid">
<div class="row">
<div class="col-12">
<!-- Navigation -->
<nav aria-label="breadcrumb">
<ol class="breadcrumb">
<li class="breadcrumb-item"><a href="{{ url_for('main.fixtures') }}">Fixtures</a></li>
<li class="breadcrumb-item"><a href="#" onclick="goBackToFixture()">Fixture Details</a></li>
<li class="breadcrumb-item active" aria-current="page">Match Details</li>
</ol>
</nav>
<div class="d-flex justify-content-between align-items-center mb-4">
<div>
<h1><i class="fas fa-boxing me-2"></i>Match Details</h1>
<p class="mb-0 text-muted">Complete match information, outcomes, and results</p>
</div>
<a href="javascript:history.back()" class="btn btn-outline-secondary">
<i class="fas fa-arrow-left me-1"></i>Back
</a>
</div>
<!-- Loading Spinner -->
<div id="loading" class="text-center my-5">
<div class="spinner-border text-primary" role="status">
<span class="visually-hidden">Loading...</span>
</div>
<p class="mt-2">Loading match details...</p>
</div>
<!-- Error Message -->
<div id="error-message" class="alert alert-danger" style="display: none;">
<i class="fas fa-exclamation-triangle me-2"></i>
<span id="error-text"></span>
</div>
<!-- Match Details Content -->
<div id="match-content" style="display: none;">
<!-- Match Information Card -->
<div class="row">
<div class="col-12">
<div class="card mb-4">
<div class="card-header">
<h5><i class="fas fa-info-circle me-2"></i>Match Information</h5>
</div>
<div class="card-body">
<div class="row">
<div class="col-md-6">
<table class="table table-borderless">
<tr>
<td><strong>Match #:</strong></td>
<td><span class="badge bg-primary fs-6" id="match-number"></span></td>
</tr>
<tr>
<td><strong>Status:</strong></td>
<td><span id="match-status-badge"></span></td>
</tr>
<tr>
<td><strong>Fighters:</strong></td>
<td><span id="fighters"></span></td>
</tr>
<tr>
<td><strong>Venue:</strong></td>
<td><span id="venue"></span></td>
</tr>
</table>
</div>
<div class="col-md-6">
<table class="table table-borderless">
<tr>
<td><strong>Start Time:</strong></td>
<td><span id="start-time" class="text-muted">Not set</span></td>
</tr>
<tr>
<td><strong>End Time:</strong></td>
<td><span id="end-time" class="text-muted">Not set</span></td>
</tr>
<tr>
<td><strong>Result:</strong></td>
<td><span id="result" class="text-muted">Not available</span></td>
</tr>
<tr>
<td><strong>Fixture ID:</strong></td>
<td><small class="text-muted" id="fixture-id"></small></td>
</tr>
</table>
</div>
</div>
</div>
</div>
</div>
</div>
<!-- Match Outcomes -->
<div class="row">
<div class="col-12">
<div class="card mb-4">
<div class="card-header d-flex justify-content-between align-items-center">
<h5><i class="fas fa-chart-line me-2"></i>Match Outcomes</h5>
<span id="outcomes-count" class="badge bg-secondary">0 outcomes</span>
</div>
<div class="card-body">
<div id="no-outcomes" class="text-center text-muted py-4" style="display: none;">
<i class="fas fa-chart-line fa-3x mb-3"></i>
<h5>No Outcomes Available</h5>
<p>No outcome data has been synchronized for this match yet.</p>
</div>
<div id="outcomes-container" style="display: none;">
<div class="table-responsive">
<table class="table table-hover">
<thead class="table-light">
<tr>
<th>Column Name</th>
<th>Value</th>
<th>Updated</th>
</tr>
</thead>
<tbody id="outcomes-tbody">
<!-- Outcomes will be loaded here -->
</tbody>
</table>
</div>
</div>
</div>
</div>
</div>
</div>
<!-- File Information -->
<div class="row">
<div class="col-md-6">
<div class="card mb-4">
<div class="card-header">
<h5><i class="fas fa-file me-2"></i>Source File</h5>
</div>
<div class="card-body">
<div class="mb-3">
<label class="form-label">Fixture File</label>
<div class="small text-muted">
<div><strong>Filename:</strong> <span id="filename"></span></div>
<div><strong>SHA1:</strong> <span id="file-sha1sum" class="font-monospace"></span></div>
</div>
</div>
</div>
</div>
</div>
<div class="col-md-6">
<div class="card mb-4">
<div class="card-header">
<h5><i class="fas fa-upload me-2"></i>Upload Status</h5>
</div>
<div class="card-body">
<div class="mb-3">
<label class="form-label">ZIP Upload</label>
<div id="upload-status"></div>
</div>
</div>
</div>
</div>
</div>
<!-- Timestamps -->
<div class="row">
<div class="col-12">
<div class="card">
<div class="card-header">
<h5><i class="fas fa-clock me-2"></i>Timestamps</h5>
</div>
<div class="card-body">
<div class="row">
<div class="col-md-4">
<label class="form-label small">Created</label>
<div class="text-muted small" id="created-at"></div>
</div>
<div class="col-md-4">
<label class="form-label small">Updated</label>
<div class="text-muted small" id="updated-at"></div>
</div>
<div class="col-md-4">
<label class="form-label small">Active Time</label>
<div class="text-muted small" id="active-time"></div>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
<script id="match-config" type="application/json">
{
"matchId": {{ match_id | tojson }},
"fixtureId": {{ fixture_id | tojson }}
}
</script>
<script>
const config = JSON.parse(document.getElementById('match-config').textContent);
const matchId = config.matchId;
const fixtureId = config.fixtureId;
let cachedMatchData = null;
let isInitialLoad = true;
// Load match details on page load
document.addEventListener('DOMContentLoaded', function() {
loadMatchDetails();
// Set up auto-refresh every 5 seconds
setInterval(loadMatchDetails, 5000);
});
function loadMatchDetails() {
const loading = document.getElementById('loading');
const errorMessage = document.getElementById('error-message');
const content = document.getElementById('match-content');
// Only show loading state on initial load
if (isInitialLoad) {
loading.style.display = 'block';
errorMessage.style.display = 'none';
content.style.display = 'none';
}
// First get fixture details to get all matches, then find the specific match
fetch(`/api/fixtures/${fixtureId}`)
.then(response => response.json())
.then(data => {
if (data.success) {
// Find the specific match within the fixture
const match = data.matches.find(m => m.id === matchId);
if (match) {
// Check if data has actually changed
const currentMatchString = JSON.stringify(match);
if (cachedMatchData === currentMatchString && !isInitialLoad) {
console.log('📦 No changes in match data, skipping update');
return;
}
cachedMatchData = currentMatchString;
if (isInitialLoad) {
renderMatchDetails(match);
content.style.display = 'block';
} else {
updateMatchDetails(match);
}
} else {
if (isInitialLoad) {
showError('Match not found in fixture');
}
}
} else {
if (isInitialLoad) {
showError(data.error || 'Failed to load fixture details');
}
}
})
.catch(error => {
console.error('Error:', error);
if (isInitialLoad) {
showError('Network error: ' + error.message);
}
})
.finally(() => {
if (isInitialLoad) {
loading.style.display = 'none';
isInitialLoad = false;
}
});
}
function showError(message) {
document.getElementById('error-text').textContent = message;
document.getElementById('error-message').style.display = 'block';
}
function updateMatchDetails(match) {
// Update status badge with highlighting
const statusBadge = document.getElementById('match-status-badge');
const newStatusBadge = getStatusBadge(match);
if (statusBadge.innerHTML !== newStatusBadge) {
statusBadge.innerHTML = newStatusBadge;
statusBadge.style.backgroundColor = '#fff3cd';
setTimeout(() => {
statusBadge.style.backgroundColor = '';
}, 1000);
}
// Update start time if changed
if (match.start_time) {
const startTimeEl = document.getElementById('start-time');
const newStartTime = new Date(match.start_time).toLocaleString();
if (startTimeEl.textContent !== newStartTime) {
startTimeEl.textContent = newStartTime;
startTimeEl.classList.remove('text-muted');
startTimeEl.style.backgroundColor = '#fff3cd';
setTimeout(() => {
startTimeEl.style.backgroundColor = '';
}, 1000);
}
}
// Update end time if changed
if (match.end_time) {
const endTimeEl = document.getElementById('end-time');
const newEndTime = new Date(match.end_time).toLocaleString();
if (endTimeEl.textContent !== newEndTime) {
endTimeEl.textContent = newEndTime;
endTimeEl.classList.remove('text-muted');
endTimeEl.style.backgroundColor = '#fff3cd';
setTimeout(() => {
endTimeEl.style.backgroundColor = '';
}, 1000);
}
}
// Update result if changed
if (match.result) {
const resultEl = document.getElementById('result');
if (resultEl.textContent !== match.result) {
resultEl.textContent = match.result;
resultEl.classList.remove('text-muted');
resultEl.style.backgroundColor = '#fff3cd';
setTimeout(() => {
resultEl.style.backgroundColor = '';
}, 1000);
}
}
// Update upload status
const uploadStatusEl = document.getElementById('upload-status');
const newUploadStatus = getUploadStatusBadge(match);
if (uploadStatusEl.innerHTML !== newUploadStatus) {
uploadStatusEl.innerHTML = newUploadStatus;
uploadStatusEl.style.backgroundColor = '#fff3cd';
setTimeout(() => {
uploadStatusEl.style.backgroundColor = '';
}, 1000);
}
// Update timestamps
const updatedAtEl = document.getElementById('updated-at');
const newUpdatedAt = new Date(match.updated_at).toLocaleString();
if (updatedAtEl.textContent !== newUpdatedAt) {
updatedAtEl.textContent = newUpdatedAt;
updatedAtEl.style.backgroundColor = '#fff3cd';
setTimeout(() => {
updatedAtEl.style.backgroundColor = '';
}, 1000);
}
// Update outcomes
renderOutcomes(match.outcomes || []);
}
function renderMatchDetails(match) {
// Basic match information
document.getElementById('match-number').textContent = match.match_number;
document.getElementById('match-status-badge').innerHTML = getStatusBadge(match);
document.getElementById('fighters').textContent = match.fighter1_township + ' vs ' + match.fighter2_township;
document.getElementById('venue').textContent = match.venue_kampala_township;
document.getElementById('fixture-id').textContent = match.fixture_id;
// Start time
if (match.start_time) {
document.getElementById('start-time').textContent = new Date(match.start_time).toLocaleString();
document.getElementById('start-time').classList.remove('text-muted');
}
// End time
if (match.end_time) {
document.getElementById('end-time').textContent = new Date(match.end_time).toLocaleString();
document.getElementById('end-time').classList.remove('text-muted');
}
// Result
if (match.result) {
document.getElementById('result').textContent = match.result;
document.getElementById('result').classList.remove('text-muted');
}
// File information
document.getElementById('filename').textContent = match.filename;
document.getElementById('file-sha1sum').textContent = match.file_sha1sum;
// Upload status
document.getElementById('upload-status').innerHTML = getUploadStatusBadge(match);
// Timestamps
document.getElementById('created-at').textContent = new Date(match.created_at).toLocaleString();
document.getElementById('updated-at').textContent = new Date(match.updated_at).toLocaleString();
// Active time
if (match.fixture_active_time) {
document.getElementById('active-time').textContent = new Date(match.fixture_active_time * 1000).toLocaleString();
}
// Render outcomes
renderOutcomes(match.outcomes || []);
}
function renderOutcomes(outcomes) {
const outcomesCount = document.getElementById('outcomes-count');
const noOutcomes = document.getElementById('no-outcomes');
const outcomesContainer = document.getElementById('outcomes-container');
const tbody = document.getElementById('outcomes-tbody');
outcomesCount.textContent = outcomes.length + ' outcomes';
if (outcomes.length === 0) {
noOutcomes.style.display = 'block';
outcomesContainer.style.display = 'none';
return;
}
noOutcomes.style.display = 'none';
outcomesContainer.style.display = 'block';
tbody.innerHTML = '';
outcomes.forEach(outcome => {
const row = document.createElement('tr');
const updatedTime = new Date(outcome.updated_at).toLocaleString();
row.innerHTML = `
<td><strong>${outcome.column_name}</strong></td>
<td><span class="badge bg-primary">${outcome.float_value}</span></td>
<td><small class="text-muted">${updatedTime}</small></td>
`;
tbody.appendChild(row);
});
}
function getStatusBadge(match) {
const status = match.status;
switch (status) {
case 'pending':
return '<span class="badge bg-warning"><i class="fas fa-clock me-1"></i>Pending</span>';
case 'scheduled':
return '<span class="badge bg-secondary"><i class="fas fa-calendar me-1"></i>Scheduled</span>';
case 'bet':
return '<span class="badge bg-primary"><i class="fas fa-money-bill me-1"></i>Bet</span>';
case 'ingame':
return '<span class="badge bg-success"><i class="fas fa-gamepad me-1"></i>In Game</span>';
case 'end':
return '<span class="badge bg-dark"><i class="fas fa-stop me-1"></i>End</span>';
case 'cancelled':
return '<span class="badge bg-danger"><i class="fas fa-times me-1"></i>Cancelled</span>';
case 'failed':
return '<span class="badge bg-danger"><i class="fas fa-exclamation-triangle me-1"></i>Failed</span>';
case 'paused':
return '<span class="badge bg-warning"><i class="fas fa-pause me-1"></i>Paused</span>';
default:
return '<span class="badge bg-secondary"><i class="fas fa-question me-1"></i>Unknown</span>';
}
}
function getUploadStatusBadge(match) {
const status = match.zip_upload_status || 'pending';
const progress = match.zip_upload_progress || 0;
switch (status) {
case 'completed':
return '<span class="badge bg-success"><i class="fas fa-check me-1"></i>Completed</span>';
case 'uploading':
return `<span class="badge bg-info"><i class="fas fa-spinner fa-spin me-1"></i>Uploading (${progress.toFixed(1)}%)</span>`;
case 'failed':
return '<span class="badge bg-danger"><i class="fas fa-times me-1"></i>Failed</span>';
default:
return '<span class="badge bg-secondary"><i class="fas fa-clock me-1"></i>Pending</span>';
}
}
function goBackToFixture() {
// Use the fixture_id from the config
if (fixtureId) {
window.location.href = `/fixtures/${fixtureId}`;
} else {
// Fallback to browser back
window.history.back();
}
}
</script>
{% endblock %}
\ No newline at end of file
temp_js.js 0 → 100644
View file @ 126fa697
let allFixtures = [];
// Load fixtures on page load
document.addEventListener('DOMContentLoaded', function() {
loadFixtures();
// Event listeners
document.getElementById('refresh-btn').addEventListener('click', loadFixtures);
document.getElementById('status-filter').addEventListener('change', filterFixtures);
document.getElementById('upload-filter').addEventListener('change', filterFixtures);
document.getElementById('search-input').addEventListener('input', filterFixtures);
// Reset fixtures button (admin only)
const resetBtn = document.getElementById('reset-fixtures-btn');
if (resetBtn) {
resetBtn.addEventListener('click', resetFixtures);
}
});
function loadFixtures() {
const loading = document.getElementById('loading');
const refreshBtn = document.getElementById('refresh-btn');
loading.style.display = 'block';
refreshBtn.disabled = true;
fetch('/api/fixtures')
.then(response => response.json())
.then(data => {
if (data.success) {
allFixtures = data.fixtures;
updateSummaryCards();
filterFixtures(); // This will also render the table
} else {
alert('Error loading fixtures: ' + (data.error || 'Unknown error'));
}
})
.catch(error => {
console.error('Error:', error);
alert('Failed to load fixtures: ' + error.message);
})
.finally(() => {
loading.style.display = 'none';
refreshBtn.disabled = false;
});
}
function updateSummaryCards() {
const totalCount = allFixtures.length;
const pendingCount = allFixtures.filter(f => f.fixture_status === 'pending').length;
const runningCount = allFixtures.filter(f => f.fixture_status === 'running').length;
const scheduledCount = allFixtures.filter(f => f.fixture_status === 'scheduled').length;
const betCount = allFixtures.filter(f => f.fixture_status === 'bet').length;
const ingameCount = allFixtures.filter(f => f.fixture_status === 'ingame').length;
const endCount = allFixtures.filter(f => f.fixture_status === 'end').length;
document.getElementById('total-count').textContent = totalCount;
document.getElementById('pending-count').textContent = pendingCount;
document.getElementById('running-count').textContent = runningCount;
// Update the summary cards to show more status types
const summaryCards = document.getElementById('summary-cards');
const betInGameCount = betCount + ingameCount;
summaryCards.innerHTML = `
<div class="col-md-2">
<div class="card text-center">
<div class="card-body">
<h5 class="card-title text-primary">
<i class="fas fa-list me-2"></i>Total Fixtures
</h5>
<h3 id="total-count" class="text-primary">` + totalCount + `</h3>
</div>
</div>
</div>
<div class="col-md-2">
<div class="card text-center">
<div class="card-body">
<h5 class="card-title text-warning">
<i class="fas fa-clock me-2"></i>Pending
</h5>
<h3 id="pending-count" class="text-warning">` + pendingCount + `</h3>
</div>
</div>
</div>
<div class="col-md-2">
<div class="card text-center">
<div class="card-body">
<h5 class="card-title text-info">
<i class="fas fa-play me-2"></i>Running
</h5>
<h3 id="running-count" class="text-info">` + runningCount + `</h3>
</div>
</div>
</div>
<div class="col-md-2">
<div class="card text-center">
<div class="card-body">
<h5 class="card-title text-secondary">
<i class="fas fa-calendar me-2"></i>Scheduled
</h5>
<h3 class="text-secondary">` + scheduledCount + `</h3>
</div>
</div>
</div>
<div class="col-md-2">
<div class="card text-center">
<div class="card-body">
<h5 class="card-title text-success">
<i class="fas fa-gamepad me-2"></i>Bet/In Game
</h5>
<h3 class="text-success">` + betInGameCount + `</h3>
</div>
</div>
</div>
<div class="col-md-2">
<div class="card text-center">
<div class="card-body">
<h5 class="card-title text-dark">
<i class="fas fa-stop me-2"></i>End
</h5>
<h3 class="text-dark">` + endCount + `</h3>
</div>
</div>
</div>
`;
}
function filterFixtures() {
const statusFilter = document.getElementById('status-filter').value;
const uploadFilter = document.getElementById('upload-filter').value;
const searchTerm = document.getElementById('search-input').value.toLowerCase();
let filteredFixtures = allFixtures.filter(fixture => {
// Status filter
if (statusFilter && fixture.fixture_status !== statusFilter) {
return false;
}
// Upload filter - check the first match's upload status
if (uploadFilter && fixture.matches && fixture.matches.length > 0) {
if (fixture.matches[0].zip_upload_status !== uploadFilter) {
return false;
}
}
// Search filter
if (searchTerm) {
const searchText = (fixture.fighter1_township + ' ' + fixture.fighter2_township + ' ' + fixture.venue_kampala_township).toLowerCase();
if (!searchText.includes(searchTerm)) return false;
}
return true;
});
renderFixturesTable(filteredFixtures);
document.getElementById('filtered-count').textContent = filteredFixtures.length + ' fixtures';
// Show/hide empty state
const emptyState = document.getElementById('empty-state');
const fixturesTable = document.querySelector('.card .table-responsive').parentElement;
if (filteredFixtures.length === 0 && allFixtures.length === 0) {
emptyState.style.display = 'block';
fixturesTable.style.display = 'none';
} else {
emptyState.style.display = 'none';
fixturesTable.style.display = 'block';
}
}
function renderFixturesTable(fixtures) {
const tbody = document.getElementById('fixtures-tbody');
tbody.innerHTML = '';
fixtures.forEach(fixture => {
const row = document.createElement('tr');
const startTimeInfo = fixture.start_time ? '<br><small class="text-info">Start: ' + new Date(fixture.start_time).toLocaleString() + '</small>' : '';
row.innerHTML = `
<td>
<strong>#` + fixture.match_number + `</strong>
<br>
<small class="text-muted">` + fixture.match_count + ` matches</small>
</td>
<td>
<div class="fw-bold">` + fixture.fighter1_township + `</div>
<small class="text-muted">vs</small>
<div class="fw-bold">` + fixture.fighter2_township + `</div>
</td>
<td>` + fixture.venue_kampala_township + `</td>
<td>` + getFixtureStatusBadge(fixture) + `</td>
<td>` + getUploadStatusBadge(fixture) + `</td>
<td>
<small class="text-muted">
` + new Date(fixture.created_at).toLocaleString() + `
</small>
` + startTimeInfo + `
</td>
<td>
<a href="/fixtures/` + fixture.id + `" class="btn btn-sm btn-outline-primary">
<i class="fas fa-eye me-1"></i>Details
</a>
</td>
`;
tbody.appendChild(row);
});
}
function getFixtureStatusBadge(fixture) {
const status = fixture.fixture_status;
switch (status) {
case 'pending':
return '<span class="badge bg-warning"><i class="fas fa-clock me-1"></i>Pending</span>';
case 'running':
return '<span class="badge bg-info"><i class="fas fa-play me-1"></i>Running</span>';
case 'scheduled':
return '<span class="badge bg-secondary"><i class="fas fa-calendar me-1"></i>Scheduled</span>';
case 'bet':
return '<span class="badge bg-primary"><i class="fas fa-money-bill me-1"></i>Bet</span>';
case 'ingame':
return '<span class="badge bg-success"><i class="fas fa-gamepad me-1"></i>In Game</span>';
case 'end':
return '<span class="badge bg-dark"><i class="fas fa-stop me-1"></i>End</span>';
default:
return '<span class="badge bg-secondary"><i class="fas fa-question me-1"></i>Unknown</span>';
}
}
function getUploadStatusBadge(fixture) {
// Get upload status from the first match in the fixture
if (!fixture.matches || fixture.matches.length === 0) {
return '<span class="badge bg-secondary"><i class="fas fa-clock me-1"></i>Pending</span>';
}
const firstMatch = fixture.matches[0];
const status = firstMatch.zip_upload_status || 'pending';
const progress = firstMatch.zip_upload_progress || 0;
switch (status) {
case 'completed':
return '<span class="badge bg-success"><i class="fas fa-check me-1"></i>Completed</span>';
case 'uploading':
return `<span class="badge bg-info"><i class="fas fa-spinner fa-spin me-1"></i>Uploading (${progress.toFixed(1)}%)</span>`;
case 'failed':
return '<span class="badge bg-danger"><i class="fas fa-times me-1"></i>Failed</span>';
default:
return '<span class="badge bg-secondary"><i class="fas fa-clock me-1"></i>Pending</span>';
}
}
function resetFixtures() {
const confirmMessage = 'WARNING: This will permanently delete ALL fixture data including:\n\n' +
'• All synchronized matches and outcomes\n' +
'• All downloaded ZIP files\n' +
'• This action cannot be undone!\n\n' +
'Are you sure you want to reset all fixtures data?';
if (!confirm(confirmMessage)) {
return;
}
const resetBtn = document.getElementById('reset-fixtures-btn');
const originalText = resetBtn.innerHTML;
resetBtn.disabled = true;
resetBtn.innerHTML = '<i class="fas fa-spinner fa-spin me-1"></i>Resetting...';
fetch('/api/fixtures/reset', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
}
})
.then(response => response.json())
.then(data => {
if (data.success) {
alert(`Fixtures reset successfully!\n\nRemoved:\n• ${data.removed.matches} matches\n• ${data.removed.outcomes} outcomes\n• ${data.removed.zip_files} ZIP files`);
// Reload fixtures to show empty state
loadFixtures();
} else {
alert('Error resetting fixtures: ' + (data.error || 'Unknown error'));
}
})
.catch(error => {
console.error('Error:', error);
alert('Failed to reset fixtures: ' + error.message);
})
.finally(() => {
resetBtn.disabled = false;
resetBtn.innerHTML = originalText;
});
}
test_cashier_complete.py 0 → 100644
View file @ 126fa697
#!/usr/bin/env python3
"""
Complete test for cashier dashboard functionality
"""
import sys
import os
import requests
import json
from pathlib import Path
# Add project root to path
project_root = Path(__file__).parent
sys.path.insert(0, str(project_root))
def test_server_connection():
"""Test if server is running and responding"""
print("=== Testing Server Connection ===")
try:
response = requests.get("http://localhost:8080/", timeout=5, allow_redirects=False)
if response.status_code == 302 and "login" in response.headers.get('Location', ''):
print("✅ Server is running and responding (redirects to login)")
return True
elif response.status_code == 200 and "login" in response.text.lower():
print("✅ Server is running and responding (login page loaded)")
return True
else:
print(f"❌ Unexpected response: {response.status_code}")
return False
except requests.exceptions.RequestException as e:
print(f"❌ Server not responding: {e}")
return False
def test_login():
"""Test login functionality"""
print("\n=== Testing Login ===")
try:
# Test login with cashier credentials
login_data = {
'username': 'cashier',
'password': 'cashier'
}
session = requests.Session()
response = session.post("http://localhost:8080/auth/login", data=login_data, timeout=10)
if response.status_code == 302:
print("✅ Login successful")
return session
else:
print(f"❌ Login failed: {response.status_code}")
return None
except Exception as e:
print(f"❌ Login error: {e}")
return None
def test_api_endpoint(session):
"""Test the cashier pending matches API endpoint"""
print("\n=== Testing API Endpoint ===")
try:
response = session.get("http://localhost:8080/api/cashier/pending-matches", timeout=10)
if response.status_code == 200:
data = response.json()
print("✅ API endpoint responding")
print(f" Response: {json.dumps(data, indent=2)}")
if data.get('success'):
print(f" Total matches: {data.get('total', 0)}")
if data.get('matches'):
print(" Sample matches:")
for i, match in enumerate(data['matches'][:2]):
print(f" {i+1}. {match.get('fighter1_township', 'N/A')} vs {match.get('fighter2_township', 'N/A')}")
return True
else:
print(f" API returned error: {data.get('error', 'Unknown error')}")
return False
else:
print(f"❌ API endpoint failed: {response.status_code}")
return False
except Exception as e:
print(f"❌ API error: {e}")
return False
def test_dashboard_access(session):
"""Test accessing the cashier dashboard"""
print("\n=== Testing Dashboard Access ===")
try:
response = session.get("http://localhost:8080/cashier", timeout=10)
if response.status_code == 200:
print("✅ Dashboard accessible")
# Check if the page contains expected elements
content = response.text
if "Cashier Dashboard" in content:
print(" Contains dashboard title")
if "pending-matches-container" in content:
print(" Contains pending matches container")
if "loadPendingMatches" in content:
print(" Contains JavaScript function")
else:
print(" ⚠️ JavaScript function not found in HTML")
return True
else:
print(f"❌ Dashboard access failed: {response.status_code}")
return False
except Exception as e:
print(f"❌ Dashboard error: {e}")
return False
def main():
"""Run all tests"""
print("Cashier Dashboard Complete Test")
print("=" * 40)
# Test 1: Server connection
if not test_server_connection():
print("\n❌ Server is not running. Please start the server first:")
print(" python main.py --web-port 8080 --screen-cast-port 8081 --no-qt")
return
# Test 2: Login
session = test_login()
if not session:
print("\n❌ Cannot proceed without successful login")
return
# Test 3: API endpoint
api_success = test_api_endpoint(session)
# Test 4: Dashboard access
dashboard_success = test_dashboard_access(session)
# Summary
print("\n" + "=" * 40)
print("SUMMARY:")
print(f"Server Connection: ✅")
print(f"Login: ✅")
print(f"API Endpoint: {'✅' if api_success else '❌'}")
print(f"Dashboard Access: {'✅' if dashboard_success else '❌'}")
if api_success and dashboard_success:
print("\n🎉 All tests passed! The cashier dashboard should be working.")
print("\nTo access the dashboard:")
print("1. Open browser to: http://localhost:8080/cashier")
print("2. Login with: cashier / cashier")
print("3. The pending matches should load automatically")
else:
print("\n❌ Some tests failed. Check the output above for details.")
if __name__ == "__main__":
main()
\ No newline at end of file
test_cashier_simple.py 0 → 100644
View file @ 126fa697
#!/usr/bin/env python3
"""
Simple test for cashier dashboard functionality
"""
import requests
import json
def test_server():
"""Test if server is responding"""
print("=== Testing Server Connection ===")
try:
response = requests.get("http://localhost:8080/", timeout=5, allow_redirects=False)
if response.status_code == 302:
print("OK Server is running and responding (redirects to login)")
return True
else:
print(f"ERROR Unexpected response: {response.status_code}")
return False
except Exception as e:
print(f"ERROR Server not responding: {e}")
return False
def test_login():
"""Test login with cashier credentials"""
print("\n=== Testing Login ===")
try:
session = requests.Session()
# First get the login page to get CSRF token if needed
login_page = session.get("http://localhost:8080/auth/login", timeout=10)
print(f"Login page status: {login_page.status_code}")
# Try login
login_data = {
'username': 'cashier',
'password': 'cashier123'
}
response = session.post("http://localhost:8080/auth/login",
data=login_data,
timeout=10,
allow_redirects=False)
print(f"Login response status: {response.status_code}")
print(f"Login response location: {response.headers.get('Location', 'N/A')}")
if response.status_code == 302 and 'cashier' in response.headers.get('Location', ''):
print("OK Login successful")
return session
else:
print("ERROR Login failed")
return None
except Exception as e:
print(f"ERROR Login error: {e}")
return None
def test_api_endpoint(session):
"""Test the cashier pending matches API"""
print("\n=== Testing API Endpoint ===")
try:
response = session.get("http://localhost:8080/api/cashier/pending-matches", timeout=10)
print(f"API response status: {response.status_code}")
if response.status_code == 200:
data = response.json()
print("OK API endpoint responding")
print(f"Response: {json.dumps(data, indent=2)}")
if data.get('success'):
print(f"Total matches: {data.get('total', 0)}")
if data.get('matches'):
print("Sample matches:")
for i, match in enumerate(data['matches'][:2]):
print(f" {i+1}. {match.get('fighter1_township', 'N/A')} vs {match.get('fighter2_township', 'N/A')}")
return True
else:
print(f"API returned error: {data.get('error', 'Unknown error')}")
return False
else:
print(f"ERROR API endpoint failed: {response.status_code}")
print(f"Response: {response.text[:200]}...")
return False
except Exception as e:
print(f"ERROR API error: {e}")
return False
def main():
"""Run all tests"""
print("Cashier Dashboard Simple Test")
print("=" * 40)
# Test 1: Server connection
if not test_server():
print("\nERROR Server is not running. Please start the server first:")
print(" python main.py --web-port 8080 --screen-cast-port 8081 --no-qt")
return
# Test 2: Login
session = test_login()
if not session:
print("\nERROR Cannot proceed without successful login")
return
# Test 3: API endpoint
api_success = test_api_endpoint(session)
# Summary
print("\n" + "=" * 40)
print("SUMMARY:")
print(f"Server Connection: OK")
print(f"Login: OK")
print(f"API Endpoint: {'OK' if api_success else 'ERROR'}")
if api_success:
print("\nSUCCESS The cashier dashboard API is working!")
print("If the web interface is not showing matches, the issue is likely in the JavaScript.")
else:
print("\nERROR The API is not working. Check server logs for errors.")
if __name__ == "__main__":
main()
\ No newline at end of file
test_dev_message.py 0 → 100644
View file @ 126fa697
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Test script for --dev-message functionality
"""
import sys
import os
from pathlib import Path
# Add the project root to Python path
project_root = Path(__file__).parent
sys.path.insert(0, str(project_root))
from mbetterclient.core.message_bus import MessageBus, Message, MessageType
from mbetterclient.config.settings import AppSettings
def test_dev_message_flag():
"""Test the --dev-message flag functionality"""
print("Testing --dev-message flag functionality")
print("=" * 50)
# Test 1: Normal mode (dev_message=False)
print("\nTest 1: Normal mode (dev_message=False)")
message_bus_normal = MessageBus(dev_message=False)
# Create a test message
test_message = Message(
type=MessageType.START_GAME,
sender="test_component",
data={"fixture_id": "test_123"}
)
print("Publishing message in normal mode...")
message_bus_normal.publish(test_message)
print("Normal mode test completed")
# Test 2: Dev message mode (dev_message=True)
print("\nTest 2: Dev message mode (dev_message=True)")
message_bus_dev = MessageBus(dev_message=True)
print("Publishing message in dev message mode...")
message_bus_dev.publish(test_message)
print("Dev message mode test completed")
# Test 3: Settings integration
print("\nTest 3: Settings integration")
settings = AppSettings()
settings.dev_message = True
message_bus_from_settings = MessageBus(dev_message=settings.dev_message)
print(f"MessageBus created with dev_message={message_bus_from_settings.dev_message}")
print("Settings integration test completed")
print("\nAll tests completed successfully!")
print("\nUsage:")
print(" python main.py --dev-message # Enable dev message mode")
print(" python main.py # Normal mode (default)")
if __name__ == "__main__":
test_dev_message_flag()
\ No newline at end of file
test_js_syntax.py 0 → 100644
View file @ 126fa697
import re
with open('mbetterclient/web_dashboard/templates/dashboard/fixtures.html', 'r') as f:
content = f.read()
# Check for basic HTML structure
if '<!DOCTYPE' in content or content.strip().startswith('<'):
print('HTML template appears to have valid structure')
else:
print('HTML template may have issues')
# Check for JavaScript syntax errors
js_matches = re.findall(r'<script[^>]*>(.*?)</script>', content, re.DOTALL)
if js_matches:
print('Found ' + str(len(js_matches)) + ' script tags')
for i, js in enumerate(js_matches):
try:
compile(js, 'script_' + str(i), 'exec')
print('Script ' + str(i+1) + ': OK')
except SyntaxError as e:
print('Script ' + str(i+1) + ': Syntax error - ' + str(e))
else:
print('No script tags found')
\ No newline at end of file
test_timer.py 0 → 100644
View file @ 126fa697
#!/usr/bin/env python3
"""
Simple test script to verify the timer functionality
"""
import sys
import time
import threading
from pathlib import Path
# Add the project root to Python path
project_root = Path(__file__).parent
sys.path.insert(0, str(project_root))
from mbetterclient.config.settings import AppSettings
from mbetterclient.core.message_bus import MessageBus, MessageType
def test_timer():
"""Test the timer functionality"""
print("Testing timer functionality...")
# Create settings with timer enabled
settings = AppSettings()
settings.timer.enabled = True
settings.timer.delay_minutes = 0.1 # 6 seconds for testing
# Create message bus
message_bus = MessageBus()
# Variables to track messages
start_game_received = [False]
start_game_delayed_received = [False]
def message_handler(message):
if message.type == MessageType.START_GAME:
print(f"✓ START_GAME message received from {message.sender}")
start_game_received[0] = True
# Simulate the application behavior - start timer when START_GAME is received
if settings.timer.enabled:
delay_seconds = settings.timer.delay_minutes * 60
print(f"Starting timer for {delay_seconds} seconds...")
def timer_callback():
print("Timer expired, sending START_GAME_DELAYED message")
from mbetterclient.core.message_bus import MessageBuilder
delayed_message = MessageBuilder.start_game_delayed(
sender="timer",
delay_minutes=settings.timer.delay_minutes
)
message_bus.publish(delayed_message, broadcast=True)
timer = threading.Timer(delay_seconds, timer_callback)
timer.daemon = True
timer.start()
elif message.type == MessageType.START_GAME_DELAYED:
print(f"✓ START_GAME_DELAYED message received from {message.sender}")
start_game_delayed_received[0] = True
# Register handler for both message types
message_bus.subscribe_global(MessageType.START_GAME, message_handler)
message_bus.subscribe_global(MessageType.START_GAME_DELAYED, message_handler)
# Send START_GAME message to trigger the timer
print("Sending START_GAME message to trigger timer...")
from mbetterclient.core.message_bus import MessageBuilder
start_game_message = MessageBuilder.start_game(sender="test_trigger")
message_bus.publish(start_game_message, broadcast=True)
# Wait for the delayed message
delay_seconds = settings.timer.delay_minutes * 60
print(f"Waiting for timer to expire ({delay_seconds} seconds)...")
time.sleep(delay_seconds + 1)
if start_game_received[0] and start_game_delayed_received[0]:
print("✓ Test PASSED: Both START_GAME and START_GAME_DELAYED messages were received")
return True
else:
print(f"✗ Test FAILED: START_GAME received: {start_game_received[0]}, START_GAME_DELAYED received: {start_game_delayed_received[0]}")
return False
if __name__ == "__main__":
success = test_timer()
sys.exit(0 if success else 1)
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment