lms.backend.moodle.backend

  1# pylint: disable=abstract-method
  2
  3import logging
  4import typing
  5import urllib.parse
  6
  7import bs4
  8import edq.net.request
  9import requests
 10
 11import lms.model.backend
 12import lms.model.constants
 13import lms.util.net
 14
 15_logger = logging.getLogger(__name__)
 16
 17class MoodleBackend(lms.model.backend.APIBackend):
 18    """ An API backend for the Moodle LMS. """
 19
 20    def __init__(self,
 21            server: str,
 22            auth_user: typing.Union[str, None] = None,
 23            auth_password: typing.Union[str, None] = None,
 24            **kwargs: typing.Any) -> None:
 25        super().__init__(server, lms.model.constants.BACKEND_TYPE_MOODLE, **kwargs)
 26
 27        if (auth_user is None):
 28            raise ValueError("Moodle backends require a username.")
 29
 30        if (auth_password is None):
 31            raise ValueError("Moodle backends require a password.")
 32
 33        self._username = auth_user
 34        """ The username to authenticate with. """
 35
 36        self._password = auth_password
 37        """ The password to authenticate with. """
 38
 39        self._session_headers: typing.Union[typing.Dict[str, typing.Any], None] = None
 40        """ The headers (e.g., cookies) for our logged in Moodle session. """
 41
 42    def _parse_cookies(self, response: requests.Response) -> typing.Dict[str, typing.Any]:
 43        """
 44        Parse Moodle cookies.
 45        Return fake cookies when testing.
 46        """
 47
 48        if (self.is_testing()):
 49            return {
 50                'moodlesession': 'testing-moodle-session',
 51                'moodleid1_': 'testing-moodle-id',
 52            }
 53
 54        return lms.util.net.parse_cookies(response.headers.get('set-cookie', None))
 55
 56    def _login(self, update_server: bool = True) -> None:
 57        """
 58        Try to login to the Moodle server.
 59        If `update_server` is true, then this may try to update the backend's server location if redirected by the Moodle server.
 60        """
 61
 62        # Check if we are already logged in.
 63        if (self._session_headers is not None):
 64            return
 65
 66        response, body = edq.net.request.make_get(self.server + '/login/index.php')
 67        cookies = self._parse_cookies(response)
 68
 69        new_cookies = {
 70            'MoodleSession': cookies['moodlesession'],
 71        }
 72        text_cookies = '; '.join(['='.join(items) for items in new_cookies.items()])
 73
 74        # Parse the login token from the page HTML.
 75        document = bs4.BeautifulSoup(body, 'html.parser')
 76        token = document.select('input[name="logintoken"]')[0]['value']
 77
 78        headers = {
 79            'cookie': text_cookies,
 80            'host': urllib.parse.urlparse(self.server).netloc,
 81        }
 82
 83        data = {
 84            'logintoken': token,
 85            'username': self._username,
 86            'password': self._password,
 87        }
 88
 89        response, _ = edq.net.request.make_post(self.server + '/login/index.php',
 90                headers = headers, data = data,
 91                allow_redirects = False)
 92
 93        # Check for a successful login.
 94        cookies = self._parse_cookies(response)
 95        if ('moodleid1_' in cookies):
 96            self._session_headers = {
 97                'cookie': response.headers.get('set-cookie', None),
 98                # Insert a header to identify the user.
 99                'edq-lms-moodle-user': self._username,
100            }
101            return
102
103        # Login Failed
104
105        # The specified server/host needs to match exactly what the Moodle server wants it to be,
106        # e.g., `127.0.0.1` does not work when the server wants the host to be `localhost`.
107        # If these do not match, we will get a redirect here.
108        # Use this redirect to discover the correct server.
109        location = response.headers.get('location', None)
110        if (update_server and (location is not None) and (not location.startswith(self.server))):
111            parts = urllib.parse.urlparse(location)
112            host = f"{parts.scheme}://{parts.netloc}"
113
114            _logger.debug(("Mismatch in the client-specified server ('%s') and server-requested host ('%s')."
115                    + " To avoid extra requests, update the server (e.g., `--server`) to match the host."),
116                    self.server, host)
117
118            # Update the server and try to login again (without updating the server again (to avoid loops)).
119            self.server = host
120            self._login(update_server = False)
121            return
122
123        raise ValueError(f"Could not log into Moodle server ({self.server}) with user '{self._username}'. Is username/password correct?")
124
125    def courses_list(self,
126            **kwargs: typing.Any) -> typing.List[lms.model.courses.Course]:
127        self._login()
128
129        url = self.server + "/user/profile.php"
130        response, _ = edq.net.request.make_get(url, headers = self._session_headers)
131
132        document = bs4.BeautifulSoup(response.text, 'html.parser')
133        cards = document.select('div.card-body')
134
135        node = None
136        for card in cards:
137            text = card.get_text()
138            if (text.startswith("Course details")):
139                node = card
140                break
141
142        if (node is None):
143            return []
144
145        links = node.select('a')
146
147        courses = []
148        for link in links:
149            name = link.get_text()
150
151            href = link.get('href', None)
152            if (href is None):
153                continue
154
155            id = str(href).rsplit("=", maxsplit = 1)[-1]
156
157            courses.append(lms.model.courses.Course(
158                id = id,
159                name = name,
160            ))
161
162        return sorted(courses)