/ - Diff - Synnefo - Greek Research and Technology Network's projects

         def clean_start_date(self):
             start_date = self.cleaned_data.get('start_date')
             if not self.precursor_application:
                 if start_date and (start_date - datetime.now()).days < 0:
                 if start_date and (start_date - datetime.now()).days < -1:
                     raise forms.ValidationError(
                     _(astakos_messages.INVALID_PROJECT_START_DATE))
             return start_date

         def owns_project(self, project):
             return project.owner == self
         def is_project_member(self, project):
             return project.user_status(self) in [0,1,2,3]
         def is_project_member(self, project_or_application):
             return self.get_status_in_project(project_or_application) in \
                                             ProjectMembership.ASSOCIATED_STATES
         def is_project_accepted_member(self, project):
             return project.user_status(self) == 2
         def is_project_accepted_member(self, project_or_application):
             return self.get_status_in_project(project_or_application) in \
                                                 ProjectMembership.ACCEPTED_STATES
         def get_status_in_project(self, project_or_application):
             application = project_or_application
             if isinstance(project_or_application, Project):
                 application = project_or_application.project
             return application.user_status(self)
     class AstakosUserAuthProviderManager(models.Manager):
-...
     class ProjectApplicationManager(ForUpdateManager):
         def user_projects(self, user):
         def user_visible_projects(self, *filters, **kw_filters):
             return self.filter(Q(state=ProjectApplication.PENDING)|\
                                Q(state=ProjectApplication.APPROVED))
         def user_visible_by_last_of_chain(self, *filters, **kw_filters):
             by_chain = self.user_visible_projects(*filters, **kw_filters).values('chain')
             by_chain = by_chain.annotate(last_id=models.Min('id')).values_list('last_id', flat=True)
             return self.filter(id__in=by_chain)
         def user_accessible_projects(self, user):
             """
             Return projects accessed by specified user.
             """
             participates_fitlers = Q(owner=user) | Q(applicant=user) | \
             participates_filters = Q(owner=user) | Q(applicant=user) | \
                                    Q(project__projectmembership__person=user)
             state_filters = (Q(state=ProjectApplication.PENDING) & \
                             Q(precursor_application__isnull=True)) | \
                             Q(state=ProjectApplication.APPROVED)
             return self.filter(participates_fitlers & state_filters).order_by('issue_date').distinct()
             return self.user_visible_by_last_of_chain(participates_filters).order_by('issue_date').distinct()
         def search_by_name(self, *search_strings):
             q = Q()
-...
             q.create(resource=resource, member_capacity=uplimit)
         def user_status(self, user):
             """
 OWNER
 REQUESTED
 PENDING
 ACCEPTED
 REMOVING
 REMOVED
            -1   User has no association with the project
             """
             try:
                 membership = self.project.projectmembership_set.get(person=user)
                 project = self.get_project()
                 if not project:
                     return -1
                 membership = project.projectmembership_set.get(person=user)
                 membership = membership.exclude(state=ProjectMembership.REMOVED)
                 status = membership.state
             except Project.DoesNotExist:
                 status = -1
             except ProjectMembership.DoesNotExist:
                 status = -1
-...
                 return
         def followers(self):
             current = self
             try:
                 while current.projectapplication:
                     yield current.follower
                     current = current.follower
             except:
                 pass
             followers = ProjectApplication.objects.filter(chain=self.chain)
             return followers.exclude(pk=self.pk).order_by('id')
         def last_follower(self):
             try:
                 return list(self.followers())[-1]
                 return self.followers().filter(
                               state__in=[self.PENDING, self.APPROVED]).order_by('-id')[0]
             except IndexError:
                 import traceback; print traceback.print_exc()
                 return None
         def has_pending_modifications(self):
             return bool(self.last_follower())
         def get_project(self):
             try:
                 return Project.objects.get(id=self.chain)
             except Project.DoesNotExist:
                 return None
         def _get_project_for_update(self):
-...
         TERMINATED  =   100
         REMOVED     =   200
         ASSOCIATED_STATES   =   set([REQUESTED, ACCEPTED, SUSPENDED, TERMINATED])
         ACCEPTED_STATES     =   set([ACCEPTED, SUSPENDED, TERMINATED])
         state               =   models.IntegerField(default=REQUESTED,
                                                     db_index=True)
         is_pending          =   models.BooleanField(default=False, db_index=True)

     from astakos.im.models import *
     from astakos.im.templatetags.filters import truncatename
     from astakos.im.functions import do_join_project_checks
     from astakos.im.functions import do_join_project_checks, \
                                      do_leave_project_checks
     DEFAULT_DATE_FORMAT = "d/m/Y"
-...
         url, action, confirm, prompt = '', '', True, ''
         append_url = ''
         can_join = True
         try:
             project = Project.objects.get(application=application)
             do_join_project_checks(project)
         except (PermissionDenied, Project.DoesNotExist), e:
             can_join = False
         if can_join:
             if user.is_project_accepted_member(application):
                 url = 'astakos.im.views.project_leave'
                 action = _('Leave')
                 confirm = True
                 prompt = _('Are you sure you want to leave from the project ?')
             elif not user.is_project_member(application):
                 url = 'astakos.im.views.project_join'
                 action = _('Join')
                 confirm = True
                 prompt = _('Are you sure you want to join this project ?')
             else:
                 action = ''
                 confirm = False
                 url = None
         can_join = can_leave = False
         member_status = application.user_status(user)
         project = application.get_project()
         if project:
             try:
                 do_join_project_checks(project)
                 can_join = True
             except PermissionDenied:
                 pass
             try:
                 do_leave_project_checks(project)
                 can_leave = True
             except PermissionDenied:
                 pass
         if can_leave and user.is_project_accepted_member(application):
             url = 'astakos.im.views.project_leave'
             action = _('Leave')
             confirm = True
             prompt = _('Are you sure you want to leave from the project ?')
         elif can_join and user.is_project_member(application):
             url = 'astakos.im.views.project_join'
             action = _('Join')
             confirm = True
             prompt = _('Are you sure you want to join this project ?')
         else:
             action = ''
             confirm = False
             url = None
         url = reverse(url, args=(application.pk, )) + append_url if url else ''
         return {'action': action,
-...
             super(UserTable, self).__init__(*args, **kwargs)
     def project_name_append(record, column):
         try:
             if record.projectapplication and column.table.user.owns_project(record):
                 if record.state == ProjectApplication.APPROVED:
                     return mark_safe("<br /><i class='tiny'>%s</i>" % _('modifications pending'))
                 else:
                     return u''
             else:
                 return u''
         except:
             return u''
     def project_name_append(application, column):
         if application.has_pending_modifications():
             return mark_safe("<br /><i class='tiny'>%s</i>" % \
                                                     _('modifications pending'))
         return u''
     # Table classes
     class UserProjectApplicationsTable(UserTable):

     @signed_terms_required
     @login_required
     def project_list(request):
         projects = ProjectApplication.objects.user_projects(request.user).select_related()
         projects = ProjectApplication.objects.user_accessible_projects(request.user).select_related()
         table = tables.UserProjectApplicationsTable(projects, user=request.user,
                                                     prefix="my_projects_")
         RequestConfig(request, paginate={"per_page": PAGINATE_BY}).configure(table)

Synnefo

Revision 05617ab9