Merge lp:~salgado/offspring/private-projects into lp:~linaro-automation/offspring/linaro

[Guilherme Salgado]

This branch adds support for private projects on models of web.queuemanager. It adds two new attributes (is_private and owner) to Project, and also makes Project inherit from AccessGroupMixin, so that we can allow people other than the owner to see certain private projects.

The access control is enforced by the new model managers, when looking up projects or their related objects. In order to make it harder to accidentally leak private objects, the model manager (accessible via .objects) of Project and all its related models will only return public stuff, and there's a new manager (accessible via .all_objects) which provides an API to query only the objects a given user is allowed to see (.accessible_by_user(user)). This way we don't risk leaking any private data if we forget to update views that don't take privacy into account.

NOTE: In order to try this branch you'll need to download http://pypi.python.org/packages/source/d/django-group-access/django-group-access-0.0.1.tar.gz into your .download-cache (that's only until we get it added to https://code.launchpad.net/~oem-solutions-releng/offspring/offspring-deps/)

[James Tunnicliffe (dooferlad)]

Looks good.

[Guilherme Salgado (salgado)]

Thanks for the review, James.

I've just noticed, though, that we must ensure the .all_objects manager is the one set as ._default_manager (used only internally by Django) or else the admin UI would hide all private objects and we would break model validation of unique fields if the user reuses a value from an object they are not allowed to see. The revision I've just pushed addresses that and it'd be great if you could review it as well.

[James Tunnicliffe (dooferlad)]

Yep, http://bazaar.launchpad.net/~salgado/offspring/private-projects/revision/68
looks fine.

On 29 September 2011 19:15, Guilherme Salgado
<email address hidden> wrote:
> Thanks for the review, James.
>
> I've just noticed, though, that we must ensure the .all_objects manager is the one set as ._default_manager (used only internally by Django) or else the admin UI would hide all private objects and we would break model validation of unique fields if the user reuses a value from an object they are not allowed to see.  The revision I've just pushed addresses that and it'd be great if you could review it as well.
> --
> https://code.launchpad.net/~salgado/offspring/private-projects/+merge/76752
> Your team Linaro Infrastructure is requested to review the proposed merge of lp:~salgado/offspring/private-projects into lp:~linaro-infrastructure/offspring/linaro.
>

--
James Tunnicliffe

=== modified file 'Makefile'
--- Makefile	2011-09-23 14:01:26 +0000
+++ Makefile	2011-09-29 18:17:25 +0000
@@ -46,7 +46,10 @@
 	./.virtualenv/bin/nosetests offspring.master
 
 test-web: web install-test-runner
-	./bin/offspring-web test --settings=offspring.web.settings_test
+	./bin/offspring-web test queuemanager --settings=offspring.web.settings_test
+
+test-web-postgres: web install-test-runner
+	./bin/offspring-web test queuemanager --settings=offspring.web.settings_devel
 
 test: master slave web install-test-runner test-web
 	./.virtualenv/bin/nosetests -e 'queuemanager.*'
 
=== modified file 'lib/offspring/web/queuemanager/models.py'
--- lib/offspring/web/queuemanager/models.py	2011-09-28 14:23:09 +0000
+++ lib/offspring/web/queuemanager/models.py	2011-09-29 18:17:25 +0000
@@ -12,14 +12,17 @@
 )
 import math
 
-from django.conf import settings
-from django.contrib.auth.models import User
+from django.contrib.auth.models import AnonymousUser, User
 from django.db import (
     connection,
     models
 )
 
 from offspring import config
+from django_group_access.models import (
+    AccessGroup,
+    AccessGroupMixin,
+    AccessManager)
 from offspring.enums import ProjectBuildStates
 
 
@@ -74,9 +77,9 @@
     def get_absolute_url(self):
         return "/project-groups/%s/" % self.name
 
-    @property
-    def projects(self):
-        return Project.objects.filter(project_group=self)
+    def get_projects(self, user):
+        return Project.all_objects.accessible_by_user(user).filter(
+            project_group=self)
 
     @property
     def builder(self): 
