/snf-astakos-app/astakos/im/models.py - Diff - Synnefo - Greek Research and Technology Network's projects

Revision 362dadaa snf-astakos-app/astakos/im/models.py

         def is_accepted(self):
             return self.moderated and not self.is_rejected
         def is_project_admin(self, application_id=None):
         def is_project_admin(self):
             return self.uuid in astakos_settings.PROJECT_ADMINS
         @property
-...
             return application.owner == self
         def owns_project(self, project):
             return project.application.owner == self
             return project.owner == self
         def is_associated(self, project):
             try:
-...
                                             self.display_member_capacity())
     def _distinct(f, l):
         d = {}
         last = None
         for x in l:
             group = f(x)
             if group == last:
                 continue
             last = group
             d[group] = x
         return d
     def invert_dict(d):
         return dict((v, k) for k, v in d.iteritems())
     class ProjectManager(models.Manager):
         def all_with_pending(self, flt=None):
             flt = Q() if flt is None else flt
             projects = list(self.select_related(
                 'application', 'application__owner').filter(flt))
             objs = ProjectApplication.objects.select_related('owner')
             apps = objs.filter(state=ProjectApplication.PENDING,
                                chain__in=projects).order_by('chain', '-id')
             app_d = _distinct(lambda app: app.chain_id, apps)
             return [(project, app_d.get(project.pk)) for project in projects]
         def expired_projects(self):
             model = self.model
             q = ((model.o_state_q(model.O_ACTIVE) |
                   model.o_state_q(model.O_SUSPENDED)) &
                  Q(application__end_date__lt=datetime.now()))
             q = (Q(state__in=[model.NORMAL, model.SUSPENDED]) &
                  Q(end_date__lt=datetime.now()))
             return self.filter(q)
         def user_accessible_projects(self, user):
-...
             else:
                 membs = user.projectmembership_set.associated()
                 memb_projects = membs.values_list("project", flat=True)
                 flt = (Q(application__owner=user) |
                        Q(application__applicant=user) |
                 flt = (Q(owner=user) |
                        Q(last_application__applicant=user) |
                        Q(id__in=memb_projects))
             relevant = model.o_states_q(model.RELEVANT_STATES)
             relevant = ~Q(state=model.DELETED)
             return self.filter(flt, relevant).order_by(
                 'application__issue_date').select_related(
                 'application', 'application__owner', 'application__applicant')
                 'creation_date').select_related('last_application', 'owner')
         def search_by_name(self, *search_strings):
             q = Q()
-...
                 q = q | Q(name__icontains=s)
             return self.filter(q)
         def initialized(self, flt=None):
             q = Q(state__in=self.model.INITIALIZED_STATES)
             if flt is not None:
                 q &= flt
             return self.filter(q)
     class Project(models.Model):
