Source Code for Module expedient.clearinghouse.project.models

  1  ''' 
  2  @author: jnaous 
  3  ''' 
  4  from django.db import models 
  5  from expedient.common.permissions.models import Permittee, ObjectPermission 
  6  from expedient.common.permissions.utils import permissions_save_override,\ 
  7      permissions_delete_override 
  8  from expedient.clearinghouse.aggregate.models import Aggregate 
  9  from django.contrib.contenttypes.models import ContentType 
 10  from django.contrib.auth.models import User 
 11  from expedient.clearinghouse.aggregate.utils import get_aggregate_classes 
 12   
 13 -class ProjectManager(models.Manager): 
 14      """Manager for L{Project} instances. 
 15       
 16      Add methods to retrieve project querysets. 
 17      """ 
 18       
 19 -    def get_for_user(self, user): 
 20          """Return projects for which C{user} has some permission. 
 21           
 22          @param user: The user whose projects we are looking for. 
 23          @type user: C{User}. 
 24          """ 
 25          if user.is_superuser: 
 26              return self.all() 
 27           
 28          permittee = Permittee.objects.get_as_permittee(user) 
 29           
 30          proj_ids = ObjectPermission.objects.filter_for_class( 
 31              klass=Project, permittees=permittee).values_list( 
 32                  "object_id", flat=True) 
 33          return self.filter(id__in=list(proj_ids)) 
 34   
 35 -class Project(models.Model): 
 36      ''' 
 37      A project is a collection of users working on the same set of slices. 
 38       
 39      @cvar objects: A L{ProjectManager} instance. 
 40       
 41      @ivar name: The name of the project 
 42      @type name: L{str} 
 43      @ivar description: Short description of the project 
 44      @type description: L{str} 
 45      @ivar aggregates: Read-only property returning all aggregates that can 
 46          be used by the project (i.e. for which the project has the 
 47          "can_use_aggregate" permission). 
 48      @type aggregates: C{QuerySet} of L{Aggregate}s 
 49      @ivar researchers: Read-only property returning all users that have the 
 50          'researcher' role for the project. 
 51      @type researchers: C{QuerySet} of C{User}s. 
 52      @ivar owners: Read-only property returning all users that have the 'owner' 
 53          role for the project. 
 54      @type owners: C{QuerySet} of C{User}s. 
 55      @ivar members: Read-only property returning all users that have some 
 56          permission in the project. 
 57      @type members: C{QuerySet} of C{User}s. 
 58      @ivar members_as_permittees: Read-only property returning all users 
 59          that have some permission in the project as Permittee instances. 
 60      @type members_as_permittees: C{QuerySet} of L{Permittee}s. 
 61      ''' 
 62      objects = ProjectManager() 
 63       
 64      name = models.CharField(max_length=200, unique=True) 
 65      description = models.TextField() 
 66       
 67      save = permissions_save_override( 
 68          permittee_kw="user", 
 69          model_func=lambda: Project, 
 70          create_perm="can_create_project", 
 71          edit_perm="can_edit_project", 
 72          delete_perm="can_delete_project", 
 73      ) 
 74      delete = permissions_delete_override( 
 75          permittee_kw="user", 
 76          model_func=lambda: Project, 
 77          delete_perm="can_delete_project", 
 78      ) 
 79       
 80 -    def _get_aggregates(self): 
 81          """Get all aggregates that can be used by the project 
 82          (i.e. for which the project has the "can_use_aggregate" permission). 
 83          """ 
 84          # Permissions are given to the leaf classes 
 85          agg_ids = [] 
 86          agg_classes = get_aggregate_classes() 
 87          permittee = Permittee.objects.get_as_permittee(self) 
 88          for agg_class in agg_classes: 
 89              agg_ids.extend( 
 90                  ObjectPermission.objects.filter_for_class( 
 91                      agg_class, 
 92                      permission__name="can_use_aggregate", 
 93                      permittees=permittee, 
 94                  ).values_list("object_id", flat=True) 
 95              ) 
 96          return Aggregate.objects.filter(pk__in=agg_ids) 
 97      aggregates=property(_get_aggregates) 
 98       
 99 -    def _get_researchers(self): 
100          """Get all users who have the 'researcher' role for the project""" 
101          from expedient.clearinghouse.roles.models import ProjectRole 
102          return ProjectRole.objects.get_users_with_role('researcher', self) 
103      researchers=property(_get_researchers) 
104       
105 -    def _get_owners(self): 
106          """Get all users who have the 'owner' role for the project""" 
107          from expedient.clearinghouse.roles.models import ProjectRole 
108          return ProjectRole.objects.get_users_with_role('owner', self) 
109      owners=property(_get_owners) 
110       
111 -    def _get_members(self): 
112          """Get all users who have some permission in the project.""" 
113          user_ids = self._get_permittees().values_list("object_id", flat=True) 
114          return User.objects.filter(pk__in=list(user_ids)) 
115      members=property(_get_members) 
116       
117 -    def _get_permittees(self): 
118          """Get all permittees that have some permission in the project.""" 
119          return Permittee.objects.filter_for_class(User).filter( 
120              objectpermission__object_type= 
121                  ContentType.objects.get_for_model(Project), 
122              objectpermission__object_id=self.id, 
123          ).distinct() 
124      members_as_permittees=property(_get_permittees) 
125       
126 -    def __unicode__(self): 
127          s = u"Project %s" % self.name 
128          return s 
129   
130      @classmethod 
131      @models.permalink 
132 -    def get_create_url(cls): 
133          "Returns the URL to create projects" 
134          return ("project_create",) 
135       
136      @models.permalink 
137 -    def get_update_url(self): 
138          "Returns the URL to update project info" 
139          return ("project_update", (), {"proj_id": self.id}) 
140   
141      @models.permalink 
142 -    def get_detail_url(self): 
143          "Returns the URL for the project detail page" 
144          return ("project_detail", (), {"proj_id": self.id}) 
145       
146      @models.permalink 
147 -    def get_delete_url(self): 
148          "Returns the URL to delete a project" 
149          return ("project_delete", (), {"proj_id": self.id}) 
150       
151      @models.permalink 
152 -    def get_agg_add_url(self): 
153          "Returns the URL to add an aggregate to a project" 
154          return ("project_add_agg", (), {"proj_id": self.id}) 
155   
156      @models.permalink 
157 -    def get_agg_update_url(self, aggregate): 
158          "Returns URL to update an aggregate's info related to the project" 
159          return ("project_update_agg", (), { 
160              "proj_id": self.id, 
161              "agg_id": aggregate.id}) 
162       
163      @models.permalink 
164 -    def get_agg_remove_url(self, aggregate): 
165          "Returns URL to remove aggregate from project" 
166          return ("project_remove_agg", (), { 
167              "proj_id": self.id, 
168              "agg_id": aggregate.id}) 
169       
170      @models.permalink 
171 -    def get_member_add_url(self): 
172          return ("project_member_add", (), { 
173              "proj_id": self.id}) 
174       
175      @models.permalink 
176 -    def get_member_update_url(self, user): 
177          return ("project_member_update", (), { 
178              "proj_id": self.id, 
179              "user_id": user.id}) 
180   
181      @models.permalink 
182 -    def get_member_remove_url(self, user): 
183          return ("project_member_remove", (), { 
184              "proj_id": self.id, 
185              "user_id": user.id}) 
186