@@ -84,11 +87,10 @@
 
     @property
     def is_active(self):
-        return bool(Project.objects.filter(project_group=self).exclude(is_active=False).count() != 0)
-
-    @property
-    def needs_build(self):
-        return BuildRequest.objects.filter(project__project_group=self).exists()
+        # Can safely use .all_objects here because we're not returning any
+        # objects so there's no risk of leaking private stuff.
+        projects = Project.all_objects.filter(project_group=self)
+        return projects.exclude(is_active=False).count() > 0
 
     @property
     def average_build_time(self):
@@ -112,7 +114,81 @@
         return "UNKNOWN"
 
 
-class Project(models.Model):
+class PublicOnlyObjectsManager(models.Manager):
+    """A model manager which only returns public objects."""
+
+    def get_query_set(self):
+        return super(PublicOnlyObjectsManager, self).get_query_set().filter(
+            models.Q(**{self.model._get_privacy_attr(): False}))
+
+
+class AccessControlledObjectsManager(AccessManager):
+    """A model manager which provides an extra API for querying objects a
+    given user is allowed to see.
+
+    We extend AccessManager because we want the access-control filters to be
+    applied only for private objects, but also because we allow AnonymousUsers
+    to be passed to accessible_by_user().
+    """
+
+    def _get_accessible_by_user_filter_rules(self, user):
+        rules = super(AccessControlledObjectsManager,
+                      self)._get_accessible_by_user_filter_rules(user)
+        return rules | models.Q(**{self.model._get_privacy_attr(): False})
+
+    def accessible_by_user(self, user):
+        if isinstance(user, AnonymousUser):
+            # If we're passed in an AnonymousUser we must not attempt to apply
+            # the usual constraints because they rely on the given user
+            # existing in the DB and that's not the case with AnonymousUsers.
+            query = models.Q(**{self.model._get_privacy_attr(): False})
+            return super(
+                AccessControlledObjectsManager, self).get_query_set().filter(
+                    query)
+        else:
+            return super(
+                AccessControlledObjectsManager, self).accessible_by_user(user)
+
+
+class MaybePrivateMixin(object):
+    """A model which may be private or linked to a private one.
+
+    If the model itself is private, it's expected to have an '_is_private'
+    boolean attribute. Otherwise it must have an 'access_relation' attribute
+    pointing to the linked model which has the '_is_private' attribute.
+    """
+    _privacy_attr_name = '_is_private'
+    _is_visible_method_name = '_is_visible_to'
+
+    @classmethod
+    def _get_privacy_attr(self):
+        privacy_attr = self._privacy_attr_name
+        if getattr(self, 'access_relation', None) is not None:
+            privacy_attr = self.access_relation + '__' + privacy_attr
+        return privacy_attr
+
+    def _get_access_controlled_object(self):
+        if getattr(self, 'access_relation', None) is None:
+            return self
+        names = self.access_relation.split('__')
+        obj = self
+        while len(names):
+            name = names.pop(0)
+            obj = getattr(obj, name)
+        return obj
+
+    @property
+    def is_private(self):
+        obj = self._get_access_controlled_object()
+        return getattr(obj, self._privacy_attr_name)
+
+    def is_visible_to(self, user):
+        is_visible_to = getattr(self._get_access_controlled_object(),
+                                self._is_visible_method_name)
+        return is_visible_to(user)
+
+
+class Project(AccessGroupMixin, MaybePrivateMixin):
     #XXX: This should probably be managed in the database.
     STATUS_CHOICES = (
         (u'devel', u'Active Development'),
@@ -122,7 +198,15 @@
         (u'experimental', u'Experimental'),
         (u'obsolete', u'Obsolete'),
     )
+    all_objects = AccessControlledObjectsManager()
+    # Using PublicOnlyObjectsManager here we ensure that any oversights when
+    # updating existing uses of Project.objects won't leak private projects.
+    objects = PublicOnlyObjectsManager()
 
