Merge pull request #7 from edx/schema-updates

Schema updates

Makefile

@@ -50,7 +50,7 @@ syncdb:
 	$(foreach db_name,$(DATABASES),./manage.py syncdb --migrate --noinput --database=$(db_name);)
 
 loaddata: syncdb
-	python manage.py loaddata courses education_levels countries single_course_activity problem_response_answer_distribution --database=analytics
+	python manage.py loaddata education_levels single_course_activity problem_response_answer_distribution --database=analytics
 	python manage.py generate_fake_enrollment_data
 
 demo: clean requirements loaddata

analytics_data_api/fixtures/courses.json

-[
-    {
-        "pk": 1,
-        "model": "v0.course",
-        "fields": {
-            "course_id": "edX/DemoX/Demo_Course"
-        }
-    }
-]

analytics_data_api/fixtures/single_course_activity.json

@@ -3,7 +3,7 @@
         "pk": 40, 
         "model": "v0.CourseActivityByWeek",
         "fields": {
-            "course": ["edX/DemoX/Demo_Course"],
+            "course_id": "edX/DemoX/Demo_Course",
             "interval_start": "2014-05-24T00:00:00Z", 
             "activity_type": "posted_forum",
             "count": 100, 
@@ -14,7 +14,7 @@
         "pk": 106, 
         "model": "v0.CourseActivityByWeek",
         "fields": {
-            "course": ["edX/DemoX/Demo_Course"], 
+            "course_id": "edX/DemoX/Demo_Course", 
             "interval_start": "2014-05-24T00:00:00Z", 
             "activity_type": "attempted_problem",
             "count": 200, 
@@ -25,7 +25,7 @@
         "pk": 201, 
         "model": "v0.CourseActivityByWeek",
         "fields": {
-            "course": ["edX/DemoX/Demo_Course"], 
+            "course_id": "edX/DemoX/Demo_Course", 
             "interval_start": "2014-05-24T00:00:00Z", 
             "activity_type": "any",
             "count": 300, 
@@ -36,7 +36,7 @@
         "pk": 725, 
         "model": "v0.CourseActivityByWeek",
         "fields": {
-            "course": ["edX/DemoX/Demo_Course"], 
+            "course_id": "edX/DemoX/Demo_Course", 
             "interval_start": "2014-05-24T00:00:00Z", 
             "activity_type": "played_video",
             "count": 400, 

analytics_data_api/management/commands/generate_fake_enrollment_data.py

+# pylint: disable=line-too-long
+
 import datetime
 import random
 
@@ -23,7 +25,7 @@ class Command(BaseCommand):
     def handle(self, *args, **options):
 
         days = 120
-        course = models.Course.objects.first()
+        course_id = 'edX/DemoX/Demo_Course'
         start_date = datetime.date(year=2014, month=1, day=1)
 
         genders = {
@@ -58,33 +60,36 @@ class Command(BaseCommand):
         birth_years = dict(zip(birth_years, ratios))
 
         # Delete existing data
-        for model in [models.CourseEnrollmentDaily, models.CourseEnrollmentByGender, models.CourseEnrollmentByEducation,
-                      models.CourseEnrollmentByBirthYear, models.CourseEnrollmentByCountry]:
+        for model in [models.CourseEnrollmentDaily,
+                      models.CourseEnrollmentByGender,
+                      models.CourseEnrollmentByEducation,
+                      models.CourseEnrollmentByBirthYear,
+                      models.CourseEnrollmentByCountry]:
             model.objects.all().delete()
 
-        # Create new data data
+        # Create new data
         daily_total = 1500
         for i in range(days):
             daily_total = get_count(daily_total)
             date = start_date + datetime.timedelta(days=i)
-            models.CourseEnrollmentDaily.objects.create(course=course, date=date, count=daily_total)
+            models.CourseEnrollmentDaily.objects.create(course_id=course_id, date=date, count=daily_total)
 
             for gender, ratio in genders.iteritems():
                 count = int(ratio * daily_total)
-                models.CourseEnrollmentByGender.objects.create(course=course, date=date, count=count, gender=gender)
+                models.CourseEnrollmentByGender.objects.create(course_id=course_id, date=date, count=count, gender=gender)
 
             for short_name, ratio in education_levels.iteritems():
                 education_level = models.EducationLevel.objects.get(short_name=short_name)
                 count = int(ratio * daily_total)
-                models.CourseEnrollmentByEducation.objects.create(course=course, date=date, count=count,
+                models.CourseEnrollmentByEducation.objects.create(course_id=course_id, date=date, count=count,
                                                                   education_level=education_level)
 
-            for code, ratio in countries.iteritems():
-                country = models.Country.objects.get(code=code)
+            for country_code, ratio in countries.iteritems():
                 count = int(ratio * daily_total)
-                models.CourseEnrollmentByCountry.objects.create(course=course, date=date, count=count, country=country)
+                models.CourseEnrollmentByCountry.objects.create(course_id=course_id, date=date, count=count,
+                                                                country_code=country_code)
 
             for birth_year, ratio in birth_years.iteritems():
                 count = int(ratio * daily_total)
-                models.CourseEnrollmentByBirthYear.objects.create(course=course, date=date, count=count,
+                models.CourseEnrollmentByBirthYear.objects.create(course_id=course_id, date=date, count=count,
                                                                   birth_year=birth_year)

analytics_data_api/v0/managers.py

-from django.db import models
-
-
-class CourseManager(models.Manager):
-    def get_by_natural_key(self, course_id):
-        return self.get(course_id=course_id)
-
-
-class CountryManager(models.Manager):
-    def get_by_natural_key(self, code):
-        return self.get(code=code)

analytics_data_api/v0/models.py

+from collections import namedtuple
 from django.db import models
-from analytics_data_api.v0.managers import CourseManager, CountryManager
-
-
-class Course(models.Model):
-    course_id = models.CharField(unique=True, max_length=255)
-
-    objects = CourseManager()  # pylint: disable=no-value-for-parameter
-
-    class Meta(object):
-        db_table = 'courses'
+from iso3166 import countries
 
 
 class CourseActivityByWeek(models.Model):
@@ -17,7 +9,7 @@ class CourseActivityByWeek(models.Model):
     class Meta(object):
         db_table = 'course_activity'
 
-    course = models.ForeignKey(Course, null=False)
+    course_id = models.CharField(max_length=255)
     interval_start = models.DateTimeField()
     interval_end = models.DateTimeField()
     activity_type = models.CharField(db_index=True, max_length=255)
@@ -26,33 +18,35 @@ class CourseActivityByWeek(models.Model):
     @classmethod
     def get_most_recent(cls, course_id, activity_type):
         """Activity for the week that was mostly recently computed."""
-        return cls.objects.filter(course__course_id=course_id, activity_type=activity_type).latest('interval_end')
+        return cls.objects.filter(course_id=course_id, activity_type=activity_type).latest('interval_end')
 
 
 class BaseCourseEnrollment(models.Model):
-    course = models.ForeignKey(Course, null=False)
+    course_id = models.CharField(max_length=255)
     date = models.DateField(null=False, db_index=True)
     count = models.IntegerField(null=False)
+    created = models.DateTimeField(auto_now_add=True)
 
     class Meta(object):
         abstract = True
         get_latest_by = 'date'
+        index_together = [('course_id', 'date',)]
 
 
 class CourseEnrollmentDaily(BaseCourseEnrollment):
     class Meta(BaseCourseEnrollment.Meta):
         db_table = 'course_enrollment_daily'
-        ordering = ('date', 'course')
-        unique_together = [('course', 'date',)]
+        ordering = ('date', 'course_id')
+        unique_together = [('course_id', 'date',)]
 
 
 class CourseEnrollmentByBirthYear(BaseCourseEnrollment):
     birth_year = models.IntegerField(null=False)
 
     class Meta(BaseCourseEnrollment.Meta):
-        db_table = 'course_enrollment_birth_year'
-        ordering = ('date', 'course', 'birth_year')
-        unique_together = [('course', 'date', 'birth_year')]
+        db_table = 'course_enrollment_birth_year_daily'
+        ordering = ('date', 'course_id', 'birth_year')
+        unique_together = [('course_id', 'date', 'birth_year')]
 
 
 class EducationLevel(models.Model):
@@ -70,18 +64,18 @@ class CourseEnrollmentByEducation(BaseCourseEnrollment):
     education_level = models.ForeignKey(EducationLevel)
 
     class Meta(BaseCourseEnrollment.Meta):
-        db_table = 'course_enrollment_education_level'
-        ordering = ('date', 'course', 'education_level')
-        unique_together = [('course', 'date', 'education_level')]
+        db_table = 'course_enrollment_education_level_daily'
+        ordering = ('date', 'course_id', 'education_level')
+        unique_together = [('course_id', 'date', 'education_level')]
 
 
 class CourseEnrollmentByGender(BaseCourseEnrollment):
     gender = models.CharField(max_length=255, null=False)
 
     class Meta(BaseCourseEnrollment.Meta):
-        db_table = 'course_enrollment_gender'
-        ordering = ('date', 'course', 'gender')
-        unique_together = [('course', 'date', 'gender')]
+        db_table = 'course_enrollment_gender_daily'
+        ordering = ('date', 'course_id', 'gender')
+        unique_together = [('course_id', 'date', 'gender')]
 
 
 class ProblemResponseAnswerDistribution(models.Model):
@@ -102,23 +96,18 @@ class ProblemResponseAnswerDistribution(models.Model):
     created = models.DateTimeField(auto_now_add=True, db_column='created')
 
 
-class Country(models.Model):
-    code = models.CharField(max_length=2, primary_key=True)
-    name = models.CharField(max_length=255, unique=True, null=False)
-
-    objects = CountryManager()  # pylint: disable=no-value-for-parameter
-
-    class Meta(object):
-        db_table = 'countries'
-
-    def __unicode__(self):
-        return "{0} - {1}".format(self.code, self.name)
+Country = namedtuple('Country', 'name, code')
 
 
 class CourseEnrollmentByCountry(BaseCourseEnrollment):
-    country = models.ForeignKey(Country, null=False, db_column='country_code')
+    country_code = models.CharField(max_length=255, null=False, db_column='country_code')
+
+    @property
+    def country(self):
+        country = countries.get(self.country_code)
+        return Country(country.name, country.alpha2)
 
     class Meta(BaseCourseEnrollment.Meta):
-        db_table = 'course_enrollment_location'
-        ordering = ('date', 'course', 'country')
-        unique_together = [('course', 'date', 'country')]
+        db_table = 'course_enrollment_location_current'
+        ordering = ('date', 'course_id', 'country_code')
+        unique_together = [('course_id', 'date', 'country_code')]

analytics_data_api/v0/serializers.py

@@ -3,16 +3,7 @@ from rest_framework import serializers
 from analytics_data_api.v0 import models
 
 
-class CourseIdMixin(object):
-    def get_course_id(self, obj):
-        return obj.course.course_id
-
-
-class RequiredSerializerMethodField(serializers.SerializerMethodField):
-    required = True
-
-
-class CourseActivityByWeekSerializer(serializers.ModelSerializer, CourseIdMixin):
+class CourseActivityByWeekSerializer(serializers.ModelSerializer):
     """
     Representation of CourseActivityByWeek that excludes the id field.
 
@@ -20,8 +11,6 @@ class CourseActivityByWeekSerializer(serializers.ModelSerializer, CourseIdMixin)
     particular record is likely to change unexpectedly so we avoid exposing it.
     """
 
-    course_id = RequiredSerializerMethodField('get_course_id')
-
     class Meta(object):
         model = models.CourseActivityByWeek
         fields = ('interval_start', 'interval_end', 'activity_type', 'count', 'course_id')
@@ -51,8 +40,7 @@ class ProblemResponseAnswerDistributionSerializer(serializers.ModelSerializer):
         )
 
 
-class BaseCourseEnrollmentModelSerializer(serializers.ModelSerializer, CourseIdMixin):
-    course_id = RequiredSerializerMethodField('get_course_id')
+class BaseCourseEnrollmentModelSerializer(serializers.ModelSerializer):
     date = serializers.DateField(format=settings.DATE_FORMAT)
 
 
@@ -64,11 +52,9 @@ class CourseEnrollmentDailySerializer(BaseCourseEnrollmentModelSerializer):
         fields = ('course_id', 'date', 'count')
 
 
-# pylint: disable=no-value-for-parameter
-class CountrySerializer(serializers.ModelSerializer):
-    class Meta(object):
-        model = models.Country
-        fields = ('code', 'name')
+class CountrySerializer(serializers.Serializer):
+    code = serializers.CharField()
+    name = serializers.CharField()
 
 
 # pylint: disable=no-value-for-parameter
@@ -79,7 +65,8 @@ class EducationLevelSerializer(serializers.ModelSerializer):
 
 
 class CourseEnrollmentByCountrySerializer(BaseCourseEnrollmentModelSerializer):
-    country = CountrySerializer()
+    # pylint: disable=unexpected-keyword-arg
+    country = CountrySerializer(many=False)
 
     class Meta(object):
         model = models.CourseEnrollmentByCountry

analytics_data_api/v0/tests/test_managers.py

-from django.core.exceptions import ObjectDoesNotExist
-
-from django.test import TestCase
-from django_dynamic_fixture import G
-
-from analytics_data_api.v0.models import Course, Country
-
-
-class CourseManagerTests(TestCase):
-    def test_get_by_natural_key(self):
-        course_id = 'edX/DemoX/Demo_Course'
-        self.assertRaises(ObjectDoesNotExist, Course.objects.get_by_natural_key, course_id)
-
-        course = G(Course, course_id=course_id)
-        self.assertEqual(course, Course.objects.get_by_natural_key(course_id))
-
-
-class CountryManagerTests(TestCase):
-    def test_get_by_natural_key(self):
-        code = 'US'
-        self.assertRaises(ObjectDoesNotExist, Country.objects.get_by_natural_key, code)
-
-        country = G(Country, code=code)
-        self.assertEqual(country, Country.objects.get_by_natural_key(code))

analytics_data_api/v0/tests/test_models.py

@@ -2,22 +2,31 @@ from django.test import TestCase
 
 from django_dynamic_fixture import G
 
-from analytics_data_api.v0.models import EducationLevel, Country
+from analytics_data_api.v0 import models
 
 
 class EducationLevelTests(TestCase):
     def test_unicode(self):
         short_name = 'high_school'
         name = 'High School'
-        education_level = G(EducationLevel, short_name=short_name, name=name)
+        education_level = G(models.EducationLevel, short_name=short_name,
+                            name=name)
 
-        self.assertEqual(unicode(education_level), "{0} - {1}".format(short_name, name))
+        self.assertEqual(unicode(education_level),
+                         "{0} - {1}".format(short_name, name))
 
 
 class CountryTests(TestCase):
-    def test_unicode(self):
-        code = 'US'
-        name = 'United States of America'
-        country = G(Country, code=code, name=name)
-
-        self.assertEqual(unicode(country), "{0} - {1}".format(code, name))
+    # pylint: disable=no-member
+    def test_attributes(self):
+        country = models.Country('Canada', 'CA')
+        self.assertEqual(country.code, 'CA')
+        self.assertEqual(country.name, 'Canada')
+
+
+class CourseEnrollmentByCountryTests(TestCase):
+    def test_country(self):
+        country = models.Country('United States', 'US')
+        instance = G(models.CourseEnrollmentByCountry,
+                     country_code=country.code)
+        self.assertEqual(instance.country, country)

analytics_data_api/v0/views/courses.py

@@ -5,7 +5,6 @@ from django.core.exceptions import ObjectDoesNotExist
 from django.db.models import Max
 from django.http import Http404
 from rest_framework import generics
-from rest_framework.generics import get_object_or_404
 
 from analytics_data_api.v0 import models, serializers
 
@@ -53,8 +52,11 @@ class CourseActivityMostRecentWeekView(generics.RetrieveAPIView):
 
 
 class BaseCourseEnrollmentView(generics.ListAPIView):
-    def get_course_or_404(self):
-        return get_object_or_404(models.Course, course_id=self.kwargs.get('course_id'))
+    def verify_course_exists_or_404(self, course_id):
+        if self.model.objects.filter(course_id=course_id).exists():
+            return True
+
+        raise Http404
 
     def apply_date_filtering(self, queryset):
         if 'start_date' in self.request.QUERY_PARAMS or 'end_date' in self.request.QUERY_PARAMS:
@@ -77,8 +79,9 @@ class BaseCourseEnrollmentView(generics.ListAPIView):
         return queryset
 
     def get_queryset(self):
-        course = self.get_course_or_404()
-        queryset = self.model.objects.filter(course=course)
+        course_id = self.kwargs.get('course_id')
+        self.verify_course_exists_or_404(course_id)
+        queryset = self.model.objects.filter(course_id=course_id)
         queryset = self.apply_date_filtering(queryset)
         return queryset
 
@@ -185,9 +188,4 @@ class CourseEnrollmentByLocationView(BaseCourseEnrollmentView):
     """
 
     serializer_class = serializers.CourseEnrollmentByCountrySerializer
-
-    def get_queryset(self):
-        course = self.get_course_or_404()
-        queryset = models.CourseEnrollmentByCountry.objects.filter(course=course)
-        queryset = self.apply_date_filtering(queryset)
-        return queryset
+    model = models.CourseEnrollmentByCountry

requirements/base.txt

@@ -6,3 +6,4 @@ djangorestframework==2.3.5
 ipython==2.1.0
 django-rest-swagger==0.1.14
 djangorestframework-csv==1.3.3
+iso3166==0.1