makerspaceapi.py

# -*- coding: utf-8 -*-

"""
MakerSpaceAPI connector for MachineUserManager
"""

import time
import requests

import logging

logger = logging.getLogger(__name__)


class ApiUnavailable(Exception):
    """The API could not be reached or answered with an unexpected status."""


class api:
    api_url = "http://localhost:8000"
    api_token = ""
    machine = "lasercutter"
    # IDs of sessions whose DELETE failed; retried later (kept in memory only)
    _pending_ends = []

    def configure(**kwargs):
        if "api_url" in kwargs:
            api.api_url = kwargs["api_url"].rstrip("/")
        if "api_token" in kwargs:
            api.api_token = kwargs["api_token"]
        if "machine" in kwargs:
            api.machine = kwargs["machine"]

    def _headers():
        return {"Authorization": f"Bearer {api.api_token}"}

    def _base():
        return f"{api.api_url}/api/v1"

    def __init__(self, uid):
        # uid may be an integer (raw NFC UID) or bytes
        if isinstance(uid, (bytes, bytearray)):
            n = 0
            for b in uid:
                n <<= 8
                n += b
            self.uid = n
        else:
            self.uid = uid

        self.per_login = 0
        self.per_minute = 0
        self.session_valid_until = 0
        self.credit = 0
        self._session_id = None
        self._name = None
        self.out_of_order_reason = None

        # Pre-fetch user info once on init
        try:
            r = requests.get(
                f"{api._base()}/users/nfc/{self.uid}",
                headers=api._headers(),
                timeout=5,
            )
            if r.ok:
                data = r.json()
                self._name = data.get("name")
                self.credit = float(data.get("balance", 0))
        except requests.RequestException:
            logger.exception("Could not fetch user info on init")

    def get_user_info(self):
        """Return (name, credit); (None, None) if the card is unknown.

        Raises ApiUnavailable if the API cannot be reached or fails, so that
        an outage is not mistaken for an unknown card.
        """
        try:
            r = requests.get(
                f"{api._base()}/users/nfc/{self.uid}",
                headers=api._headers(),
                timeout=5,
            )
        except requests.RequestException as e:
            logger.exception("get_user_info failed")
            raise ApiUnavailable(str(e)) from e
        if r.status_code == 404:
            return None, None
        if not r.ok:
            raise ApiUnavailable(f"HTTP {r.status_code}")
        data = r.json()
        self._name = data.get("name")
        self.credit = float(data.get("balance", 0))
        return self._name, self.credit

    def get_rate(self, fallback_login, fallback_minute):
        try:
            r = requests.get(
                f"{api._base()}/machines/{api.machine}/authorize/{self.uid}",
                headers=api._headers(),
                timeout=5,
            )
            if r.ok:
                data = r.json()
                self.per_login = float(data.get("price_per_login", fallback_login))
                self.per_minute = float(data.get("price_per_minute", fallback_minute))
                return self.per_login, self.per_minute
            self.per_login = fallback_login
            self.per_minute = fallback_minute
            return None, None
        except requests.RequestException:
            logger.exception("get_rate failed")
            self.per_login = fallback_login
            self.per_minute = fallback_minute
            return None, None

    def access_state(self):
        """Return "authorized", "unauthorized", "terms_required" or "out_of_order".

        "terms_required" means the user is authorized but has not accepted the
        machine's current terms of use yet (servers without that feature never
        report it). Raises ApiUnavailable if the API cannot be reached or fails.
        """
        try:
            r = requests.get(
                f"{api._base()}/machines/{api.machine}/authorize/{self.uid}",
                headers=api._headers(),
                timeout=5,
            )
        except requests.RequestException as e:
            logger.exception("access_state failed")
            raise ApiUnavailable(str(e)) from e
        if r.status_code == 404:
            return "unauthorized"
        if not r.ok:
            raise ApiUnavailable(f"HTTP {r.status_code}")
        data = r.json()
        if data.get("out_of_order", False):
            self.out_of_order_reason = data.get("out_of_order_reason")
            return "out_of_order"
        if data.get("authorized", False):
            return "authorized"
        if data.get("terms_required", False):
            return "terms_required"
        return "unauthorized"

    def is_authorized(self):
        return self.access_state() == "authorized"

    def can_create_session(self):
        price = self.per_login + self.per_minute
        self.check_credit()
        return self.credit >= price

    def check_credit(self):
        try:
            r = requests.get(
                f"{api._base()}/users/nfc/{self.uid}",
                headers=api._headers(),
                timeout=5,
            )
            if r.ok:
                self.credit = float(r.json().get("balance", 0))
                return self.credit
            return 0
        except requests.RequestException:
            logger.exception("check_credit failed")
            return 0

    def create_session(self, fallback_login, fallback_minute):
        self.start_time = int(time.time())
        self.get_rate(fallback_login, fallback_minute)
        try:
            r = requests.post(
                f"{api._base()}/sessions",
                headers=api._headers(),
                json={"nfc_id": self.uid},
                timeout=5,
            )
            if r.ok:
                data = r.json()
                self._session_id = data.get("session_id")
                self.check_credit()
                self.session_valid_until = self.start_time + 60
                return True
            return False
        except requests.RequestException:
            logger.exception("create_session failed")
            return False

    """
    Check if current session is still valid and extend if necessary.
    Returns True if still valid or revaluation was successful.
    Returns False if no session was created beforehand or credit is not enough to extend.
    """

    def extend_session(self):
        if self._session_id is None:
            return False
        if self.session_valid_until >= time.time():
            return True
        try:
            r = requests.put(
                f"{api._base()}/sessions/{self._session_id}",
                headers=api._headers(),
                timeout=5,
            )
            if r.ok:
                self.check_credit()
                self.session_valid_until += 60
                return True
            # 402 = insufficient balance → session terminated by API
            return False
        except requests.RequestException:
            logger.exception("extend_session failed")
            return False

    def get_remaining_time(self):
        if self.per_minute is None:
            return 0
        elif self.per_minute == 0:
            return 999
        else:
            return int(
                (self.credit - (self.per_login if self.session_valid_until == 0 else 0))
                / self.per_minute
            )

    def end_session(self):
        """End the session on the server; if that fails, retry later (see flush_pending_ends)."""
        session_id = self._session_id
        self.session_valid_until = 0
        self._session_id = None
        if session_id is None:
            return
        if not api._delete_session(session_id):
            logger.warning("Could not end session %s, will retry", session_id)
            api._pending_ends.append(session_id)

    def _delete_session(session_id):
        """True if the server no longer has this session open (ended, or unknown/foreign)."""
        try:
            r = requests.delete(
                f"{api._base()}/sessions/{session_id}",
                headers=api._headers(),
                timeout=5,
            )
        except requests.RequestException:
            logger.exception("end_session failed")
            return False
        # 4xx (e.g. 404): retrying cannot help
        return r.ok or 400 <= r.status_code < 500

    def flush_pending_ends():
        """Retry session ends that failed earlier; stops at the first failure (API still down)."""
        while api._pending_ends:
            if not api._delete_session(api._pending_ends[0]):
                return
            logger.info("Ended session %s after retry", api._pending_ends[0])
            api._pending_ends.pop(0)