+    _is_private = models.BooleanField(default=False, db_column='is_private')
+    # We allow projects without an owner for backwards compatibility but
+    # there's a DB constraint to ensure private projects always have an owner.
+    owner = models.ForeignKey(User, blank=True, null=True)
     name = models.SlugField('codename', max_length=200, primary_key=True, unique=True)
     title = models.CharField('project title', max_length=30)
     project_group = models.ForeignKey(ProjectGroup, blank=True, null=True)
@@ -145,6 +229,16 @@
     def __unicode__(self):
         return self.display_name()
 
+    def _is_visible_to(self, user):
+        if not self._is_private or user == self.owner:
+            return True
+        if isinstance(user, AnonymousUser):
+            # Private objects are never visible to anonymous users.
+            return False
+        access_groups = set(self.access_groups.all())
+        user_groups = AccessGroup.objects.filter(members=user)
+        return len(access_groups.intersection(user_groups)) > 0
+
     def get_absolute_url(self):
         return "/projects/%s/" % self.name
 
@@ -192,7 +286,7 @@
             return u""
 
 
-class Lexbuilder(models.Model):
+class Lexbuilder(models.Model, MaybePrivateMixin):
     name = models.SlugField(max_length=200, unique=True)
     uri = models.CharField(max_length=200)
     current_state = models.CharField(max_length=200, default="UNKNOWN", editable=False)
@@ -205,6 +299,13 @@
     current_job = models.ForeignKey("BuildResult", db_column="current_job_id", editable=False, blank=True, null=True)
     notes = models.TextField('whiteboard', blank=True, null=True)
 
+    access_relation = 'current_job__project'
+    all_objects = AccessControlledObjectsManager()
+    # Using PublicOnlyObjectsManager here we ensure that any oversights when
+    # updating existing uses of Lexbuilder.objects won't leak anything related
+    # to private projects.
+    objects = PublicOnlyObjectsManager()
+
     class Meta:
         db_table = "lexbuilders"
 
@@ -266,7 +367,7 @@
         return cursor.fetchone()[0]
 
 
-class BuildResult(models.Model):
+class BuildResult(models.Model, MaybePrivateMixin):
     name = models.CharField('build name', max_length=200, blank=True, null=True, editable=False)
     project = models.ForeignKey(Project, db_column="project_name", editable=False)
     builder = models.ForeignKey(Lexbuilder, blank=True, null=True, editable=False)
@@ -279,6 +380,13 @@
     dispatched_at = models.DateTimeField('date dispatched', editable=False, null=True, blank=True) 
     notes = models.CharField(max_length=200, null=True, blank=True)
 
+    access_relation = 'project'
+    all_objects = AccessControlledObjectsManager()
+    # Using PublicOnlyObjectsManager here we ensure that any oversights when
+    # updating existing uses of BuildResult.objects won't leak anything
+    # related to private projects.
+    objects = PublicOnlyObjectsManager()
+
     class Meta:
         db_table = "buildresults"
         get_latest_by = "started_at"
@@ -326,13 +434,20 @@
     recentBuildFailures = staticmethod(recentBuildFailures)
 
 
-class BuildRequest(models.Model):
+class BuildRequest(models.Model, MaybePrivateMixin):
     project = models.ForeignKey(Project, db_column="project_name")
     requestor = models.ForeignKey(User, db_column="requestor_id", blank=True, null=True)
     created_at = models.DateTimeField('date created', auto_now_add=True)
     score = models.IntegerField(default=10)
     reason = models.TextField('request reason', blank=True, max_length=200)
 
+    access_relation = 'project'
+    all_objects = AccessControlledObjectsManager()
+    # Using PublicOnlyObjectsManager here we ensure that any oversights when
+    # updating existing uses of BuildRequest.objects won't leak anything
+    # related to private projects.
+    objects = PublicOnlyObjectsManager()
+
     class Meta:
         db_table = "buildrequests"
 
@@ -451,7 +566,7 @@
         return "%s subscribed to %s" % (self.user, self.project)
 
 
