Skip to main content

A simple Django app to fetch and parse data from Dataporten.

Project description

Django-dataporten is a simple Django app which fetches data from dataporten and attaches it to your Django user objects. It implements the dataporten groups API, allowing you to easily access group memberships through a pythonic API, without worrying about parsing raw JSON content.

Setup

  1. Add “dataporten” to your INSTALLED_APPS setting like this
INSTALLED_APPS = [
    ...
    'dataporten',
    ...
]
  1. Run python manage.py migrate to create the dataporten proxy models.

3. In your settings.py file, add the variable DATAPORTEN_TOKEN_FUNCTION, which should be a dotted path to the function that will retrieve user tokens. Dataporten uses this “importable string” in order to retrieve the OAuth2 authentication token for a given user. For instance,

DATAPORTEN_TOKEN_FUNCTION = 'myapp.oauth.allauth_token'

The function should accept a User and return a str, if the token exists, else None. Here is a python3.6/3.7 example that will work if you use django-allauth:

def allauth_token(user: User) -> Optional[str]:
    try:
        return SocialToken.objects.get(
            account__user=user,
            account__provider='dataporten',
        ).token
    except SocialToken.DoesNotExist:
        return None

4. Add the dataporten middleware. This middleware adds a dataporten attribute to request.user for users with an associated dataporten token. Take care to place it after django.contrib.auth.middleware.AuthenticationMiddleware.

MIDDLEWARE = (
    ...
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    ...
    'dataporten.middleware.DataportenGroupsMiddleware',
    ...
)

5. Optionally, enable caching for API queries. Take care to create the directory set in DATAPORTEN_CACHE_PATH before starting the Django server.

# Cache requests to the dataporten API
DATAPORTEN_CACHE_REQUESTS = True

# Where to save the sqlite3 cache backend
DATAPORTEN_CACHE_PATH = 'tmp/'

Usage

The DataportenGroupsMiddleware adds an instance of DataportenGroupsManager assigned to request.user.dataporten for every valid dataporten user making a request. This object contains attributes for accessing different types of group memberships, such as courses, organization units, study programmes, main profiles, generic groups, and all groups.

Groups

All groups are accessible through request.user.dataporten.groups. This is a dictionary keyed by group ids, with Group objects as values. Let’s use the Applied Physics and Mathematics master degree at NTNU as an example for common attributes available for all group types

uid = 'fc:fs:fs:prg:ntnu.no:MTFYMA'
group = request.user.dataporten.groups[uid]
assert group.uid == uid
assert group.name == 'Fysikk og matematikk - masterstudium (5-\u00e5rig)'
assert group.url == 'http://www.ntnu.no/studier/mtfyma'
assert group.group_type == 'fc:fs:prg'

Membership objects

All groups have an associated Membership object which can be used for further querying of membership properties for that particular group. The original membership JSON can be accessed from the Membership.json attribute:

group = request.user.dataporten.groups[uid]
membership = group.membership

print(membership.json)
>>> {
>>>     'title': ['fast ansatt'],
>>>     'affiliation': ['employee', 'member', 'affiliate', 'student'],
>>>     'primaryAffiliation': 'employee',
>>>     'basic': 'admin',
>>>     'displayName': 'Ansatt',
>>> }

Some additional, common properties are available:

# Membership objects are "truthy" if they are considered active
assert membership

# Not all group memberships have a set end time
assert isinstance(membership.end_time, [datetime.datetime, None])

# The displayName value is used as the membership string representation
assert str(membership) == 'Ansatt'

# Primary affiliation to the group
assert membership.primary_affiliation == 'employee'

# And all affiliations to the group
assert membership.affiliations == [
    'employee',
    'member',
    'affiliate',
    'student',
]

Group membership checks

You can also check if a user is an active member of a specific dataporten group by providing the group id to the DataportenGroupsManager.is_member_of method. This is offered as a more ergonomic alternative to bool(request.user.dataporten.groups[uid].membership). For instance,

assert request.user.dataporten.is_member_of(
    uid='fc:org:ntnu.no:unit:167500',
    active=True,
)

If active is set to False, the method only checks if the user has been a member of the group at any time, not necessarily if the user is an active member.

Semester objects

Membership objects also have an associated Semester object which can be used to determine the year and season of the membership.

from dataporten.parsers import Semester

semester = request.user.groups[uid].membership.semester
assert semester.year == 2019
assert semester.season in (Semester.SPRING, Semester.AUTUMN)

The Semester class also implements __sub__, which returns “semester delta” between two semesters. For instance, the spring semester of 2019 minus the autumn semester of 2017 would return 3.

Courses

Course enrollment can be queryed from the CourseManager object, attributed to request.user.dataporten.course.

You can check if a user has an affiliation to a course, only given its course code, and not its dataporten ID,

# Already finished the course
assert 'TMA4150' in request.user.dataporten.courses.finished

# Currently enrolled in the course
assert 'TMA4150' in request.user.dataporten.courses.active

# Either
assert 'TMA4150' in request.user.dataporten.courses.all

More

There is still lots of more undocumented (but well tested!) attributes of DataportenGroupsManager. Take a look at dataporten/parsers.py. Each parser has a class variable NAME, and they are attached to the user as request.user.dataporten.NAME.

If you have a specific usecase, please open a GitHub issue, and I will document and/or implement it for you.

Run tests

export DJANGO_SETTINGS_MODULE=dataporten.settings
pytest

Project details


Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Files for django-dataporten, version 0.4.0
Filename, size File type Python version Upload date Hashes
Filename, size django_dataporten-0.4.0-py3-none-any.whl (20.1 kB) File type Wheel Python version 3.6 Upload date Hashes View
Filename, size django-dataporten-0.4.0.tar.gz (17.8 kB) File type Source Python version None Upload date Hashes View

Supported by

Pingdom Pingdom Monitoring Google Google Object Storage and Download Analytics Sentry Sentry Error logging AWS AWS Cloud computing DataDog DataDog Monitoring Fastly Fastly CDN DigiCert DigiCert EV certificate StatusPage StatusPage Status page