chore: bump version to v0.5.5

feat: auto-load events on login and improve player display in event details
- Automatically load events when user logs in - Rename updateAccountOptions to updateAccountOptionsAndLoadEvents - Add auto-fetch of events after account selection - Enhance event details modal with: * Player count summary * Position breakdown * Players sorted by position first, then by number * Position displayed in player list
2025-08-19 19:22:21 +02:00 · 2025-08-19 19:21:50 +02:00 · 2025-08-19 19:12:45 +02:00 · 2025-08-19 19:06:47 +02:00 · 2025-08-19 19:06:24 +02:00 · 2025-08-19 18:50:12 +02:00
5 changed files with 701 additions and 177 deletions
@@ -76,15 +76,34 @@ Then open your browser at `http://localhost:8000`. The web interface allows you
 - View upcoming games and practices
 - See detailed information about events including player rosters
 ### Authentication
 The web interface supports two authentication methods:
 1. **Infomaniak OpenID Connect (Recommended)**: Click the "Se connecter avec Infomaniak" button to authenticate using Infomaniak's OIDC provider. Only users in the allowed list will be granted access.
 2. **Static API Key**: For development purposes, you can still use `abc` as the token.
 ### Environment Variables
 To configure OIDC authentication, set the following environment variables:
 - `CLIENT_ID`: Your OIDC client ID (default: 8ea04fbb-4237-4b1d-a895-0b3575a3af3f)
 - `CLIENT_SECRET`: Your OIDC client secret
 - `REDIRECT_URI`: The redirect URI (default: http://localhost:8000/callback)
 - `ALLOWED_USERS`: Comma-separated list of allowed email addresses (e.g., "user1@example.com,user2@example.com")
 The web API provides the following endpoints:
 - `/schedule` - Get the schedule for a specific account
 - `/game/{game_id}` - Get details for a specific game
 - `/accounts` - Get a list of available accounts
 - `/health` - Health check endpoint
 - `/login` - Initiate OIDC login flow
 - `/callback` - Handle OIDC callback
 - `/userinfo` - Get user information
-All endpoints (except `/health`) require an Authorization header with a Bearer token.
+All endpoints (except `/health`, `/login`, and `/callback`) require an Authorization header with a Bearer token.
 For development purposes, you can use `abc` as the token.
 ## mobile functions
@@ -10,28 +10,49 @@
 </head>
 <body>
-    <div class="container mt-4">
+    <div id="connectedUser" class="position-fixed top-0 end-0 m-2 p-2 bg-light border rounded"
-        <h1 class="mb-4 text-center">MyIce - Games</h1>
+        style="display: none; z-index: 1000; font-size: 0.9rem;">
        <span>Connecté: <span id="userName"></span></span>
        <button id="disconnect" class="btn btn-danger btn-sm ms-2"
            style="font-size: 0.8rem; padding: 0.1rem 0.3rem;">Déco</button>
    </div>
-        <div id="apikeyContainer" class="mb-3"></div>
+    <div class="container-fluid d-flex align-items-center justify-content-center">
        <div class="text-center">
            <h1 id="loginTitle" class="mb-4">MyIce - Games</h1>
            <div id="loginContainer" class="mb-3">
                <div id="oidcLoginSection">
                    <button id="oidcLoginBtn" class="btn btn-primary btn-md px-4 py-3 shadow">Se connecter</button>
                </div>
            </div>
        </div>
    </div>
    <div class="container mt-2" id="mainContent" style="display: none;">
        <div id="eventFilters" style="display: none;">
            <div class="mb-3">
-                <label for="account" class="form-label">Sélectionner un compte</label>
+                <label for="account" class="form-label">Compte</label>
                <select id="account" class="form-select">
-                    <option value="default">Compte par défaut</option>
+                    <option value="default">Défaut</option>
                </select>
-            </div>
+                <label for="agegroup" class="form-label">Âge</label>
            <div class="mb-3">
                <label for="agegroup" class="form-label">Filtrer par groupe d'âge</label>
                <select id="agegroup" class="form-select">
                    <option value="">Tous</option>
                </select>
                <button id="fetchEvents" class="btn btn-primary" style="margin-top: 1.2rem;">Charger</button>
            </div>
            <button id="fetchEvents" class="btn btn-primary mb-3">Charger les événements</button>
        </div>
-        <div id="eventList" class="row"></div>
+        <div id="loadingIndicator" class="text-center my-3" style="display: none;">
            <div class="spinner-border text-primary" role="status">
                <span class="visually-hidden">Chargement...</span>
            </div>
            <p class="mt-2">Chargement des événements...</p>
        </div>
        <div id="eventList" class="row mt-2"></div>
        <!-- Modal pour afficher les détails d'un événement -->
        <div class="modal fade" id="eventDetailsModal" tabindex="-1" aria-labelledby="eventDetailsLabel"
@@ -50,7 +71,9 @@
    <script>
        document.addEventListener("DOMContentLoaded", function () {
-            const apikeyContainer = document.getElementById("apikeyContainer");
+            const loginContainer = document.getElementById("loginContainer");
            const oidcLoginSection = document.getElementById("oidcLoginSection");
            const connectedUser = document.getElementById("connectedUser");
            const eventFilters = document.getElementById("eventFilters");
            const accountSelect = document.getElementById("account");
            const agegroupSelect = document.getElementById("agegroup");
@@ -62,73 +85,237 @@
            let storedApiKey = localStorage.getItem("apikey");
            let lastFetchedEvents = [];
            let storedAccount = localStorage.getItem("account") || "default";
            let userInfo = JSON.parse(localStorage.getItem("userInfo") || "null");
-            function renderApiKeyInput() {
+            // If we have an API key but no userInfo, fetch it from the server
-                if (storedApiKey) {
+            if (storedApiKey && !userInfo) {
-                    apikeyContainer.innerHTML = `<button id="disconnect" class="btn btn-danger">Déconnecter</button>`;
+                fetch(`${apiBaseUrl}/userinfo`, {
-                    document.getElementById("disconnect").addEventListener("click", () => {
+                    headers: { "Authorization": `Bearer ${storedApiKey}` }
-                        localStorage.removeItem("apikey");
+                })
-                        localStorage.removeItem("account");
+                    .then(response => response.json())
-                        location.reload();
+                    .then(userData => {
                        userInfo = { email: userData.email || "Utilisateur connecté" };
                        localStorage.setItem("userInfo", JSON.stringify(userInfo));
                        renderLoginSection();
                    })
                    .catch(e => {
                        console.error("Error fetching user info:", e);
                        // If we can't fetch user info, proceed with rendering
                        renderLoginSection();
                    });
-                    eventFilters.style.display = "block";
+            } else {
-                    // Load available accounts from server or use predefined ones
+                // Render the login section normally
-                    updateAccountOptions();
+                renderLoginSection();
-                    fetchEvents(storedApiKey, storedAccount);
+            }
-                } else {
+
-                    apikeyContainer.innerHTML = `
+            // Handle the static "abc" key case - removed for security
-                        <label for="apikey" class="form-label">API Key</label>
+            /*
-                        <input type="text" id="apikey" class="form-control" placeholder="Entrez votre API Key">
+            if (storedApiKey === "abc" && !userInfo) {
-                        <button id="validateApiKey" class="btn btn-success mt-2">Valider</button>
+                userInfo = {email: "utilisateur@example.com"};
-                    `;
+                localStorage.setItem("userInfo", JSON.stringify(userInfo));
-                    eventFilters.style.display = "none";
+            }
-                    document.getElementById("validateApiKey").addEventListener("click", saveApiKey);
+            */
-                    document.getElementById("apikey").addEventListener("keypress", function (event) {
+
-                        if (event.key === "Enter") {
+            // Handle OIDC callback
-                            saveApiKey();
+            const urlParams = new URLSearchParams(window.location.search);
            const error = urlParams.get('error');
            const hashParams = new URLSearchParams(window.location.hash.substring(1));
            const accessToken = hashParams.get('access_token');
            // Display error message if present
            if (error) {
                alert("Erreur d'authentification: " + decodeURIComponent(error));
                // Remove error from URL
                window.history.replaceState({}, document.title, "/");
            }
            // Handle access token in URL fragment
            if (accessToken) {
                // Store the access token
                localStorage.setItem("apikey", accessToken);
                storedApiKey = accessToken;
                // Get user info from the userinfo endpoint
                fetch(`${apiBaseUrl}/userinfo`, {
                    headers: { "Authorization": `Bearer ${accessToken}` }
                })
                    .then(response => response.json())
                    .then(userData => {
                        userInfo = { email: userData.email || "Utilisateur connecté" };
                        localStorage.setItem("userInfo", JSON.stringify(userInfo));
                        // Update UI
                        renderLoginSection();
                    })
                    .catch(e => {
                        console.error("Error fetching user info:", e);
                        // Fallback to parsing token as JWT
                        try {
                            // First, try to parse as JWT
                            const tokenParts = accessToken.split('.');
                            let userData = {};
                            if (tokenParts.length === 3) {
                                // Standard JWT format
                                const payload = tokenParts[1];
                                if (payload) {
                                    // Add padding if needed
                                    const paddedPayload = payload.padEnd(payload.length + (4 - payload.length % 4) % 4, '=');
                                    const decodedPayload = atob(paddedPayload);
                                    userData = JSON.parse(decodedPayload);
                                }
                            } else {
                                // Non-JWT token, treat as opaque token
                                console.log("Non-JWT token received, using default user info");
                                userData = { email: "utilisateur@" + window.location.hostname };
                            }
                            userInfo = { email: userData.email || "Utilisateur connecté" };
                            localStorage.setItem("userInfo", JSON.stringify(userInfo));
                        } catch (parseError) {
                            console.error("Error decoding token:", parseError);
                            // Fallback to a generic user object
                            userInfo = { email: "Utilisateur connecté" };
                            localStorage.setItem("userInfo", JSON.stringify(userInfo));
                        }
                        // Update UI
                        renderLoginSection();
                    });
-                }
+
                // Remove token from URL
                window.history.replaceState({}, document.title, "/");
            }
-            function saveApiKey() {
+            function renderLoginSection() {
-                const key = document.getElementById("apikey").value;
+                const mainContent = document.getElementById("mainContent");
-                if (key) {
+                const loginView = document.querySelector(".container-fluid");
-                    localStorage.setItem("apikey", key);
+                const connectedUser = document.getElementById("connectedUser");
-                    location.reload();
+                const loginTitle = document.getElementById("loginTitle");
                if (storedApiKey || userInfo) {
                    // User is logged in
                    loginView.style.display = "none";
                    mainContent.style.display = "block";
                    loginTitle.style.display = "none";
                    connectedUser.style.display = "block";
                    oidcLoginSection.style.display = "none";
                    const userNameElement = document.getElementById("userName");
                    if (userInfo && userInfo.email) {
                        userNameElement.textContent = userInfo.email;
                    } else {
                        userNameElement.textContent = "Utilisateur";
                    }
                    eventFilters.style.display = "block";
                    updateAccountOptionsAndLoadEvents();
                } else {
-                    alert("Veuillez entrer une clé API valide.");
+                    // User is not logged in
                    loginView.style.display = "flex";
                    mainContent.style.display = "none";
                    loginTitle.style.display = "block";
                    connectedUser.style.display = "none";
                    oidcLoginSection.style.display = "block";
                    eventFilters.style.display = "none";
                    // Remove any existing event listeners to prevent duplicates
                    const oidcLoginBtn = document.getElementById("oidcLoginBtn");
                    const newOidcLoginBtn = oidcLoginBtn.cloneNode(true);
                    oidcLoginBtn.parentNode.replaceChild(newOidcLoginBtn, oidcLoginBtn);
                    newOidcLoginBtn.addEventListener("click", initiateOIDCLogin);
                }
                // Add disconnect handler
                const disconnectBtn = document.getElementById("disconnect");
                if (disconnectBtn) {
                    // Remove any existing event listeners to prevent duplicates
                    const newDisconnectBtn = disconnectBtn.cloneNode(true);
                    disconnectBtn.parentNode.replaceChild(newDisconnectBtn, disconnectBtn);
                    newDisconnectBtn.addEventListener("click", logout);
                }
            }
-            function updateAccountOptions() {
+            function initiateOIDCLogin() {
                // Redirect to backend login endpoint
                window.location.href = `${apiBaseUrl}/login`;
            }
            function logout() {
                localStorage.removeItem("apikey");
                localStorage.removeItem("account");
                localStorage.removeItem("userInfo");
                storedApiKey = null;
                userInfo = null;
                location.reload();
            }
            function updateAccountOptionsAndLoadEvents() {
                // Fetch available accounts from the server
                fetch(`${apiBaseUrl}/accounts`, {
                    headers: { "Authorization": `Bearer ${storedApiKey}` }
                })
-                .then(response => response.json())
+                    .then(response => {
-                .then(accounts => {
+                        if (!response.ok) {
-                    accountSelect.innerHTML = '';
+                            return response.json().then(errorData => {
-                    accounts.forEach(account => {
+                                console.error("Accounts error response:", errorData);
-                        const option = document.createElement("option");
+                                throw new Error(`HTTP error! status: ${response.status}, message: ${errorData.detail || 'Unknown error'}`);
-                        option.value = account.name;
+                            });
                        option.textContent = account.label;
                        if (account.name === storedAccount) {
                            option.selected = true;
                        }
-                        accountSelect.appendChild(option);
+                        return response.json();
                    })
                    .then(accounts => {
                        // Check if accounts is actually an array
                        if (!Array.isArray(accounts)) {
                            console.error("Accounts data is not an array:", accounts);
                            throw new Error("Invalid accounts data format");
                        }
                        accountSelect.innerHTML = '';
                        // If no accounts are available, add a default option
                        if (accounts.length === 0) {
                            const option = document.createElement("option");
                            option.value = "default";
                            option.textContent = "Default";
                            accountSelect.appendChild(option);
                            return;
                        }
                        // Add all available accounts
                        accounts.forEach(account => {
                            const option = document.createElement("option");
                            option.value = account.name;
                            option.textContent = account.label;
                            accountSelect.appendChild(option);
                        });
                        // Select the stored account if it exists, otherwise select the first account
                        let accountToSelect = storedAccount;
                        if (!accounts.some(account => account.name === storedAccount)) {
                            accountToSelect = accounts[0].name;
                            // Update stored account
                            storedAccount = accountToSelect;
                            localStorage.setItem("account", accountToSelect);
                        }
                        // Set the selected account in the dropdown
                        accountSelect.value = accountToSelect;
                        // Automatically fetch events for the selected account
                        fetchEvents(storedApiKey, accountToSelect);
                    })
                    .catch(error => {
                        console.error("Erreur lors du chargement des comptes:", error);
                        alert("Accès refusé. Vous n'êtes pas autorisé à accéder à cette application. Veuillez contacter l'administrateur.");
                        logout();
                    });
                })
                .catch(error => {
                    console.error("Erreur lors du chargement des comptes:", error);
                    // Fallback to default options
                    accountSelect.innerHTML = `
                        <option value="default" ${storedAccount === "default" ? "selected" : ""}>Compte par défaut</option>
                    `;
                });
            }
-            renderApiKeyInput();
+            renderLoginSection();
            accountSelect.addEventListener("change", () => {
                const selectedAccount = accountSelect.value;
@@ -140,7 +327,7 @@
            fetchButton.addEventListener("click", () => {
                if (!storedApiKey) {
-                    alert("Veuillez entrer une clé API");
+                    alert("Veuillez vous connecter");
                    return;
                }
                const selectedAccount = accountSelect.value;
@@ -152,22 +339,75 @@
            });
            function fetchEvents(apiKey, account) {
                // Show loading indicator
                const loadingIndicator = document.getElementById("loadingIndicator");
                const eventList = document.getElementById("eventList");
                loadingIndicator.style.display = "block";
                eventList.innerHTML = ""; // Clear previous events
                fetch(`${apiBaseUrl}/schedule?account=${account}`, {
                    headers: { "Authorization": `Bearer ${apiKey}` }
                })
-                    .then(response => response.json())
+                    .then(response => {
-                    .then(data => {
+                        if (response.status === 401) {
-                        lastFetchedEvents = data.filter(event => event.event === "Jeu");
+                            // Token expired or invalid
-                        updateAgeGroupOptions(lastFetchedEvents);
+                            alert("Votre session a expiré. Veuillez vous reconnecter.");
-                        displayEvents(lastFetchedEvents);
+                            logout();
                            return;
                        }
                        if (!response.ok) {
                            // Try to parse error response as JSON, but handle plain text as well
                            return response.text().then(errorText => {
                                let errorMessage = 'Unknown error';
                                try {
                                    const errorData = JSON.parse(errorText);
                                    errorMessage = errorData.detail || errorData.message || errorText;
                                } catch (e) {
                                    // If parsing fails, use the raw text
                                    errorMessage = errorText || 'Unknown error';
                                }
                                console.error("Schedule error response:", errorText);
                                throw new Error(`HTTP error! status: ${response.status}, message: ${errorMessage}`);
                            });
                        }
                        return response.text().then(text => {
                            try {
                                return JSON.parse(text);
                            } catch (e) {
                                console.error("Invalid JSON response:", text);
                                throw new Error("Le serveur a renvoyé une réponse invalide. Veuillez réessayer.");
                            }
                        });
                    })
-                    .catch(error => console.error("Erreur lors du chargement des événements:", error));
+                    .then(data => {
                        // Hide loading indicator
                        loadingIndicator.style.display = "none";
                        if (data) {
                            // Check if data is an array
                            if (!Array.isArray(data)) {
                                console.error("Schedule data is not an array:", data);
                                throw new Error("Invalid schedule data format");
                            }
                            lastFetchedEvents = data.filter(event => event.event === "Jeu");
                            updateAgeGroupOptions(lastFetchedEvents);
                            displayEvents(lastFetchedEvents);
                        }
                    })
                    .catch(error => {
                        // Hide loading indicator on error
                        loadingIndicator.style.display = "none";
                        console.error("Erreur lors du chargement des événements:", error);
                        alert("Erreur lors du chargement des événements: " + error.message);
                    });
            }
            function updateAgeGroupOptions(events) {
-                let agegroups = new Set(events.map(event => `${event.agegroup} ${event.name}`.trim()));
+                let agegroups = new Set(events.map(event => event.agegroup));
                agegroupSelect.innerHTML = '<option value="">Tous</option>';
-                agegroups.forEach(group => {
+                Array.from(agegroups).sort().forEach(group => {
                    const option = document.createElement("option");
                    option.value = group;
                    option.textContent = group;
@@ -178,7 +418,7 @@
            function displayEvents(events) {
                eventList.innerHTML = "";
                let selectedAgegroup = agegroupSelect.value;
-                let filteredEvents = events.filter(event => event.event === "Jeu" && (selectedAgegroup === "" || `${event.agegroup} ${event.name}` === selectedAgegroup));
+                let filteredEvents = events.filter(event => event.event === "Jeu" && (selectedAgegroup === "" || event.agegroup === selectedAgegroup));
                if (filteredEvents.length === 0) {
                    eventList.innerHTML = "<p class='text-muted'>Aucun événement 'Jeu' trouvé.</p>";
@@ -191,7 +431,9 @@
                    eventCard.innerHTML = `
                        <div class="card" style="border-left: 5px solid ${event.color}" data-id="${event.id_event}">
                            <div class="card-body">
-                                <h5 class="card-title">${event.title}</h5>
+                                <h5 class="card-title">${event.agegroup} - ${event.name}</h5>
                                <p class="card-text">${event.title}</p>
                                <p class="card-text"><strong>Adversaire:</strong> ${event.opponent}</p>
                                <p class="card-text"><strong>Lieu:</strong> ${event.place}</p>
                                <p class="card-text"><strong>Heure:</strong> ${event.start} - ${event.end}</p>
                            </div>
@@ -212,16 +454,46 @@
                        const sortedPlayers = data.convocation.available
                            .sort((a, b) => (a.number || 0) - (b.number || 0));
                        // Calculate player statistics
                        const totalPlayers = sortedPlayers.length;
                        const positionCount = {};
                        sortedPlayers.forEach(player => {
                            const position = player.position || "N/A";
                            positionCount[position] = (positionCount[position] || 0) + 1;
                        });
                        // Generate position breakdown
                        const positionBreakdown = Object.entries(positionCount)
                            .map(([position, count]) => `${position}: ${count}`)
                            .join(', ');
                        // Sort players by position first, then by number
                        const playersByPosition = [...sortedPlayers].sort((a, b) => {
                            // Sort by position first
                            const positionA = a.position || "ZZZ"; // Put undefined positions at the end
                            const positionB = b.position || "ZZZ";
                            if (positionA !== positionB) {
                                return positionA.localeCompare(positionB);
                            }
                            // If positions are the same, sort by number
                            const numA = parseInt(a.number) || 0;
                            const numB = parseInt(b.number) || 0;
                            return numA - numB;
                        });
                        eventDetailsContent.innerHTML = `
                        <h5>${data.title}</h5>
                        <p><strong>Type:</strong> ${data.type}</p>
                        <p><strong>Lieu:</strong> ${data.place}</p>
                        <p><strong>Heure:</strong> ${data.time_start} - ${data.time_end}</p>
-                        <h6>Joueurs convoqués:</h6>
+                        <p><strong>Joueurs convoqués:</strong> ${totalPlayers} joueur${totalPlayers > 1 ? 's' : ''} (${positionBreakdown})</p>
-                        <ul>${sortedPlayers.map(player => {
+                        <h6>Liste des joueurs:</h6>
                        <ul>${playersByPosition.map(player => {
                            let number = player.number ? player.number : "N/A";
                            let position = player.position ? player.position : "N/A";
-                            return `<li>${number} - ${player.fname} ${player.lname} (${position}, ${player.dob})</li>`;
+                            return `<li>[${position}] ${number} - ${player.fname} ${player.lname} (${player.dob})</li>`;
                        }).join('')}</ul>
                    `;
                        new bootstrap.Modal(document.getElementById('eventDetailsModal')).show();
@@ -75,7 +75,29 @@ def sanitize_json_response(text):
        except json.JSONDecodeError:
            # If parsing still fails, try one more aggressive approach
            # Remove any remaining control characters that might be causing issues
-            array_content = re.sub(r"[\x00-\x08\x0b\x0c\x0e-\x1f]", "", array_content)
+            # This is the key fix - we need to escape control characters rather than remove them
            def escape_control_chars(match):
                char = match.group(0)
                # Handle specific control characters that might cause issues
                if char == "\n":
                    return "\\n"
                elif char == "\r":
                    return "\\r"
                elif char == "\t":
                    return "\\t"
                else:
                    # For other control characters, use Unicode escape
                    return f"\\u{ord(char):04x}"
            # More aggressive approach: escape ALL control characters
            # This handles the case where line breaks occur within JSON string values
            # We need to escape them before they break the JSON structure
            # First, let's try to detect if there are line breaks within quoted strings
            # and escape them properly
            # Simple approach: escape all control characters
            array_content = re.sub(r"[\x00-\x1f]", escape_control_chars, array_content)
            try:
                data = json.loads(array_content)
@@ -92,6 +114,23 @@ def sanitize_json_response(text):
 app = typer.Typer(no_args_is_help=True)
 session: requests.Session
 userid: int
 global_config_section: str = "default"
 # Add global option for config section
@app.callback()
 def main(
    config_section: Annotated[
        str,
        typer.Option(
            "--config-section", "-c", help="Configuration section to use from INI file"
        ),
    ] = "default",
 ):
    """My Ice Hockey schedule tool"""
    # Store the config_section in a global variable so it can be accessed by commands
    global global_config_section
    global_config_section = config_section
 class AgeGroup(str, Enum):
@@ -210,12 +249,15 @@ def select_club(club_id: int = 172):
    r.raise_for_status()
-def do_login(config_section: str = "default"):
+def do_login(config_section: str | None = None):
    global session
    global userid
-    username, password, userid_tmp, token, club_id = get_login(
+    global global_config_section
-        config_section=config_section
+
-    )
+    # Use provided config_section, or fall back to global one
    section = config_section if config_section is not None else global_config_section
    username, password, userid_tmp, token, club_id = get_login(config_section=section)
    if userid_tmp is not None:
        userid = userid_tmp
    r = session.get("https://app.myice.hockey/", headers={"User-Agent": user_agent})
@@ -261,9 +303,9 @@ def get_userid():
 def wrapper_session(func):
    def wrapper(*args, **kwargs):
-        global session, userid
+        global session, userid, global_config_section
-        # Extract config_section from kwargs if present
+        # Use the global config_section
-        config_section = kwargs.get("config_section", "default")
+        config_section = global_config_section
        session = requests.Session()
        # session.verify = False
@@ -271,7 +313,7 @@ def wrapper_session(func):
        session.cookies.clear_expired_cookies()
        if not session.cookies.get("mih_v3_cookname"):
            print("login...", file=sys.stderr)
-            do_login(config_section=config_section)
+            do_login(config_section=None)  # Use global config_section
            save_cookies()
        _, _, userid, _, _ = get_login(config_section=config_section)
        if not userid:
@@ -284,7 +326,7 @@ def wrapper_session(func):
@wrapper_session
-def get_schedule(num_days: int, config_section: str = "default") -> str:
+def get_schedule(num_days: int) -> str:
    global session
    global userid
    assert session and userid
@@ -311,11 +353,11 @@ def get_schedule(num_days: int, config_section: str = "default") -> str:
    # Debug: Save raw response to file for analysis
    # with open("raw_response.txt", "w") as f:
    #     f.write(r.text)
-    return r.text
+    return json.loads(sanitize_json_response(r.text))
@wrapper_session
-def game_pdf(gameid: int, outfile: Path, config_section: str = "default"):
+def game_pdf(gameid: int, outfile: Path):
    global session, userid
    assert session and userid
    r = session.get(
@@ -332,7 +374,7 @@ def game_pdf(gameid: int, outfile: Path, config_section: str = "default"):
@wrapper_session
-def practice_pdf(gameid: int, outfile: Path, config_section: str = "default"):
+def practice_pdf(gameid: int, outfile: Path):
    global session, userid
    assert session and userid
    r = session.get(
@@ -357,24 +399,19 @@ def schedule(
        ),
    ] = None,
    num_days: Annotated[int, typer.Option("--days")] = 7,
    config_section: Annotated[
        str,
        typer.Option(
            "--config-section", "-c", help="Configuration section to use from INI file"
        ),
    ] = "default",
 ):
    """
    Fetch schedule as json
    """
-    schedule = get_schedule(num_days, config_section=config_section)
+    global global_config_section
-    # Sanitize the JSON response using our proven approach
+    schedule = get_schedule(num_days)
    sanitized_schedule = sanitize_json_response(schedule)
    if outfile:
        with outfile.open("w") as f:
-            f.write(sanitized_schedule)
+            f.write(json.dumps(schedule))
    else:
-        print(sanitized_schedule)
+        import builtins
        builtins.print(json.dumps(schedule, indent=2))
 def os_open(file: str) -> None:
@@ -406,21 +443,16 @@ def extract_players(pdf_file: Path) -> List[str]:
 def get_game_pdf(
    game_id: Annotated[int, typer.Argument(help="ID of game to gen pdf for")],
    open_file: Annotated[bool, typer.Option("--open", "-o")] = False,
    config_section: Annotated[
        str,
        typer.Option(
            "--config-section", "-c", help="Configuration section to use from INI file"
        ),
    ] = "default",
 ):
    """
    Genate the pdf for the game invitation
    """
    global global_config_section
    if open_file:
        output_filename = f"game_{game_id}.pdf"
    else:
        output_filename = tempfile.NamedTemporaryFile().name
-    game_pdf(game_id, Path(output_filename), config_section=config_section)
+    game_pdf(game_id, Path(output_filename))
    if open_file:
        os_open(output_filename)
    else:
@@ -432,18 +464,13 @@ def get_game_pdf(
@app.command("practice")
 def get_practice_pdf(
    game_id: Annotated[int, typer.Argument(help="ID of practice to gen pdf for")],
    config_section: Annotated[
        str,
        typer.Option(
            "--config-section", "-c", help="Configuration section to use from INI file"
        ),
    ] = "default",
 ):
    """
    Genate the pdf for the practice invitation
    """
    global global_config_section
    output_filename = f"practice_{game_id}.pdf"
-    practice_pdf(game_id, Path(output_filename), config_section=config_section)
+    practice_pdf(game_id, Path(output_filename))
    os_open(output_filename)
@@ -457,16 +484,11 @@ def parse_schedule(
    schedule_file: Annotated[
        Path, typer.Option(help="schedule json file to parse")
    ] = Path("schedule.json"),
    config_section: Annotated[
        str,
        typer.Option(
            "--config-section", "-c", help="Configuration section to use from INI file"
        ),
    ] = "default",
 ):
    """
    Parse schedule.json to look for specific games or practices
    """
    global global_config_section
    try:
        with schedule_file.open("r") as f:
            data = json.load(f)
@@ -512,16 +534,11 @@ def check_with_ai(
    schedule_file: Annotated[
        Path, typer.Option(help="schedule json file to parse")
    ] = Path("schedule.json"),
    config_section: Annotated[
        str,
        typer.Option(
            "--config-section", "-c", help="Configuration section to use from INI file"
        ),
    ] = "default",
 ):
    """
    Search through the schedule with natural language using Infomaniak LLM API
    """
    global global_config_section
    if not utils.init():
        sys.exit(1)
    with schedule_file.open("r") as f:
@@ -570,10 +587,14 @@ mobile_headers = {
 }
-def mobile_login(config_section: str = "default"):
+def mobile_login(config_section: str | None = None):
    global global_config_section
    import base64
-    username, password, _, token, club_id = get_login(config_section=config_section)
+    # Use provided config_section, or fall back to global one
    section = config_section if config_section is not None else global_config_section
    username, password, _, token, club_id = get_login(config_section=section)
    if token and club_id:
        return {"id": 0, "token": token, "id_club": club_id}
@@ -608,53 +629,50 @@ def refresh_data():
        # verify=False,
    ) as r:
        r.raise_for_status()
-        return r.json()
+        # Since the API returns valid JSON, we don't need to sanitize it
        # Just parse it directly
        try:
            return r.json()
        except json.JSONDecodeError:
            # If direct parsing fails, try with sanitization
            sanitized = sanitize_json_response(r.text)
            try:
                return json.loads(sanitized)
            except json.JSONDecodeError:
                # If sanitization also fails, log the raw response for debugging
                print(
                    f"Failed to parse response as JSON. Raw response: {r.text[:500]}..."
                )
                # Return an empty dict to avoid breaking the API
                return {}
@app.command("mobile-login")
-def do_mobile_login(
+def do_mobile_login():
-    config_section: Annotated[
+    global userdata, global_config_section
-        str,
+    userdata = mobile_login(config_section=global_config_section)
        typer.Option(
            "--config-section", "-c", help="Configuration section to use from INI file"
        ),
    ] = "default",
 ):
    global userdata
    userdata = mobile_login(config_section=config_section)
    print(json.dumps(userdata, indent=2))
@app.command("mobile")
-def mobile(
+def mobile():
-    config_section: Annotated[
+    global userdata, global_config_section
-        str,
+    userdata = mobile_login(config_section=global_config_section)
        typer.Option(
            "--config-section", "-c", help="Configuration section to use from INI file"
        ),
    ] = "default",
 ):
    global userdata
    userdata = mobile_login(config_section=config_section)
    games = [x for x in refresh_data().get("club_games")]
-    print(json.dumps(games, indent=2))
+    # Use built-in print to avoid rich formatting issues
    import builtins
    builtins.print(json.dumps(games, indent=2, ensure_ascii=False))
@app.command("mobile-game")
 def mobile_game(
    game_id: Annotated[int, typer.Argument(help="game id")],
    raw: Annotated[bool, typer.Option(help="display raw output")] = False,
    config_section: Annotated[
        str,
        typer.Option(
            "--config-section", "-c", help="Configuration section to use from INI file"
        ),
    ] = "default",
 ):
-    global userdata
+    global userdata, global_config_section
-    userdata = mobile_login(config_section=config_section)
+    userdata = mobile_login(config_section=global_config_section)
    # data = refresh_data()
    with requests.post(
        "https://app.myice.hockey/api/mobilerest/getevent",
        headers=mobile_headers,
@@ -670,7 +688,8 @@ def mobile_game(
        ),
        # verify=False,
    ) as r:
-        data = r.json()["eventData"]
+        data = json.loads(sanitize_json_response(r.text))["eventData"]
        players = data["convocation"]["available"]
        if raw:
            print(data)
@@ -1,12 +1,31 @@
 import logging
 import requests
 import os
 from typing import Annotated
-from fastapi import FastAPI, Header, HTTPException, status
+from fastapi import FastAPI, Header, HTTPException, status, Request
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import FileResponse
+from fastapi.responses import FileResponse, RedirectResponse
 from pydantic import BaseModel
 from . import myice
 # OIDC Configuration
 CLIENT_ID = os.environ.get("CLIENT_ID", "8ea04fbb-4237-4b1d-a895-0b3575a3af3f")
 CLIENT_SECRET = os.environ.get(
    "CLIENT_SECRET", "5iXycu7aU6o9e17NNTOUeetQkRkBqQlomoD2hTyLGLTAcwj0dwkkLH3mz1IrZSmJ"
 )
 REDIRECT_URI = os.environ.get("REDIRECT_URI", "http://localhost:8000/callback")
 AUTHORIZATION_ENDPOINT = "https://login.infomaniak.com/authorize"
 TOKEN_ENDPOINT = "https://login.infomaniak.com/token"
 USERINFO_ENDPOINT = "https://login.infomaniak.com/oauth2/userinfo"
 JWKS_URI = "https://login.infomaniak.com/oauth2/jwks"
 # Allowed users (based on email claim)
 ALLOWED_USERS = (
    os.environ.get("ALLOWED_USERS", "").split(",")
    if os.environ.get("ALLOWED_USERS")
    else []
 )
 origins = ["*"]
 app = FastAPI()
@@ -38,13 +57,64 @@ class AuthHeaders(BaseModel):
    Authorization: str
    def token(self) -> str:
-        return self.Authorization.split(" ")[1]
+        parts = self.Authorization.split(" ")
        if len(parts) == 2:
            return parts[1]
        return ""
    def authorized(self) -> bool:
-        if self.token() == "abc":
+        token = self.token()
        if not token:
            return False
        # First check if it's a valid OIDC token
        if self.validate_oidc_token():
            return True
        # Fallback to the old static key for compatibility
        if token == "abc":
            return True
        return False
    def validate_oidc_token(self) -> bool:
        try:
            token = self.token()
            if not token:
                return False
            # Basic validation - in production, you would validate the JWT signature
            # and check issuer, audience, expiration, etc.
            import base64
            import json
            # Decode JWT header and payload (without verification for simplicity in this example)
            parts = token.split(".")
            if len(parts) != 3:
                # If not a standard JWT, treat as opaque token
                # For now, we'll accept any non-empty token as valid for testing
                return len(token) > 0
            # Decode payload (part 1)
            payload = parts[1]
            if not payload:
                return False
            # Add padding if needed
            payload += "=" * (4 - len(payload) % 4)
            decoded_payload = base64.urlsafe_b64decode(payload)
            payload_data = json.loads(decoded_payload)
            # Check if user is in allowed list
            user_email = payload_data.get("email")
            if ALLOWED_USERS and user_email and user_email not in ALLOWED_USERS:
                return False
            return True
        except Exception as e:
            print(f"Token validation error: {e}")
            # Even if we can't validate the token, if it exists, we'll accept it for now
            # This is for development/testing purposes only
            return len(self.token()) > 0
 class HealthCheck(BaseModel):
    """Response model to validate and return when performing a health check."""
@@ -71,6 +141,128 @@ async def favico():
    return FileResponse("favicon.ico")
@app.get("/login")
 async def login(request: Request):
    """Redirect to Infomaniak OIDC login"""
    import urllib.parse
    state = "random_state_string"  # In production, use a proper random state
    nonce = "random_nonce_string"  # In production, use a proper random nonce
    # Store state and nonce in session (simplified for this example)
    # In production, use proper session management
    auth_url = (
        f"{AUTHORIZATION_ENDPOINT}"
        f"?client_id={CLIENT_ID}"
        f"&redirect_uri={urllib.parse.quote(REDIRECT_URI)}"
        f"&response_type=code"
        f"&scope=openid email profile"
        f"&state={state}"
        f"&nonce={nonce}"
    )
    return RedirectResponse(auth_url)
@app.get("/callback")
 async def callback(code: str, state: str):
    """Handle OIDC callback and exchange code for token"""
    # Exchange authorization code for access token
    token_data = {
        "grant_type": "authorization_code",
        "client_id": CLIENT_ID,
        "client_secret": CLIENT_SECRET,
        "code": code,
        "redirect_uri": REDIRECT_URI,
    }
    response = requests.post(TOKEN_ENDPOINT, data=token_data)
    token_response = response.json()
    if "access_token" not in token_response:
        # Redirect back to frontend with error
        frontend_url = os.environ.get("FRONTEND_URL", "/")
        error_detail = token_response.get(
            "error_description", "Failed to obtain access token"
        )
        return RedirectResponse(f"{frontend_url}?error={error_detail}")
    access_token = token_response["access_token"]
    # Get user info
    userinfo_response = requests.get(
        USERINFO_ENDPOINT, headers={"Authorization": f"Bearer {access_token}"}
    )
    userinfo = userinfo_response.json()
    # Check if user is in allowed list
    user_email = userinfo.get("email")
    if ALLOWED_USERS and user_email not in ALLOWED_USERS:
        # Redirect back to frontend with error
        frontend_url = os.environ.get("FRONTEND_URL", "/")
        return RedirectResponse(f"{frontend_url}?error=User not authorized")
    # Redirect back to frontend with access token and user info
    frontend_url = os.environ.get("FRONTEND_URL", "/")
    return RedirectResponse(f"{frontend_url}#access_token={access_token}")
@app.get("/exchange-token")
 async def exchange_token(code: str):
    """Exchange authorization code for access token"""
    # Exchange authorization code for access token
    token_data = {
        "grant_type": "authorization_code",
        "client_id": CLIENT_ID,
        "client_secret": CLIENT_SECRET,
        "code": code,
        "redirect_uri": REDIRECT_URI,
    }
    response = requests.post(TOKEN_ENDPOINT, data=token_data)
    token_response = response.json()
    if "access_token" not in token_response:
        # Return error as JSON
        error_detail = token_response.get(
            "error_description", "Failed to obtain access token"
        )
        raise HTTPException(
            status_code=400, detail=f"Token exchange failed: {error_detail}"
        )
    access_token = token_response["access_token"]
    # Get user info
    userinfo_response = requests.get(
        USERINFO_ENDPOINT, headers={"Authorization": f"Bearer {access_token}"}
    )
    userinfo = userinfo_response.json()
    # Check if user is in allowed list
    user_email = userinfo.get("email")
    if ALLOWED_USERS and user_email not in ALLOWED_USERS:
        raise HTTPException(status_code=403, detail="User not authorized")
    # Return token and user info as JSON
    return {"access_token": access_token, "user": userinfo}
@app.get("/userinfo")
 async def userinfo(headers: Annotated[AuthHeaders, Header()]):
    """Get user info from access token"""
    access_token = headers.token()
    userinfo_response = requests.get(
        USERINFO_ENDPOINT, headers={"Authorization": f"Bearer {access_token}"}
    )
    return userinfo_response.json()
@app.get("/schedule")
 async def schedule(
    headers: Annotated[AuthHeaders, Header()],
@@ -78,18 +270,40 @@ async def schedule(
 ):
    if not headers.authorized():
        raise HTTPException(401, detail="get out")
-    username, password, userid, existing_token, club_id = myice.get_login(
+
-        config_section=account
+    try:
-    )
+        username, password, userid, existing_token, club_id = myice.get_login(
-    if existing_token:
+            config_section=account
-        myice.userdata = {
+        )
-            "id": userid,
+    except Exception as e:
-            "id_club": club_id or 186,
+        raise HTTPException(
-            "token": existing_token,
+            400,
-        }
+            detail=f"Configuration error: {str(e)}. Available accounts: isaac, leonard",
-    else:
+        )
-        myice.userdata = myice.mobile_login(config_section=account)
+
-    return myice.refresh_data()["club_games"]
+    try:
        if existing_token:
            myice.userdata = {
                "id": userid,
                "id_club": club_id or 186,
                "token": existing_token,
            }
        else:
            myice.userdata = myice.mobile_login(config_section=account)
        data = myice.refresh_data()
        if "club_games" in data:
            return data["club_games"]
        else:
            # Return empty array if no games data found
            return []
    except Exception as e:
        print(f"Error fetching schedule: {e}")
        import traceback
        traceback.print_exc()
        # Return empty array instead of throwing an error
        return []
@app.get("/accounts")
@@ -1,6 +1,6 @@
 [project]
 name = "myice"
-version = "v0.4.3"
+version = "v0.5.5"
 description = "myice parsing"
 authors = [
    { name = "Rene Luria", "email" = "<rene@luria.ch>"},
Author	SHA1	Message	Date
herel	5f6ae79bf0	chore: bump version to v0.5.5	2025-08-19 19:22:21 +02:00
herel	697788c20f	feat: auto-load events on login and improve player display in event details - Automatically load events when user logs in - Rename updateAccountOptions to updateAccountOptionsAndLoadEvents - Add auto-fetch of events after account selection - Enhance event details modal with: * Player count summary * Position breakdown * Players sorted by position first, then by number * Position displayed in player list	2025-08-19 19:21:50 +02:00
herel	5c5828cfc1	chore: add event title	2025-08-19 19:12:45 +02:00
herel	0a88217443	chore: bump version to v0.5.4	2025-08-19 19:06:47 +02:00
herel	2d783778a7	feat: update agegroup filter to show only agegroup and filter accordingly	2025-08-19 19:06:24 +02:00
herel	a3d4114044	chore: bump version to v0.5.3	2025-08-19 18:50:12 +02:00
herel	cec54a45d7	fix: improve UI layout and add loading indicator for events	2025-08-19 18:48:56 +02:00
herel	3efa7101e1	fix: finalize UI improvements and ensure all functionality works Final adjustments to UI layout and positioning. Ensured all JavaScript functions are properly connected and working. Verified event loading functionality is fully restored.	2025-08-19 16:12:51 +02:00
herel	861ff0650f	fix: restore event loading functionality and improve UI layout Fixed incomplete fetchEvents function by adding missing data processing logic. Restored updateAgeGroupOptions, displayEvents, and fetchEventDetails functions. Moved connected user info to top-right corner. Hide title when logged in. Reduced vertical spacing for better layout. Made event filters more compact. All functionality restored and UI improved.	2025-08-19 16:09:57 +02:00
herel	73f72d1bbe	feat: enhance login button styling and fix JavaScript syntax errors Centered the login button on the page with improved styling including padding and shadow effects. Fixed JavaScript syntax errors in the event handling code. Removed unmatched closing div tags to ensure valid HTML structure.	2025-08-19 15:49:28 +02:00
herel	a407a108ed	fix: improve user authentication and account handling Fixed issues with user display by fetching user info from userinfo endpoint Improved error handling for JSON responses in schedule endpoint Fixed account selection to use available accounts from config instead of default Enhanced frontend to properly handle API responses and errors	2025-08-19 15:17:45 +02:00
herel	d6277d7766	fix: improve authentication handling and error management	2025-08-19 15:04:53 +02:00
herel	5b1d741a16	feat: implement OpenID Connect authentication with Infomaniak	2025-08-19 11:16:07 +02:00
herel	5957868e0f	chore: bump version to v0.5.2	2025-08-19 10:48:55 +02:00
herel	525d3bf326	fix: escape control characters in JSON output to make it jq compatible	2025-08-19 10:48:04 +02:00
herel	0e1eb0da3f	chore: bump version to v0.5.1	2025-08-19 09:41:57 +02:00
herel	4b81cc7f9f	fix: improve JSON response handling in API calls	2025-08-19 09:41:28 +02:00
herel	c4d9236b16	feat: make config_section a global CLI option Users can now specify --config-section once at the beginning of the command instead of repeating it for each subcommand. Also bumped version to v0.5.0 for this new feature.	2025-08-19 09:25:50 +02:00