-class Release(models.Model):
+class Release(models.Model, MaybePrivateMixin):
     STATUS_PENDING, STATUS_PUBLISHED, STATUS_REMOVED, STATUS_MISSING, STATUS_ERROR = range(5)
     STATUS_CHOICES = (
         (STATUS_PENDING, 'Pending Publication'),
@@ -469,6 +584,13 @@
         ("GM", "Gold Master"),
     )
 
+    access_relation = 'build__project'
+    all_objects = AccessControlledObjectsManager()
+    # Using PublicOnlyObjectsManager here we ensure that any oversights when
+    # updating existing uses of Release.objects won't leak anything related to
+    # private projects.
+    objects = PublicOnlyObjectsManager()
+
     build = models.OneToOneField(BuildResult, primary_key=True, unique=True)
     name = models.CharField('release name', max_length=200)
     milestone = models.ForeignKey(LaunchpadProjectMilestone, null=True, blank=True)
 
=== added directory 'lib/offspring/web/queuemanager/sql'
=== added file 'lib/offspring/web/queuemanager/sql/project.postgresql_psycopg2.sql'
--- lib/offspring/web/queuemanager/sql/project.postgresql_psycopg2.sql	1970-01-01 00:00:00 +0000
+++ lib/offspring/web/queuemanager/sql/project.postgresql_psycopg2.sql	2011-09-29 18:17:25 +0000
@@ -0,0 +1,5 @@
+-- XXX: This doesn't apply when running tests because sqlite3 doesn't support
+-- addition of new constraints to existing tables.  Need to decide whether
+-- it's preferred to just ignore this in our tests or use postgresql to run
+-- the tests as well.
+ALTER TABLE projects ADD CONSTRAINT "private_project_requires_owner" CHECK (is_private IS FALSE OR owner_id IS NOT NULL);
 
=== modified file 'lib/offspring/web/queuemanager/tests/__init__.py'
--- lib/offspring/web/queuemanager/tests/__init__.py	2011-09-23 13:31:21 +0000
+++ lib/offspring/web/queuemanager/tests/__init__.py	2011-09-29 18:17:25 +0000
@@ -0,0 +1,1 @@
+from .test_models import *
 
=== modified file 'lib/offspring/web/queuemanager/tests/factory.py'
--- lib/offspring/web/queuemanager/tests/factory.py	2011-09-27 19:58:38 +0000
+++ lib/offspring/web/queuemanager/tests/factory.py	2011-09-29 18:17:25 +0000
@@ -1,6 +1,7 @@
 from itertools import count
 
 from django.contrib.auth.models import User
