Skip to content

E
edx-analytics-data-api
Commit b4034977 by Clinton Blackburn
Options

Added Course Enrollment-Demographic Resources 

Change-Id: I5285f72b5bffb59a97cdc4750e90cd8578202b83
parent 763bc9c3
Showing with 895 additions and 476 deletions
Makefile
ROOT = $(shell echo "$$PWD") ROOT = $(shell echo "$$PWD")
COVERAGE = $(ROOT)/build/coverage COVERAGE = $(ROOT)/build/coverage
PACKAGES = analyticsdata PACKAGES = analytics_data_api
DATABASES = default analytics DATABASES = default analytics
.PHONY: requirements develop clean diff.report view.diff.report quality syncdb .PHONY: requirements develop clean diff.report view.diff.report quality syncdb
...@@ -24,8 +24,8 @@ test: clean ...@@ -24,8 +24,8 @@ test: clean
--with-coverage --cover-inclusive --cover-branches \ --with-coverage --cover-inclusive --cover-branches \
--cover-html --cover-html-dir=$(COVERAGE)/html/ \ --cover-html --cover-html-dir=$(COVERAGE)/html/ \
--cover-xml --cover-xml-file=$(COVERAGE)/coverage.xml \ --cover-xml --cover-xml-file=$(COVERAGE)/coverage.xml \
--cover-package=analyticsdata \ --cover-package=$(PACKAGES) \
analyticsdata/ $(PACKAGES)
diff.report: diff.report:
diff-cover $(COVERAGE)/coverage.xml --html-report $(COVERAGE)/diff_cover.html diff-cover $(COVERAGE)/coverage.xml --html-report $(COVERAGE)/diff_cover.html
...@@ -42,7 +42,7 @@ quality: ...@@ -42,7 +42,7 @@ quality:
pylint --rcfile=.pylintrc $(PACKAGES) pylint --rcfile=.pylintrc $(PACKAGES)
# Ignore module level docstrings and all test files # Ignore module level docstrings and all test files
pep257 --ignore=D100,D203 --match='(?!test).*py' $(PACKAGES) #pep257 --ignore=D100,D203 --match='(?!test).*py' $(PACKAGES)
validate: test.requirements test quality validate: test.requirements test quality
......
README.md
edX Analytics API Server edX Analytics API Server
====================== ========================
See https://edx-wiki.atlassian.net/wiki/display/AN/Analytics+Data+API for more details. For the API *client* visit This repository includes the Django server for the API as well as the API package itself. The client is hosted at
https://github.com/edx/edx-analytics-api-client. https://github.com/edx/edx-analytics-api-client.
License License
...@@ -10,18 +10,25 @@ The code in this repository is licensed under version 3 of the AGPL unless other ...@@ -10,18 +10,25 @@ The code in this repository is licensed under version 3 of the AGPL unless other
Please see `LICENSE.txt` for details. Please see `LICENSE.txt` for details.
Testing Getting Started
------------- ---------------
Run `make validate`.
Development 1. Install the requirements:
-------------
1. Install dependencies:
$ make develop $ make develop
2. Launch server: 2. Run the server:
$ ./manage.py runserver $ ./manage.py runserver
Loading Data
------------
The fixtures directory contains demo data. This data can be loaded with the following commands:
$ ./manage.py syncdb --migrate --noinput --database=analytics
$ ./manage.py loaddata courses education_levels single_course_activity course_enrollment_birth_year course_enrollment_education course_enrollment_gender --database=analytics
Running Tests
-------------
Run `make validate` install the requirements, run the tests, and run lint.
analytics_data_api/fixtures/course_enrollment_education.json 0 → 100644
[
{
"model": "v0.CourseEnrollmentByEducation",
"pk": 5,
"fields": {
"course": ["edX/DemoX/Demo_Course"],
"education_level": 6,
"num_enrolled_students": 12255,
"interval_start": "2014-07-01T00:00:00Z",
"interval_end": "2014-07-02T23:59:59Z"
}
},
{
"model": "v0.CourseEnrollmentByEducation",
"pk": 6,
"fields": {
"course": ["edX/DemoX/Demo_Course"],
"education_level": 7,
"num_enrolled_students": 70885,
"interval_start": "2014-07-01T00:00:00Z",
"interval_end": "2014-07-02T23:59:59Z"
}
},
{
"model": "v0.CourseEnrollmentByEducation",
"pk": 7,
"fields": {
"course": ["edX/DemoX/Demo_Course"],
"education_level": 3,
"num_enrolled_students": 981,
"interval_start": "2014-07-01T00:00:00Z",
"interval_end": "2014-07-02T23:59:59Z"
}
},
{
"model": "v0.CourseEnrollmentByEducation",
"pk": 8,
"fields": {
"course": ["edX/DemoX/Demo_Course"],
"education_level": 5,
"num_enrolled_students": 51591,
"interval_start": "2014-07-01T00:00:00Z",
"interval_end": "2014-07-02T23:59:59Z"
}
},
{
"model": "v0.CourseEnrollmentByEducation",
"pk": 9,
"fields": {
"course": ["edX/DemoX/Demo_Course"],
"education_level": 4,
"num_enrolled_students": 6051,
"interval_start": "2014-07-01T00:00:00Z",
"interval_end": "2014-07-02T23:59:59Z"
}
},
{
"model": "v0.CourseEnrollmentByEducation",
"pk": 10,
"fields": {
"course": ["edX/DemoX/Demo_Course"],
"education_level": 8,
"num_enrolled_students": 53216,
"interval_start": "2014-07-01T00:00:00Z",
"interval_end": "2014-07-02T23:59:59Z"
}
},
{
"model": "v0.CourseEnrollmentByEducation",
"pk": 11,
"fields": {
"course": ["edX/DemoX/Demo_Course"],
"education_level": 1,
"num_enrolled_students": 667,
"interval_start": "2014-07-01T00:00:00Z",
"interval_end": "2014-07-02T23:59:59Z"
}
},
{
"model": "v0.CourseEnrollmentByEducation",
"pk": 12,
"fields": {
"course": ["edX/DemoX/Demo_Course"],
"education_level": 2,
"num_enrolled_students": 5722,
"interval_start": "2014-07-01T00:00:00Z",
"interval_end": "2014-07-02T23:59:59Z"
}
},
{
"model": "v0.CourseEnrollmentByEducation",
"pk": 13,
"fields": {
"course": ["edX/DemoX/Demo_Course"],
"education_level": 9,
"num_enrolled_students": 9940,
"interval_start": "2014-07-01T00:00:00Z",
"interval_end": "2014-07-02T23:59:59Z"
}
}
]
analytics_data_api/fixtures/course_enrollment_gender.json 0 → 100644
[
{
"model": "v0.CourseEnrollmentByGender",
"pk": 1,
"fields": {
"course": ["edX/DemoX/Demo_Course"],
"gender": "m",
"num_enrolled_students": 133240,
"interval_start": "2014-07-01T00:00:00Z",
"interval_end": "2014-07-02T23:59:59Z"
}
},
{
"model": "v0.CourseEnrollmentByGender",
"pk": 2,
"fields": {
"course": ["edX/DemoX/Demo_Course"],
"gender": "f",
"num_enrolled_students": 77495,
"interval_start": "2014-07-01T00:00:00Z",
"interval_end": "2014-07-02T23:59:59Z"
}
},
{
"model": "v0.CourseEnrollmentByGender",
"pk": 3,
"fields": {
"course": ["edX/DemoX/Demo_Course"],
"gender": "o",
"num_enrolled_students": 423,
"interval_start": "2014-07-01T00:00:00Z",
"interval_end": "2014-07-02T23:59:59Z"
}
}
]
analytics_data_api/fixtures/courses.json 0 → 100644
[
{
"pk": 1,
"model": "v0.course",
"fields": {
"course_key": "edX/DemoX/Demo_Course"
}
}
]
analytics_data_api/fixtures/education_levels.json 0 → 100644
[
{
"pk": 1,
"model": "v0.educationlevel",
"fields": {
"name": "None",
"short_name": "none"
}
},
{
"pk": 2,
"model": "v0.educationlevel",
"fields": {
"name": "Other",
"short_name": "other"
}
},
{
"pk": 3,
"model": "v0.educationlevel",
"fields": {
"name": "Elementary/Primary School",
"short_name": "primary"
}
},
{
"pk": 4,
"model": "v0.educationlevel",
"fields": {
"name": "Junior Secondary/Junior High/Middle School",
"short_name": "junior_secondary"
}
},
{
"pk": 5,
"model": "v0.educationlevel",
"fields": {
"name": "Secondary/High School",
"short_name": "secondary"
}
},
{
"pk": 6,
"model": "v0.educationlevel",
"fields": {
"name": "Associate's Degree",
"short_name": "associates"
}
},
{
"pk": 7,
"model": "v0.educationlevel",
"fields": {
"name": "Bachelor's Degree",
"short_name": "bachelors"
}
},
{
"pk": 8,
"model": "v0.educationlevel",
"fields": {
"name": "Master's or Professional Degree",
"short_name": "masters"
}
},
{
"pk": 9,
"model": "v0.educationlevel",
"fields": {
"name": "Doctorate",
"short_name": "doctorate"
}
}
]
\ No newline at end of file
analyticsdata/fixtures/single_course_activity.json → analytics_data_api/fixtures/single_course_activity.json
[ [
{ {
"pk": 40, "pk": 40,
"model": "analyticsdata.courseactivitybyweek", "model": "v0.CourseActivityByWeek",
"fields": { "fields": {
"course_id": "edX/DemoX/Demo_Course", "course": ["edX/DemoX/Demo_Course"],
"interval_start": "2014-05-24T00:00:00Z", "interval_start": "2014-05-24T00:00:00Z",
"label": "POSTED_FORUM", "activity_type": "posted_forum",
"count": 100, "count": 100,
"interval_end": "2014-06-01T00:00:00Z" "interval_end": "2014-06-01T00:00:00Z"
} }
}, },
{ {
"pk": 106, "pk": 106,
"model": "analyticsdata.courseactivitybyweek", "model": "v0.CourseActivityByWeek",
"fields": { "fields": {
"course_id": "edX/DemoX/Demo_Course", "course": ["edX/DemoX/Demo_Course"],
"interval_start": "2014-05-24T00:00:00Z", "interval_start": "2014-05-24T00:00:00Z",
"label": "ATTEMPTED_PROBLEM", "activity_type": "attempted_problem",
"count": 200, "count": 200,
"interval_end": "2014-06-01T00:00:00Z" "interval_end": "2014-06-01T00:00:00Z"
} }
}, },
{ {
"pk": 201, "pk": 201,
"model": "analyticsdata.courseactivitybyweek", "model": "v0.CourseActivityByWeek",
"fields": { "fields": {
"course_id": "edX/DemoX/Demo_Course", "course": ["edX/DemoX/Demo_Course"],
"interval_start": "2014-05-24T00:00:00Z", "interval_start": "2014-05-24T00:00:00Z",
"label": "ACTIVE", "activity_type": "any",
"count": 300, "count": 300,
"interval_end": "2014-06-01T00:00:00Z" "interval_end": "2014-06-01T00:00:00Z"
} }
}, },
{ {
"pk": 725, "pk": 725,
"model": "analyticsdata.courseactivitybyweek", "model": "v0.CourseActivityByWeek",
"fields": { "fields": {
"course_id": "edX/DemoX/Demo_Course", "course": ["edX/DemoX/Demo_Course"],
"interval_start": "2014-05-24T00:00:00Z", "interval_start": "2014-05-24T00:00:00Z",
"label": "PLAYED_VIDEO", "activity_type": "played_video",
"count": 400, "count": 400,
"interval_end": "2014-06-01T00:00:00Z" "interval_end": "2014-06-01T00:00:00Z"
} }
......
analytics_data_api/management/commands/set_api_key.py 0 → 100644
"""A command to set the API key for a user using when using TokenAuthentication."""
from optparse import make_option
from django.contrib.auth.models import User
from django.core.management.base import BaseCommand, CommandError
from analytics_data_api.utils import delete_user_auth_token, set_user_auth_token
class Command(BaseCommand):
"""A command to set the API key for a user using when using TokenAuthentication."""
help = 'Set the API key for the specified user.'
args = '<username> <api_key>'
option_list = BaseCommand.option_list + (
make_option('--delete-key', action='store_true', default=False, help="Delete API key for user"),
)
def handle(self, *args, **options):
if len(args) < 1:
raise CommandError("You must supply a username.")
username = args[0]
if options['delete_key']:
delete_user_auth_token(username)
print 'Removed API key for user: <{0}>'.format(username)
else:
if len(args) < 2:
raise CommandError("You must supply both a username and key.")
user, _ = User.objects.get_or_create(username=username)
try:
key = args[1]
set_user_auth_token(user, key)
except AttributeError:
print "The key %s is in use by another user. Please select another key." % key
analytics_data_api/models.py 0 → 100644
# This file should be empty. Place your models in the package that corresponds to an API version (e.g. v0, v1). This
# file only exists to make Django happy.
analytics_data_api/tests.py 0 → 100644
from django.contrib.auth.models import User
from django.core.management import call_command, CommandError
from django.test import TestCase
from django_dynamic_fixture import G
from rest_framework.authtoken.models import Token
from analytics_data_api.utils import delete_user_auth_token, set_user_auth_token
class UtilsTests(TestCase):
def test_delete_user_auth_token(self):
# Create user and token
user = G(User)
G(Token, user=user)
# Verify token exists
self.assertTrue(Token.objects.filter(user=user).exists())
# Call delete method
delete_user_auth_token(user.username)
# Verify token no longer exists
self.assertFalse(Token.objects.filter(user=user).exists())
def test_delete_user_auth_token_non_existing(self):
user = G(User)
self.assertFalse(Token.objects.filter(user=user).exists())
delete_user_auth_token(user.username)
self.assertFalse(Token.objects.filter(user=user).exists())
def test_set_user_auth_token(self):
user = G(User)
key = "Avengers Assemble!"
self.assertFalse(Token.objects.filter(user=user).exists())
set_user_auth_token(user, key)
self.assertEqual(Token.objects.get(user=user).key, key)
key = "Hulk Smash!"
set_user_auth_token(user, key)
self.assertEqual(Token.objects.get(user=user).key, key)
# Verify we don't create token conflicts
user2 = G(User)
self.assertRaises(AttributeError, set_user_auth_token, user2, key)
class SetApiKeyTests(TestCase):
def test_delete_key(self):
user = G(User)
G(Token, user=user)
self.assertTrue(Token.objects.filter(user=user).exists())
call_command('set_api_key', user.username, delete_key=True)
self.assertFalse(Token.objects.filter(user=user).exists())
def test_invalid_arguments(self):
self.assertRaises(CommandError, call_command, 'set_api_key')
self.assertRaises(CommandError, call_command, 'set_api_key', 'username')
def test_set_key(self):
user = G(User)
key = "Super Secret!"
self.assertFalse(Token.objects.filter(user=user).exists())
call_command('set_api_key', user.username, key)
self.assertEqual(Token.objects.get(user=user).key, key)
key = "No one will guess this!"
call_command('set_api_key', user.username, key)
self.assertEqual(Token.objects.get(user=user).key, key)
def test_set_key_conflict(self):
key = "Super Secret!"
user = G(User)
user2 = G(User)
G(Token, user=user, key=key)
self.assertFalse(Token.objects.filter(user=user2).exists())
call_command('set_api_key', user2.username, key)
self.assertFalse(Token.objects.filter(user=user2).exists())
analyticsdata/urls.py → analytics_data_api/urls.py
from django.conf.urls import patterns, url from django.conf.urls import patterns, url, include
from rest_framework.urlpatterns import format_suffix_patterns from rest_framework.urlpatterns import format_suffix_patterns
from analyticsdata import views
urlpatterns = patterns( urlpatterns = patterns(
'', '',
url(r'^status$', views.status), url(r'^v0/', include('analytics_data_api.v0.urls', namespace='v0')),
url(r'^authenticated$', views.authenticated),
url(r'^health$', views.health),
# Course Activity
url(r'^courses/(?P<course_id>.+)/recent_activity$', views.CourseActivityMostRecentWeekView.as_view())
) )
urlpatterns = format_suffix_patterns(urlpatterns) urlpatterns = format_suffix_patterns(urlpatterns)
analytics_data_api/utils.py 0 → 100644
from django.db.models import Q
from rest_framework.authtoken.models import Token
def delete_user_auth_token(username):
"""
Deletes the authentication tokens for the user with the given username
If no user exists, NO error is returned.
:param username: Username of the user whose authentication tokens should be deleted
:return: None
"""
Token.objects.filter(user__username=username).delete()
def set_user_auth_token(user, key):
"""
Sets the authentication for the given User.
Raises an AttributeError if *different* User with the specified key already exists.
:param user: User whose authentication is being set
:param key: New authentication key
:return: None
"""
# Check that no other user has the same key
if Token.objects.filter(~Q(user=user), key=key).exists():
raise AttributeError("The key %s is already in use by another user.", key)
Token.objects.filter(user=user).delete()
Token.objects.create(user=user, key=key)
print "Set API key for user %s to %s" % (user, key)
analytics_data_api/v0/managers.py 0 → 100644
from django.db import models
class CourseManager(models.Manager):
def get_by_natural_key(self, course_key):
return self.get(course_key=course_key)
analytics_data_api/v0/models.py 0 → 100644
from django.db import models
from analytics_data_api.v0.managers import CourseManager
class Course(models.Model):
objects = CourseManager() # pylint: disable=no-value-for-parameter
course_key = models.CharField(unique=True, max_length=255)
class Meta(object):
db_table = 'courses'
class CourseActivityByWeek(models.Model):
"""A count of unique users who performed a particular action during a week."""
class Meta(object):
db_table = 'course_activity'
course = models.ForeignKey(Course, null=False)
interval_start = models.DateTimeField()
interval_end = models.DateTimeField()
activity_type = models.CharField(db_index=True, max_length=255)
count = models.IntegerField()
@classmethod
def get_most_recent(cls, course_key, activity_type):
"""Activity for the week that was mostly recently computed."""
return cls.objects.filter(course__course_key=course_key, activity_type=activity_type).latest('interval_end')
class BaseCourseEnrollment(models.Model):
course = models.ForeignKey(Course, null=False)
interval_start = models.DateTimeField(null=False)
interval_end = models.DateTimeField(null=False)
num_enrolled_students = models.IntegerField(null=False)
class Meta(object):
abstract = True
class CourseEnrollmentByBirthYear(BaseCourseEnrollment):
birth_year = models.IntegerField(null=False)
class Meta(object):
db_table = 'course_enrollment_birth_year'
ordering = ('course', 'birth_year')
class EducationLevel(models.Model):
name = models.CharField(max_length=255, null=False, unique=True)
short_name = models.CharField(max_length=255, null=False, unique=True)
class Meta(object):
db_table = 'education_levels'
class CourseEnrollmentByEducation(BaseCourseEnrollment):
education_level = models.ForeignKey(EducationLevel)
class Meta(object):
db_table = 'course_enrollment_education_level'
ordering = ('course', 'education_level')
class CourseEnrollmentByGender(BaseCourseEnrollment):
gender = models.CharField(max_length=255, null=False)
class Meta(object):
db_table = 'course_enrollment_gender'
ordering = ('course', 'gender')
analytics_data_api/v0/serializers.py 0 → 100644
from rest_framework import serializers
from analytics_data_api.v0.models import CourseActivityByWeek
class CourseActivityByWeekSerializer(serializers.ModelSerializer):
"""
Representation of CourseActivityByWeek that excludes the id field.
This table is managed by the data pipeline, and records can be removed and added at any time. The id for a
particular record is likely to change unexpectedly so we avoid exposing it.
"""
course_key = serializers.SerializerMethodField('get_course_key')
def get_course_key(self, obj):
return obj.course.course_key
class Meta(object):
model = CourseActivityByWeek
fields = ('interval_start', 'interval_end', 'activity_type', 'count', 'course_key')
analytics_data_api/v0/urls/__init__.py 0 → 100644
from django.conf.urls import patterns, url, include
from analytics_data_api.v0.views import operational
urlpatterns = patterns(
'',
url(r'^status$', operational.StatusView.as_view()),
url(r'^authenticated$', operational.AuthenticationTestView.as_view()),
url(r'^health$', operational.HealthView.as_view()),
url(r'^courses/', include('analytics_data_api.v0.urls.courses', namespace='courses')),
)
analytics_data_api/v0/urls/courses.py 0 → 100644
import re
from django.conf.urls import patterns, url
from analytics_data_api.v0.views.courses import CourseActivityMostRecentWeekView, CourseEnrollmentByEducationView, \
CourseEnrollmentByBirthYearView, CourseEnrollmentByGenderView
COURSE_URLS = [
('recent_activity', CourseActivityMostRecentWeekView, 'recent_activity'),
('enrollment/birth_year', CourseEnrollmentByBirthYearView, 'enrollment_by_birth_year'),
('enrollment/education', CourseEnrollmentByEducationView, 'enrollment_by_education'),
('enrollment/gender', CourseEnrollmentByGenderView, 'enrollment_by_gender'),
]
urlpatterns = patterns(
'',
# url(r'^$', CourseDetailView.as_view(), name='detail')
)
for path, view, name in COURSE_URLS:
urlpatterns += patterns('', url(r'^(?P<course_key>.+)/' + re.escape(path) + r'$', view.as_view(), name=name))
analytics_data_api/v0/views/courses.py 0 → 100644
from django.core.exceptions import ObjectDoesNotExist
from django.http import Http404
from rest_framework import generics
from rest_framework.response import Response
from rest_framework.views import APIView
from analytics_data_api.v0.models import CourseActivityByWeek, CourseEnrollmentByBirthYear, \
CourseEnrollmentByEducation, CourseEnrollmentByGender
from analytics_data_api.v0.serializers import CourseActivityByWeekSerializer
class CourseActivityMostRecentWeekView(generics.RetrieveAPIView):
"""
Counts of users who performed various actions at least once during the most recently computed week.
The default is all users who performed <strong>any</strong> action in the course.
The representation has the following fields:
<ul>
<li>course_key: The ID of the course whose activity is described (e.g. edX/DemoX/Demo_Course).</li>
- interval_start: All data from this timestamp up to the `interval_end` was considered when computing this data
point.
- interval_end: All data from `interval_start` up to this timestamp was considered when computing this data point.
Note that data produced at exactly this time is **not** included.
- activity_type: The type of activity requested. Possible values are:
- ANY: The number of unique users who performed any action within the course, including actions not
enumerated below.
- PLAYED_VIDEO: The number of unique users who started watching any video in the course.
- ATTEMPTED_PROBLEM: The number of unique users who answered any loncapa based question in the course.
- POSTED_FORUM: The number of unique users who created a new post, responded to a post, or submitted a comment
on any forum in the course.
- count: The number of users who performed the activity indicated by the `activity_type`.
</ul>
activity_type -- The type of activity. (Defaults to "any".)
"""
serializer_class = CourseActivityByWeekSerializer
def get_object(self, queryset=None):
"""Select the activity report for the given course and activity type."""
course_key = self.kwargs.get('course_key')
activity_type = self.request.QUERY_PARAMS.get('activity_type', 'any')
activity_type = activity_type.lower()
try:
print CourseActivityByWeek.objects.all()
return CourseActivityByWeek.get_most_recent(course_key, activity_type)
except ObjectDoesNotExist:
raise Http404
class AbstractCourseEnrollmentView(APIView):
model = None
def render_data(self, data):
"""
Render view data
"""
raise NotImplementedError('Subclasses must define a render_data method!')
def get(self, request, *args, **kwargs): # pylint: disable=unused-argument
if not self.model:
raise NotImplementedError('Subclasses must specify a model!')
course_key = self.kwargs['course_key']
data = self.model.objects.filter(course__course_key=course_key)
if not data:
raise Http404
return Response(self.render_data(data))
class CourseEnrollmentByBirthYearView(AbstractCourseEnrollmentView):
"""
Course enrollment broken down by user birth year
Returns the enrollment of a course with users binned by their birth years.
"""
model = CourseEnrollmentByBirthYear
def render_data(self, data):
return {
'birth_years': dict(data.values_list('birth_year', 'num_enrolled_students'))
}
class CourseEnrollmentByEducationView(AbstractCourseEnrollmentView):
"""
Course enrollment broken down by user level of education
Returns the enrollment of a course with users binned by their education levels.
"""
model = CourseEnrollmentByEducation
def render_data(self, data):
return {
'education_levels': dict(data.values_list('education_level__short_name', 'num_enrolled_students'))
}
class CourseEnrollmentByGenderView(AbstractCourseEnrollmentView):
"""
Course enrollment broken down by user gender
Returns the enrollment of a course with users binned by their genders.
Genders:
m - male
f - female
o - other
"""
model = CourseEnrollmentByGender
def render_data(self, data):
return {
'genders': dict(data.values_list('gender', 'num_enrolled_students'))
}
analytics_data_api/v0/views/operational.py 0 → 100644
from rest_framework import permissions
from rest_framework.response import Response
from django.conf import settings
from django.db import connections
from rest_framework.views import APIView
class StatusView(APIView):
"""
Simple check to determine if the server is alive
Return no data, a simple 200 OK status code is sufficient to indicate that the server is alive. This endpoint is
public and does not require an authentication token to access it.
"""
permission_classes = (permissions.AllowAny,)
def get(self, request, *args, **kwargs): # pylint: disable=unused-argument
return Response({})
class AuthenticationTestView(APIView):
"""
Verifies that the client is authenticated
Returns HTTP 200 if client is authenticated, HTTP 401 if not authenticated
"""
def get(self, request, *args, **kwargs): # pylint: disable=unused-argument
return Response({})
class HealthView(APIView):
"""
A more comprehensive check to see if the system is fully operational.
This endpoint is public and does not require an authentication token to access it.
The returned structure contains the following fields:
- overall_status: Can be either "OK" or "UNAVAILABLE".
- detailed_status: More detailed information about the status of the system.
- database_connection: Status of the database connection. Can be either "OK" or "UNAVAILABLE".
"""
permission_classes = (permissions.AllowAny,)
def get(self, request, *args, **kwargs): # pylint: disable=unused-argument
overall_status = 'UNAVAILABLE'
db_conn_status = 'UNAVAILABLE'
try:
connection_name = getattr(settings, 'ANALYTICS_DATABASE', 'default')
cursor = connections[connection_name].cursor()
try:
cursor.execute("SELECT 1")
cursor.fetchone()
overall_status = 'OK'
db_conn_status = 'OK'
finally:
cursor.close()
except Exception: # pylint: disable=broad-except
pass
response = {
"overall_status": overall_status,
"detailed_status": {
'database_connection': db_conn_status
}
}
return Response(response)
analyticsdata/management/commands/set_api_key.py deleted 100644 → 0
"""A command to set the API key for a user using when using TokenAuthentication."""
from optparse import make_option
from django.contrib.auth.models import User
from django.core.exceptions import ObjectDoesNotExist
from django.core.management.base import BaseCommand, CommandError
from rest_framework.authtoken.models import Token
class Command(BaseCommand):
"""A command to set the API key for a user using when using TokenAuthentication."""
help = 'Set the API key for the specified user.'
args = '<username> <api_key>'
option_list = BaseCommand.option_list + (
make_option('--create-user', action='store_true', default=False,
help="Create a user if it doesn't exists"),
make_option('--delete-key', action='store_true', default=False,
help="Delete API key for user")
)
def handle(self, *args, **options):
"""Default Django BaseCommand handler."""
if options['delete_key']:
self._delete_user(*args)
else:
self._set_api_key(*args, **options)
def _delete_user(self, *args):
if len(args) != 1:
raise CommandError('Invalid or misssing arguments')
username = args[0]
tokens = Token.objects.filter(user__username=username)
if tokens.exists():
tokens.delete()
self.stdout.write('Removed API key for user: <{0}>\n'.format(username))
else:
self.stdout.write('Unknown user or user without an API key: <{0}>\n'.format(username))
def _set_api_key(self, *args, **options):
if len(args) != 2:
raise CommandError('Invalid or missing arguments')
username, key = args[0], args[1]
user = self._get_user(username, options['create_user'])
self._set_token(user, key)
def _get_user(self, username, create_user=False):
if create_user:
user, created = User.objects.get_or_create(username=username)
if created:
self.stdout.write('Created user: <{0}>\n'.format(user))
else:
try:
user = User.objects.get(username=username)
except ObjectDoesNotExist:
raise CommandError('Unknown user: <{0}>'.format(username))
return user
def _set_token(self, user, key):
# Check that no other user has the same key
tokens = Token.objects.filter(key=key)
if tokens.exists() and tokens[0].user != user:
raise CommandError('Key already in use.')
# Get and update the user key
_, created = Token.objects.get_or_create(user=user)
count = Token.objects.filter(user=user).update(key=key)
if count:
action = 'Created' if created else 'Updated'
self.stdout.write('{0} API key for user: <{1}>\n'.format(action, user))
else:
raise CommandError('Something went wrong.')
analyticsdata/models.py deleted 100644 → 0
from django.db import models
from rest_framework import serializers
class CourseActivityByWeek(models.Model):
"""A count of unique users who performed a particular action during a week."""
db_from_setting = 'ANALYTICS_DATABASE'
class Meta: # pylint: disable=old-style-class
db_table = 'course_activity'
course_id = models.CharField(db_index=True, max_length=255)
interval_start = models.DateTimeField()
interval_end = models.DateTimeField()
label = models.CharField(db_index=True, max_length=255)
count = models.IntegerField()
@classmethod
def get_most_recent(cls, course_id, label):
"""Activity for the week that was mostly recently computed."""
return cls.objects.filter(course_id=course_id, label=label).latest('interval_end')
class CourseActivityByWeekSerializer(serializers.ModelSerializer):
"""
Representation of CourseActivityByWeek that excludes the id field.
This table is managed by the data pipeline, and records can be removed and added at any time. The id for a
particular record is likely to change unexpectedly so we avoid exposing it.
"""
class Meta: # pylint: disable=old-style-class
model = CourseActivityByWeek
fields = ('course_id', 'interval_start', 'interval_end', 'label', 'count')
analyticsdata/tests.py deleted 100644 → 0
from contextlib import contextmanager
from datetime import datetime
from functools import partial
from django.conf import settings
from django.contrib.auth.models import User
from django.db.utils import ConnectionHandler
from django.test import TestCase
from django.test.utils import override_settings
from mock import patch
import pytz
from rest_framework.authtoken.models import Token
from analyticsdata.views import handle_internal_server_error, handle_missing_resource_error
# NOTE: Full URLs are used throughout these tests to ensure that the API contract is fulfilled. The URLs should *not*
# change for versions greater than 1.0.0. Tests target a specific version of the API, additional tests should be added
# for subsequent versions if there are breaking changes introduced in those versions.
class TestCaseWithAutenticatation(TestCase):
def setUp(self):
super(TestCaseWithAutenticatation, self).setUp()
test_user = User.objects.create_user('tester', 'test@example.com', 'testpassword')
token = Token.objects.create(user=test_user)
self.authenticated_get = partial(self.client.get, HTTP_AUTHORIZATION='Token ' + token.key)
class OperationalEndpointsTest(TestCaseWithAutenticatation):
def test_status(self):
response = self.client.get('/api/v0/status')
self.assertEquals(response.status_code, 200)
def test_authentication_check_failure(self):
response = self.client.get('/api/v0/authenticated')
self.assertEquals(response.status_code, 401)
def test_authentication_check_success(self):
response = self.authenticated_get('/api/v0/authenticated')
self.assertEquals(response.status_code, 200)
def test_health(self):
self.assert_database_health('OK')
def assert_database_health(self, status):
response = self.client.get('/api/v0/health')
self.assertEquals(
response.data,
{
'overall_status': status,
'detailed_status': {
'database_connection': status
}
}
)
self.assertEquals(response.status_code, 200)
def test_database_down(self):
databases = {
"default": {}
}
with self.override_database_connections(databases):
self.assert_database_health('UNAVAILABLE')
@staticmethod
@contextmanager
def override_database_connections(databases):
with patch('analyticsdata.views.connections', ConnectionHandler(databases)):
yield
@override_settings(ANALYTICS_DATABASE='reporting')
def test_read_setting(self):
databases = dict(settings.DATABASES)
databases['reporting'] = {}
with self.override_database_connections(databases):
self.assert_database_health('UNAVAILABLE')
# Workaround to remove a setting from django settings. It has to be used in override_settings and then deleted.
@override_settings(ANALYTICS_DATABASE='reporting')
def test_default_setting(self):
del settings.ANALYTICS_DATABASE
databases = dict(settings.DATABASES)
databases['reporting'] = {}
with self.override_database_connections(databases):
# This would normally return UNAVAILABLE, however we have deleted the settings so it will use the default
# connection which should be OK.
self.assert_database_health('OK')
class ErrorHandlingTest(TestCase):
def test_internal_server_error_handling(self):
response = handle_internal_server_error(None)
self.validate_error_response(response, 500)
def validate_error_response(self, response, status_code):
self.assertEquals(response.content, '{{"status": {0}}}'.format(status_code))
self.assertEquals(response.status_code, status_code)
self.assertEquals(response.get('Content-Type'), 'application/json; charset=utf-8')
def test_missing_resource_handling(self):
response = handle_missing_resource_error(None)
self.validate_error_response(response, 404)
class CourseActivityLastWeekTest(TestCaseWithAutenticatation):
fixtures = ['single_course_activity']
COURSE_ID = 'edX/DemoX/Demo_Course'
def test_activity(self):
response = self.authenticated_get('/api/v0/courses/{0}/recent_activity'.format(self.COURSE_ID))
self.assertEquals(response.status_code, 200)
self.assertEquals(response.data, self.get_activity_record())
@staticmethod
def get_activity_record(**kwargs):
default = {
'course_id': 'edX/DemoX/Demo_Course',
'interval_start': datetime(2014, 5, 24, 0, 0, tzinfo=pytz.utc),
'interval_end': datetime(2014, 6, 1, 0, 0, tzinfo=pytz.utc),
'label': 'ACTIVE',
'count': 300,
}
default.update(kwargs)
return default
def test_activity_auth(self):
response = self.client.get('/api/v0/courses/{0}/recent_activity'.format(self.COURSE_ID))
self.assertEquals(response.status_code, 401)
def test_url_encoded_course_id(self):
response = self.authenticated_get('/api/v0/courses/edX%2FDemoX%2FDemo_Course/recent_activity')
self.assertEquals(response.status_code, 200)
self.assertEquals(response.data, self.get_activity_record())
def test_video_activity(self):
label = 'PLAYED_VIDEO'
response = self.authenticated_get('/api/v0/courses/{0}/recent_activity?label={1}'.format(self.COURSE_ID, label))
self.assertEquals(response.status_code, 200)
self.assertEquals(response.data, self.get_activity_record(label=label, count=400))
def test_unknown_activity(self):
label = 'MISSING_ACTIVITY_TYPE'
response = self.authenticated_get('/api/v0/courses/{0}/recent_activity?label={1}'.format(self.COURSE_ID, label))
self.assertEquals(response.status_code, 404)
def test_unknown_course_id(self):
response = self.authenticated_get('/api/v0/courses/{0}/recent_activity'.format('foo'))
self.assertEquals(response.status_code, 404)
def test_missing_course_id(self):
response = self.authenticated_get('/api/v0/courses/recent_activity')
self.assertEquals(response.status_code, 404)
analyticsdata/views.py deleted 100644 → 0
from rest_framework import generics
from rest_framework.decorators import api_view, permission_classes
from rest_framework.permissions import AllowAny
from rest_framework.renderers import JSONRenderer
from rest_framework.response import Response
from django.conf import settings
from django.core.exceptions import ObjectDoesNotExist
from django.db import connections
from django.http import HttpResponse, Http404
from analyticsdata.models import CourseActivityByWeek
from analyticsdata.models import CourseActivityByWeekSerializer
@api_view(['GET'])
@permission_classes((AllowAny, ))
def status(_request):
"""
A very quick check to see if the application server is alive and processing requests.
Return no data, a simple 200 OK status code is sufficient to indicate that the server is alive. This endpoint is
public and does not require an authentication token to access it.
"""
return Response()
@api_view(['GET'])
def authenticated(_request):
"""
Validate provided credentials.
Return no data, a simple 200 OK status code is sufficient to indicate that the credentials are valid.
"""
return Response()
@api_view(['GET'])
@permission_classes((AllowAny, ))
def health(_request):
"""
A more comprehensive check to see if the system is fully operational.
This endpoint is public and does not require an authentication token to access it.
The returned structure contains the following fields:
- overall_status: Can be either "OK" or "UNAVAILABLE".
- detailed_status: More detailed information about the status of the system.
- database_connection: Status of the database connection. Can be either "OK" or "UNAVAILABLE".
"""
overall_status = 'OK'
db_conn_status = 'OK'
connection_name = getattr(settings, 'ANALYTICS_DATABASE', 'default')
try:
cursor = connections[connection_name].cursor()
try:
cursor.execute("SELECT 1")
cursor.fetchone()
finally:
cursor.close()
except Exception: # pylint: disable=broad-except
overall_status = 'UNAVAILABLE'
db_conn_status = 'UNAVAILABLE'
response = {
"overall_status": overall_status,
"detailed_status": {
'database_connection': db_conn_status
}
}
return Response(response)
def handle_internal_server_error(_request):
"""Notify the client that an error occurred processing the request without providing any detail."""
return _handle_error(500)
def handle_missing_resource_error(_request):
"""Notify the client that the requested resource could not be found."""
return _handle_error(404)
def _handle_error(status_code):
info = {
'status': status_code
}
renderer = JSONRenderer()
content_type = '{media}; charset={charset}'.format(media=renderer.media_type, charset=renderer.charset)
return HttpResponse(renderer.render(info), content_type=content_type, status=status_code)
class CourseActivityMostRecentWeekView(generics.RetrieveAPIView):
"""
Counts of users who performed various actions at least once during the most recently computed week.
The default is all users who performed *any* action in the course.
The representation has the following fields:
- course_id: The ID of the course whose activity is described.
- interval_start: All data from this timestamp up to the `interval_end` was considered when computing this data
point.
- interval_end: All data from `interval_start` up to this timestamp was considered when computing this data point.
Note that data produced at exactly this time is **not** included.
- label: The type of activity requested. Possible values are:
- ACTIVE: The number of unique users who performed any action within the course, including actions not
enumerated below.
- PLAYED_VIDEO: The number of unique users who started watching any video in the course.
- ATTEMPTED_PROBLEM: The number of unique users who answered any loncapa based question in the course.
- POSTED_FORUM: The number of unique users who created a new post, responded to a post, or submitted a comment
on any forum in the course.
- count: The number of users who performed the activity indicated by the `label`.
Parameters:
- course_id (string): Unique identifier for the course.
- label (string): The type of activity. Defaults to `ACTIVE`. Possible values:
- `ACTIVE`
- `PLAYED_VIDEO`
- `ATTEMPTED_PROBLEM`
- `POSTED_FORUM`
"""
serializer_class = CourseActivityByWeekSerializer
def get_object(self): # pylint: disable=arguments-differ
"""Select the activity report for the given course and label."""
course_id = self.kwargs.get('course_id')
label = self.request.QUERY_PARAMS.get('label', 'ACTIVE')
try:
return CourseActivityByWeek.get_most_recent(course_id, label)
except ObjectDoesNotExist:
raise Http404
analyticsdataserver/router.py
from django.conf import settings from django.conf import settings
class DatabaseFromSettingRouter(object): class DatabaseFromSettingRouter(object):
def db_for_read(self, model, **hints): def db_for_read(self, model, **hints):
return self._get_database(model) return self._get_database(model)
def _get_database(self, model): def _get_database(self, model):
if model._meta.app_label == 'v0':
return getattr(settings, 'ANALYTICS_DATABASE', 'default')
if getattr(model, 'db_from_setting', None): if getattr(model, 'db_from_setting', None):
return getattr(settings, model.db_from_setting, 'default') return getattr(settings, model.db_from_setting, 'default')
else:
return None return None
def db_for_write(self, model, **hints): def db_for_write(self, model, **hints):
......
analyticsdataserver/settings/base.py
...@@ -185,10 +185,12 @@ THIRD_PARTY_APPS = ( ...@@ -185,10 +185,12 @@ THIRD_PARTY_APPS = (
'south', 'south',
'rest_framework', 'rest_framework',
'rest_framework.authtoken', 'rest_framework.authtoken',
'rest_framework_swagger',
) )
LOCAL_APPS = ( LOCAL_APPS = (
'analyticsdata', 'analytics_data_api',
'analytics_data_api.v0',
) )
# See: https://docs.djangoproject.com/en/dev/ref/settings/#installed-apps # See: https://docs.djangoproject.com/en/dev/ref/settings/#installed-apps
...@@ -251,6 +253,7 @@ REST_FRAMEWORK = { ...@@ -251,6 +253,7 @@ REST_FRAMEWORK = {
} }
########## END REST FRAMEWORK CONFIGURATION ########## END REST FRAMEWORK CONFIGURATION
########## ANALYTICS DATA API CONFIGURATION ########## ANALYTICS DATA API CONFIGURATION
ANALYTICS_DATABASE = 'default' ANALYTICS_DATABASE = 'default'
......
analyticsdataserver/settings/local.py
...@@ -58,6 +58,7 @@ CACHES = { ...@@ -58,6 +58,7 @@ CACHES = {
# See: https://github.com/django-debug-toolbar/django-debug-toolbar#installation # See: https://github.com/django-debug-toolbar/django-debug-toolbar#installation
INSTALLED_APPS += ( INSTALLED_APPS += (
'debug_toolbar', 'debug_toolbar',
'django_nose',
) )
# See: https://github.com/django-debug-toolbar/django-debug-toolbar#installation # See: https://github.com/django-debug-toolbar/django-debug-toolbar#installation
...@@ -70,7 +71,6 @@ MIDDLEWARE_CLASSES += ( ...@@ -70,7 +71,6 @@ MIDDLEWARE_CLASSES += (
# See: https://github.com/django-debug-toolbar/django-debug-toolbar#installation # See: https://github.com/django-debug-toolbar/django-debug-toolbar#installation
DEBUG_TOOLBAR_CONFIG = { DEBUG_TOOLBAR_CONFIG = {
'INTERCEPT_REDIRECTS': False,
'SHOW_TEMPLATE_CONTEXT': True, 'SHOW_TEMPLATE_CONTEXT': True,
} }
########## END TOOLBAR CONFIGURATION ########## END TOOLBAR CONFIGURATION
...@@ -81,3 +81,5 @@ ANALYTICS_DATABASE = 'analytics' ...@@ -81,3 +81,5 @@ ANALYTICS_DATABASE = 'analytics'
ENABLE_ADMIN_SITE = True ENABLE_ADMIN_SITE = True
########## END ANALYTICS DATA API CONFIGURATION ########## END ANALYTICS DATA API CONFIGURATION
TEST_RUNNER = 'django_nose.NoseTestSuiteRunner'
analyticsdataserver/urls.py
from django.conf import settings from django.conf import settings
from django.conf.urls import patterns, include, url from django.conf.urls import patterns, include, url
from django.contrib import admin from django.contrib import admin
from django.views.generic import RedirectView
urlpatterns = patterns( urlpatterns = patterns(
'', '',
url(r'^$', RedirectView.as_view(url='/docs')),
# Support logging in to the browseable API # Support logging in to the browseable API
url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework')), url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework')),
...@@ -12,15 +15,13 @@ urlpatterns = patterns( ...@@ -12,15 +15,13 @@ urlpatterns = patterns(
url(r'^api-token-auth/', 'rest_framework.authtoken.views.obtain_auth_token'), url(r'^api-token-auth/', 'rest_framework.authtoken.views.obtain_auth_token'),
# Route all reports URLs to this endpoint # Route all reports URLs to this endpoint
# TODO: come up with a better way to handle versioning, maybe a decorator? url(r'^api/', include('analytics_data_api.urls', namespace='api')),
url(r'^api/v0/', include('analyticsdata.urls')), url(r'^docs/', include('rest_framework_swagger.urls')),
) )
if settings.ENABLE_ADMIN_SITE: if settings.ENABLE_ADMIN_SITE:
admin.autodiscover() admin.autodiscover()
urlpatterns += patterns('', url(r'^site/admin/', include(admin.site.urls))) urlpatterns += patterns('', url(r'^site/admin/', include(admin.site.urls)))
handler500 = 'analyticsdataserver.views.handle_internal_server_error' # pylint: disable=invalid-name
handler500 = 'analyticsdata.views.handle_internal_server_error' # pylint: disable=invalid-name handler404 = 'analyticsdataserver.views.handle_missing_resource_error' # pylint: disable=invalid-name
handler404 = 'analyticsdata.views.handle_missing_resource_error' # pylint: disable=invalid-name
analyticsdataserver/views.py 0 → 100644
from django.http import HttpResponse
from rest_framework.renderers import JSONRenderer
def handle_internal_server_error(_request):
"""Notify the client that an error occurred processing the request without providing any detail."""
return _handle_error(500)
def handle_missing_resource_error(_request):
"""Notify the client that the requested resource could not be found."""
return _handle_error(404)
def _handle_error(status_code):
info = {
'status': status_code
}
renderer = JSONRenderer()
content_type = '{media}; charset={charset}'.format(media=renderer.media_type, charset=renderer.charset)
return HttpResponse(renderer.render(info), content_type=content_type, status=status_code)
requirements/base.txt
Django==1.4.12 Django==1.6.5
Markdown==2.4.1 Markdown==2.4.1
South==0.8.1 South==0.8.1
django-model-utils==1.4.0 django-model-utils==1.4.0
djangorestframework==2.3.5 djangorestframework==2.3.5
ipython==2.1.0 ipython==2.1.0
django-rest-swagger==0.1.14
requirements/local.txt
# Local development dependencies go here # Local development dependencies go here
-r base.txt -r base.txt
django-debug-toolbar==0.9.4 django-debug-toolbar==1.2.1
requirements/test.txt
...@@ -2,12 +2,11 @@ ...@@ -2,12 +2,11 @@
-r base.txt -r base.txt
coverage==3.7 coverage==3.7
diff-cover >= 0.2.1 diff-cover >= 0.2.1
django-dynamic-fixture==1.7.0
django-nose==1.2 django-nose==1.2
httpretty==0.8.0
mock==1.0.1 mock==1.0.1
nose==1.3.3 nose==1.3.3
pep257==0.3.2 pep257==0.3.2
pep8==1.5.7 pep8==1.5.7
pylint==1.2.1 pylint==1.2.1
pytz==2012h pytz==2012h
requests==2.3.0
static/css/edx-swagger.css 0 → 100644
#header form#api_selector .input a#explore {
color: white;
background-color: #126F9E;
box-shadow: 0 2px 1px 0 #0a4a67;
}
#header form#api_selector .input a#explore:hover {
background-color: #1790c7;
}
#header {
border-bottom: 1px solid #8a8c8f;
box-shadow: 0 1px 5px 0 rgba(0, 0, 0, 0.1);
background: #fff;
}
#header a#logo {
background: transparent url(../images/header-logo.png) no-repeat left center;
padding-left: 100px;
}
body {
background: #f5f5f5;
}
#swagger-ui-container, #message-bar {
background: white;
}
#swagger-ui-container {
padding-bottom: 20px;
}
templates/rest_framework_swagger/index.html 0 → 100644
{% load staticfiles %}
<!DOCTYPE html>
<html>
<head>
<title>edX Analytics API</title>
<link href='//fonts.googleapis.com/css?family=Droid+Sans:400,700' rel='stylesheet' type='text/css'/>
<link href='{% static "rest_framework_swagger/css/highlight.default.css" %}' media='screen' rel='stylesheet' type='text/css'/>
<link href='{% static "rest_framework_swagger/css/rest_framework_swagger.css" %}' media='screen' rel='stylesheet' type='text/css'/>
<link href='{% static "rest_framework_swagger/css/screen.css" %}' media='screen' rel='stylesheet' type='text/css'/>
<link href='{% static "css/edx-swagger.css" %}' media='screen' rel='stylesheet' type='text/css'/>
<script type="text/javascript" src="{% static 'rest_framework_swagger/lib/shred.bundle.js' %}"></script>
<script src='{% static "rest_framework_swagger/lib/jquery-1.8.0.min.js" %}' type='text/javascript'></script>
<script src='{% static "rest_framework_swagger/lib/jquery.slideto.min.js" %}' type='text/javascript'></script>
<script src='{% static "rest_framework_swagger/lib/jquery.wiggle.min.js" %}' type='text/javascript'></script>
<script src='{% static "rest_framework_swagger/lib/jquery.ba-bbq.min.js" %}' type='text/javascript'></script>
<script src='{% static "rest_framework_swagger/lib/jquery.cookie.js" %}' type='text/javascript'></script>
<script src='{% static "rest_framework_swagger/lib/handlebars-1.0.0.js" %}' type='text/javascript'></script>
<script src='{% static "rest_framework_swagger/lib/underscore-min.js" %}' type='text/javascript'></script>
<script src='{% static "rest_framework_swagger/lib/backbone-min.js" %}' type='text/javascript'></script>
<script src='{% static "rest_framework_swagger/lib/swagger.js" %}' type='text/javascript'></script>
<script src='{% static "rest_framework_swagger/swagger-ui.min.js" %}' type='text/javascript'></script>
<script src='{% static "rest_framework_swagger/lib/highlight.7.3.pack.js" %}' type='text/javascript'></script>
<link rel="icon" type="image/x-icon" href='{% static "images/favicon.ico" %}' />
<script type="text/javascript">
$(function () {
window.swaggerUi = new SwaggerUi({
url: "{{ swagger_settings.discovery_url }}",
apiKey: "{{ swagger_settings.api_key }}",
dom_id: "swagger-ui-container",
supportedSubmitMethods: {{ swagger_settings.enabled_methods }},
onComplete: function(swaggerApi, swaggerUi){
if(console) {
console.log("Loaded SwaggerUI")
}
$('pre code').each(function(i, e) {hljs.highlightBlock(e)});
},
onFailure: function(data) {
if(console) {
console.log("Unable to Load SwaggerUI");
console.log(data);
}
},
docExpansion: "none"
});
$('#input_apiKey').change(function() {
var key = $('#input_apiKey')[0].value;
console.log("key: " + key);
if(key && key.trim() != "") {
console.log("added key " + key);
window.authorizations.add("key", new ApiKeyAuthorization("Authorization", "Token " + key, "header"));
}
})
{% if swagger_settings.api_key %}
window.authorizations.add("key", new ApiKeyAuthorization("Authorization", "Token " + "{{ swagger_settings.api_key }}", "header"));
{% endif %}
window.swaggerUi.load();
});
</script>
</head>
<body>
<div id='header'>
<div class="swagger-ui-wrap">
<a id="logo" class="edx-logo" href="http://code.edx.org/"></a>
<form id='api_selector'>
<div class='input'><input placeholder="http://example.com/api" id="input_baseUrl" name="baseUrl" type="text"/></div>
<div class='input'><input placeholder="API Key" id="input_apiKey" name="apiKey" type="text"/></div>
<div class='input'><a id="explore" href="#">Explore</a></div>
</form>
</div>
</div>
<div id="message-bar" class="swagger-ui-wrap">
&nbsp;
</div>
<div id="swagger-ui-container" class="swagger-ui-wrap">
</div>
</body>
</html>
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