-...
         NORMAL = 1
         SUSPENDED = 10
         TERMINATED = 100
         DELETED = 1000
         INITIALIZED_STATES = [NORMAL,
                               SUSPENDED,
                               TERMINATED,
+                              ]
         ALIVE_STATES = [NORMAL,
                         SUSPENDED,
+                        ]
         SKIP_STATES = [DELETED,
                        TERMINATED,
+                       ]
         DEACTIVATED_STATES = [SUSPENDED, TERMINATED]
         state = models.IntegerField(default=NORMAL,
         state = models.IntegerField(default=UNINITIALIZED,
                                     db_index=True)
         uuid = models.CharField(max_length=255, unique=True)
-...
         def __str__(self):
             return uenc(_("<project %s '%s'>") %
                         (self.id, udec(self.application.name)))
                         (self.id, udec(self.realname)))
         __repr__ = __str__
         def __unicode__(self):
             return _("<project %s '%s'>") % (self.id, self.application.name)
             return _("<project %s '%s'>") % (self.id, self.realname)
         O_UNINITIALIZED = -1
         O_PENDING = 0
         O_ACTIVE = 1
         O_ACTIVE_PENDING = 2
         O_DENIED = 3
         O_DISMISSED = 4
         O_CANCELLED = 5
         O_SUSPENDED = 10
         O_TERMINATED = 100
         O_DELETED = 1000
         O_STATE_DISPLAY = {
             O_UNINITIALIZED: _("Uninitialized"),
             O_PENDING:    _("Pending"),
             O_ACTIVE:     _("Active"),
             O_DENIED:     _("Denied"),
-...
             O_CANCELLED:  _("Cancelled"),
             O_SUSPENDED:  _("Suspended"),
             O_TERMINATED: _("Terminated"),
             O_DELETED:    _("Deleted"),
+        }
         OVERALL_STATE = {
             (NORMAL, ProjectApplication.PENDING):      O_PENDING,
             (NORMAL, ProjectApplication.APPROVED):     O_ACTIVE,
             (NORMAL, ProjectApplication.DENIED):       O_DENIED,
             (NORMAL, ProjectApplication.DISMISSED):    O_DISMISSED,
             (NORMAL, ProjectApplication.CANCELLED):    O_CANCELLED,
             (SUSPENDED, ProjectApplication.APPROVED):  O_SUSPENDED,
             (TERMINATED, ProjectApplication.APPROVED): O_TERMINATED,
+        }
         OVERALL_STATE_INV = invert_dict(OVERALL_STATE)
         @classmethod
         def o_state_q(cls, o_state):
             p_state, a_state = cls.OVERALL_STATE_INV[o_state]
             return Q(state=p_state, application__state=a_state)
         @classmethod
         def o_states_q(cls, o_states):
             return reduce(lambda x, y: x | y, map(cls.o_state_q, o_states), Q())
         INITIALIZED_STATES = [O_ACTIVE,
                               O_SUSPENDED,
                               O_TERMINATED,
+                              ]
         RELEVANT_STATES = [O_PENDING,
                            O_DENIED,
                            O_ACTIVE,
                            O_SUSPENDED,
                            O_TERMINATED,
+                           ]
         O_STATE_UNINITIALIZED = {
             None: O_UNINITIALIZED,
             ProjectApplication.PENDING: O_PENDING,
             ProjectApplication.DENIED:  O_DENIED,
+            }
         O_STATE_DELETED = {
             None: O_DELETED,
             ProjectApplication.DISMISSED: O_DISMISSED,
             ProjectApplication.CANCELLED: O_CANCELLED,
+            }
         SKIP_STATES = [O_DISMISSED,
                        O_CANCELLED,
                        O_TERMINATED,
+                       ]
         OVERALL_STATE = {
             NORMAL: lambda app_state: Project.O_ACTIVE,
             UNINITIALIZED: lambda app_state: Project.O_STATE_UNINITIALIZED.get(
                 app_state, None),
             DELETED: lambda app_state: Project.O_STATE_DELETED.get(
                 app_state, None),
             SUSPENDED: lambda app_state: Project.O_SUSPENDED,
             TERMINATED: lambda app_state: Project.O_TERMINATED,
+            }
         @classmethod
         def _overall_state(cls, project_state, app_state):
             return cls.OVERALL_STATE.get((project_state, app_state), None)
             os = cls.OVERALL_STATE.get(project_state, None)
             if os is None:
                 return None
             return os(app_state)
         def overall_state(self):
             return self._overall_state(self.state, self.application.state)
             app_state = (self.last_application.state
                          if self.last_application else None)
             return self._overall_state(self.state, app_state)
         def last_pending_application(self):
             apps = self.chained_apps.filter(
                 state=ProjectApplication.PENDING).order_by('-id')
             if apps:
                 return apps[0]
             app = self.last_application
             if app and app.state == ProjectApplication.PENDING:
                 return app
             return None
         def last_pending_modification(self):
             last_pending = self.last_pending_application()
             if last_pending == self.application:
                 return None
             return last_pending
             if self.state != Project.UNINITIALIZED:
                 return last_pending
             return None
         def state_display(self):
             return self.O_STATE_DISPLAY.get(self.overall_state(), _('Unknown'))
         def expiration_info(self):
             return (str(self.id), self.name, self.state_display(),
                     str(self.application.end_date))
                     str(self.end_date))
         def last_deactivation(self):
             objs = self.log.filter(to_state__in=self.DEACTIVATED_STATES)
-...
             return self.state != self.NORMAL
         def is_active(self):
             return self.overall_state() == self.O_ACTIVE
             return self.state == self.NORMAL
         def is_initialized(self):
             return self.overall_state() in self.INITIALIZED_STATES
             return self.state in self.INITIALIZED_STATES
         ### Deactivation calls
-...
         def resume(self, actor=None, reason=None):
             self.set_state(self.NORMAL, actor=actor, reason=reason)
             if self.name is None:
                 self.name = self.application.name
                 self.name = self.realname
                 self.save()
         def activate(self, actor=None, reason=None):
             assert self.state != self.DELETED, \
                 "cannot activate: %s is deleted" % self
             if self.state != self.NORMAL:
                 self.set_state(self.NORMAL, actor=actor, reason=reason)
             if self.name != self.realname:
                 self.name = self.realname
                 self.save()
         def set_deleted(self, actor=None, reason=None):
             self.set_state(self.DELETED, actor=actor, reason=reason)
         ### Logical checks
         @property
         def is_alive(self):
             return self.overall_state() in [self.O_ACTIVE, self.O_SUSPENDED]
             return self.state in [self.NORMAL, self.SUSPENDED]
         @property
         def is_terminated(self):
-...
             return self.is_deactivated(self.SUSPENDED)
         def violates_members_limit(self, adding=0):
             application = self.application
             limit = application.limit_on_members_number
             if limit is None:
                 return False
             limit = self.limit_on_members_number
             return (len(self.approved_members) + adding > limit)
         ### Other
-...
         def approved_members(self):
             return [m.person for m in self.approved_memberships]
         @property
         def member_join_policy_display(self):
             policy = self.member_join_policy
             return presentation.PROJECT_MEMBER_JOIN_POLICIES.get(policy)
         @property
         def member_leave_policy_display(self):
             policy = self.member_leave_policy
             return presentation.PROJECT_MEMBER_LEAVE_POLICIES.get(policy)
     def create_project(**kwargs):
         if "uuid" not in kwargs:

Also available in: Unified diff