+from django_group_access.models import AccessGroup
 
 from offspring.web.queuemanager.models import (
     BuildRequest,
@@ -41,12 +42,20 @@
         user.save()
         return user
 
-    def makeProject(self, name=None, title=None):
+    def makeProject(self, name=None, title=None, is_private=False,
+                    project_group=None, owner=None, access_groups=[]):
         if name is None:
             name = self.getUniqueString()
         if title is None:
             title = self.getUniqueString()
-        project = Project(name=name, title=title)
+        if owner is None:
+            owner = self.makeUser()
+        project = Project(
+            name=name, title=title, _is_private=is_private, owner=owner,
+            project_group=project_group)
+        project.save()
+        for group in access_groups:
+            project.access_groups.add(group)
         project.save()
         return project
 
@@ -97,5 +106,14 @@
         request.save()
         return request
 
+    def makeAccessGroup(self, users):
+        name = self.getUniqueString()
+        group = AccessGroup(name=name)
+        group.save()
+        for user in users:
+            group.members.add(user)
+        group.save()
+        return group
+
 
 factory = ObjectFactory()
 
=== added file 'lib/offspring/web/queuemanager/tests/test_models.py'
--- lib/offspring/web/queuemanager/tests/test_models.py	1970-01-01 00:00:00 +0000
+++ lib/offspring/web/queuemanager/tests/test_models.py	2011-09-29 18:17:25 +0000
@@ -0,0 +1,228 @@
+from operator import attrgetter
+
+from django.contrib.auth.models import AnonymousUser
+from django.test import TestCase
+
+from offspring.web.queuemanager.models import (
+    BuildRequest,
+    BuildResult,
+    Lexbuilder,
+    Project,
+    Release)
+from offspring.web.queuemanager.tests.factory import factory
+
+
+class ProjectTests(TestCase):
+
+    def test_default_manager(self):
+        # Make sure .all_objects is the default manager or else the admin UI
+        # will exclude all private objects and we would break model validation
+        # of unique fields if the user reuses a value from an object they're
+        # not allowed to see.
+        self.assertEquals(Project.all_objects, Project._default_manager)
+
+    def test_is_private_for_public_project(self):
+        project = factory.makeProject(is_private=False)
+        self.assertEqual(False, project.is_private)
+
+    def test_is_private_for_private_project(self):
+        private_project = factory.makeProject(is_private=True)
+        self.assertEqual(True, private_project.is_private)
+
+    def test_is_visible_to_anyone_if_public(self):
+        project = factory.makeProject(is_private=False)
+        self.assertTrue(project.is_visible_to(AnonymousUser()))
+
+    def test_is_not_visible_to_anyone_if_private(self):
+        project = factory.makeProject(is_private=True)
+        self.assertFalse(project.is_visible_to(AnonymousUser()))
+
+    def test_is_visible_to_owner_if_private(self):
+        project = factory.makeProject(is_private=True)
+        self.assertTrue(project.is_visible_to(project.owner))
+
+    def test_is_visible_to_member_of_access_group_if_private(self):
+        user = factory.makeUser()
+        group = factory.makeAccessGroup([user])
+        project = factory.makeProject(is_private=True, access_groups=[group])
+        self.assertTrue(project.is_visible_to(user))
+
+    def test_default_model_manager_only_returns_public_projects(self):
+        project = factory.makeProject(is_private=False)
+        project2 = factory.makeProject(is_private=True)
+        self.assertEqual([project], list(Project.objects.all()))
+
+    def test_all_objects_model_manager(self):
+        # Project.all_objects() is a separate model manager which returns
+        # private objects as well. Its .all() method will return public and
+        # private objects regardless of whether or not the current user has
+        # access to them. It is to be used with caution.
+        project = factory.makeProject(is_private=False)
+        project2 = factory.makeProject(is_private=True)
+        self.assertEqual([project, project2], list(Project.all_objects.all()))
+
+    def test_accessible_by_user_with_anonymous_user(self):
+        project = factory.makeProject(is_private=True)
+        project2 = factory.makeProject(is_private=False)
+        self.assertEqual(True, project.is_private)
+        self.assertEqual(False, project2.is_private)
+        objects = Project.all_objects.accessible_by_user(AnonymousUser())
+        self.assertEqual([project2], list(objects))
+
+    def test_accessible_by_user_with_public_project(self):
+        user = factory.makeUser()
+        project = factory.makeProject(is_private=False)
+        self.assertEqual(False, project.is_private)
+        objects = Project.all_objects.accessible_by_user(user)
+        self.assertEqual([project], list(objects))
+
+    def test_accessible_by_user_with_private_project(self):
+        user = factory.makeUser()
+        group = factory.makeAccessGroup([user])
+        project = factory.makeProject(is_private=True, access_groups=[group])
+        # This second project is private but has no access groups set up, so
+        # the user cannot see it.
+        project2 = factory.makeProject(is_private=True)
+        self.assertEqual(True, project.is_private)
+        self.assertEqual(True, project2.is_private)
+        objects = Project.all_objects.accessible_by_user(user)
+        self.assertEqual([project], list(objects))
+
+
+class ReleaseOrLexbuilderOrBuildResultOrBuildRequestTestsMixin(object):
+    """A mixin with tests that work for the following models:
+
+        Release
+        Lexbuilder
+        BuildResult
+        BuildRequest
+
+    You just need to mix this with TestCase in your subclass and define
+    factoryMethod and model.
+    """
+    model = None
+
+    def factoryMethod(self, project):
+        raise NotImplementedError()
+
+    def test_default_manager(self):
+        # Make sure .all_objects is the default manager or else the admin UI
+        # will exclude all private objects and we would break model validation
+        # of unique fields if the user reuses a value from an object they're
+        # not allowed to see.
+        self.assertEquals(self.model.all_objects, self.model._default_manager)
+
+    def test_is_private_for_public_object(self):
+        public_object = self.factoryMethod(
+            factory.makeProject(is_private=False))
+        self.assertFalse(public_object.is_private)
+
+    def test_is_private_for_private_object(self):
+        private_object = self.factoryMethod(
+            factory.makeProject(is_private=True))
+        self.assertTrue(private_object.is_private)
+
+    def test_is_visible_to_anyone_if_public(self):
+        public_object = self.factoryMethod(
+            factory.makeProject(is_private=False))
+        self.assertTrue(public_object.is_visible_to(AnonymousUser()))
+
+    def test_is_not_visible_to_anyone_if_private(self):
+        private_object = self.factoryMethod(
+            factory.makeProject(is_private=True))
+        self.assertFalse(private_object.is_visible_to(AnonymousUser()))
+
+    def test_is_visible_to_owner_if_private(self):
+        # The object we're dealing with inherits the access-control rules from
+        # the project it's related to, so the owner that matters is the
+        # project owner.
+        owner = factory.makeUser()
+        private_object = self.factoryMethod(
+            factory.makeProject(is_private=True, owner=owner))
+        self.assertTrue(private_object.is_visible_to(owner))
+
+    def test_is_visible_to_member_of_access_group_if_private(self):
+        user = factory.makeUser()
+        group = factory.makeAccessGroup([user])
+        private_object = self.factoryMethod(
+            factory.makeProject(is_private=True, access_groups=[group]))
+        self.assertTrue(private_object.is_visible_to(user))
+
+    def test_default_model_manager_only_returns_public_objects(self):
+        private_object = self.factoryMethod(
+            factory.makeProject(is_private=True))
+        public_object = self.factoryMethod(
+            factory.makeProject(is_private=False))
+        self.assertEqual([public_object], list(self.model.objects.all()))
+
+    def test_all_objects_model_manager(self):
+        # self.model.all_objects() is a separate model manager which returns
+        # private objects as well. Its .all() method will return public and
+        # private objects regardless of whether or not the current user has
+        # access to them. It is to be used with caution.
+        public_object = self.factoryMethod(
+            project=factory.makeProject(is_private=False))
+        private_object = self.factoryMethod(
+            project=factory.makeProject(is_private=True))
+        self.assertEqual([public_object, private_object],
+                         list(self.model.all_objects.all()))
+
+    def test_accessible_by_user(self):
+        user = factory.makeUser()
+        group = factory.makeAccessGroup([user])
+        visible_object = self.factoryMethod(
+            factory.makeProject(is_private=True, access_groups=[group]))
+        # This object is linked to a private project which has no access
+        # groups set up, so the user cannot see it.
+        invisible_object = self.factoryMethod(
+            project=factory.makeProject(is_private=True))
+        self.assertEqual(
+            [visible_object],
+            list(self.model.all_objects.accessible_by_user(user)))
+
+
+class ReleaseTests(
+    TestCase, ReleaseOrLexbuilderOrBuildResultOrBuildRequestTestsMixin):
+    model = Release
+
+    def factoryMethod(self, project):
+        return factory.makeRelease(
+            build=factory.makeBuildResult(project=project))
+
+
+class LexbuilderTests(
+        TestCase, ReleaseOrLexbuilderOrBuildResultOrBuildRequestTestsMixin):
+    model = Lexbuilder
+
+    def factoryMethod(self, project):
+        return factory.makeLexbuilder(
+            current_job=factory.makeBuildResult(project=project))
+
+
+class BuildResultTests(
+        TestCase, ReleaseOrLexbuilderOrBuildResultOrBuildRequestTestsMixin):
+    model = BuildResult
+    factoryMethod = factory.makeBuildResult
+
+
+class BuildRequestTests(
+        TestCase, ReleaseOrLexbuilderOrBuildResultOrBuildRequestTestsMixin):
+    model = BuildRequest
+    factoryMethod = factory.makeBuildRequest
+
+
+class ProjectGroupTests(TestCase):
+
+    def test_get_projects_filters_private_objects(self):
+        user = factory.makeUser()
+        group = factory.makeProjectGroup()
+        public_project = factory.makeProject(
+            is_private=False, project_group=group)
+        private_project_visible_to_user = factory.makeProject(
+            is_private=True, project_group=group, owner=user)
+        private_project = factory.makeProject(
+            is_private=True, project_group=group)
+        self.assertEqual(
+            sorted([public_project, private_project_visible_to_user],
+                   key=attrgetter('name')),
+            sorted(group.get_projects(user), key=attrgetter('name')))
 
=== modified file 'lib/offspring/web/queuemanager/views.py'
--- lib/offspring/web/queuemanager/views.py	2011-08-13 06:28:28 +0000
+++ lib/offspring/web/queuemanager/views.py	2011-09-29 18:17:25 +0000
@@ -241,6 +241,7 @@
 
     pageData = { 
         'projectGroup' : pg, 
+        'projects': pg.get_projects(request.user),
         'pillar' : 'projects', 
         'build_stats' : build_stats,
         'projectgroup_build_results' : projectgroup_build_results,
 
=== modified file 'lib/offspring/web/settings.py'
--- lib/offspring/web/settings.py	2011-09-23 14:01:26 +0000
+++ lib/offspring/web/settings.py	2011-09-29 18:17:25 +0000
@@ -96,6 +96,7 @@
     'djcelery',
     'djkombu',
     'piston',
+    'django_group_access',
     # Offspring Apps
     'offspring.web.queuemanager',
 )
 
=== modified file 'lib/offspring/web/templates/queuemanager/projectgroup_details.html'
--- lib/offspring/web/templates/queuemanager/projectgroup_details.html	2010-11-29 08:27:24 +0000
+++ lib/offspring/web/templates/queuemanager/projectgroup_details.html	2011-09-29 18:17:25 +0000
@@ -32,7 +32,7 @@
             <h3>Project</h3></td><td></td><td><h3>Last Build</h3></td><td width="30%"><h3>Date</h3></td><td width="15%"><h3>Result</h3>
         </td>
     </tr>
-    {% for project in projectGroup.projects %}
+    {% for project in projects %}
     <tr>
         <td>
             {% if project.needs_build %}<img src="/assets/images/33.png" title="Pending Build">{% else %}{% ifequal project.latest_build.result "FAILED" %}<img src="/assets/images/34.png" title="Build Failure">{% else %} {% ifequal project.latest_build.result "COMPLETED" %} <img src="/assets/images/35.png" title="Build Successful"> {% else %} <img src="/assets/images/36.png" title="Not yet built">{% endifequal %}{% endifequal %}{% endif %}</td><td> <a href="{% url offspring.web.queuemanager.views.project_details project.name %}">{{ project.title }}</a>
 
=== added directory 'migration'
=== added file 'migration/001-project-privacy.sql'
--- migration/001-project-privacy.sql	1970-01-01 00:00:00 +0000
+++ migration/001-project-privacy.sql	2011-09-29 18:17:25 +0000
@@ -0,0 +1,3 @@
+ALTER TABLE projects ADD COLUMN "is_private" boolean NOT NULL default FALSE;
+ALTER TABLE projects ADD COLUMN "owner_id" integer REFERENCES "auth_user" ("id") DEFERRABLE INITIALLY DEFERRED;
+ALTER TABLE projects ADD CONSTRAINT "private_project_requires_owner" CHECK (is_private IS FALSE OR owner_id IS NOT NULL);
 
=== modified file 'requirements/requirements.web.txt'
--- requirements/requirements.web.txt	2011-08-11 00:16:09 +0000
+++ requirements/requirements.web.txt	2011-09-29 18:17:25 +0000
@@ -11,3 +11,4 @@
 celery>=2.3.1
 django-celery>=2.3.0
 django-kombu>=0.9.4
+django-group-access>=0.0.1