Synnefo

class GroupKind(models.Model):

    name = models.CharField(_('Name'), max_length=255, unique=True, db_index=True)

    def __str__(self):

        return self.name

class AstakosGroup(Group):

    kind = models.ForeignKey(GroupKind)

    homepage = models.URLField(

        _('Homepage Url'), max_length=255, null=True, blank=True)

    desc = models.TextField(_('Description'), null=True)

    policy = models.ManyToManyField(

        Resource,

        null=True,

        blank=True,

        through='AstakosGroupQuota'

    )

    creation_date = models.DateTimeField(

        _('Creation date'),

        default=datetime.now()

    )

    issue_date = models.DateTimeField(

        _('Start date'),

        null=True

    )

    expiration_date = models.DateTimeField(

        _('Expiration date'),

        null=True

    )

    moderation_enabled = models.BooleanField(

        _('Moderated membership?'),

        default=True

    )

    approval_date = models.DateTimeField(

        _('Activation date'),

        null=True,

        blank=True

    )

    estimated_participants = models.PositiveIntegerField(

        _('Estimated #members'),

        null=True,

        blank=True,

    )

    max_participants = models.PositiveIntegerField(

        _('Maximum numder of participants'),

        null=True,

        blank=True

    )

    @property

    def is_disabled(self):

        if not self.approval_date:

            return True

        return False

    @property

    def is_enabled(self):

        if self.is_disabled:

            return False

        if not self.issue_date:

            return False

        if not self.expiration_date:

            return True

        now = datetime.now()

        if self.issue_date > now:

            return False

        if now >= self.expiration_date:

            return False

        return True

    def enable(self):

        if self.is_enabled:

            return

        self.approval_date = datetime.now()

        self.save()

        quota_disturbed.send(sender=self, users=self.approved_members)

        #propagate_groupmembers_quota.apply_async(

        #    args=[self], eta=self.issue_date)

        #propagate_groupmembers_quota.apply_async(

        #    args=[self], eta=self.expiration_date)

    def disable(self):

        if self.is_disabled:

            return

        self.approval_date = None

        self.save()

        quota_disturbed.send(sender=self, users=self.approved_members)

    def approve_member(self, person):

        m, created = self.membership_set.get_or_create(person=person)

        m.approve()

    @property

    def members(self):

        q = self.membership_set.select_related().all()

        return [m.person for m in q]

    @property

    def approved_members(self):

        q = self.membership_set.select_related().all()

        return [m.person for m in q if m.is_approved]

    @property

    def quota(self):

        d = defaultdict(int)

        for q in self.astakosgroupquota_set.select_related().all():

            d[q.resource] += q.uplimit or inf

        return d

    def add_policy(self, service, resource, uplimit, update=True):

        """Raises ObjectDoesNotExist, IntegrityError"""

        resource = Resource.objects.get(service__name=service, name=resource)

        if update:

            AstakosGroupQuota.objects.update_or_create(

                group=self,

                resource=resource,

                defaults={'uplimit': uplimit}

            )

        else:

            q = self.astakosgroupquota_set

            q.create(resource=resource, uplimit=uplimit)

    @property

    def policies(self):

        return self.astakosgroupquota_set.select_related().all()

    @policies.setter

    def policies(self, policies):

        for p in policies:

            service = p.get('service', None)

            resource = p.get('resource', None)

            uplimit = p.get('uplimit', 0)

            update = p.get('update', True)

            self.add_policy(service, resource, uplimit, update)

    @property

    def owners(self):

        return self.owner.all()

    @property

    def owner_details(self):

        return self.owner.select_related().all()

    @owners.setter

    def owners(self, l):

        self.owner = l

        map(self.approve_member, l)

    astakos_groups = models.ManyToManyField(

        AstakosGroup, verbose_name=_('agroups'), blank=True,

        help_text=_(astakos_messages.ASTAKOSUSER_GROUPS_HELP),

        through='Membership')

    owner = models.ManyToManyField(

        AstakosGroup, related_name='owner', null=True)

    @extended_groups.setter

    def extended_groups(self, groups):

        #TODO exceptions

        for name in (groups or ()):

            group = AstakosGroup.objects.get(name=name)

            self.membership_set.create(group=group)

class Membership(models.Model):

    person = models.ForeignKey(AstakosUser)

    group = models.ForeignKey(AstakosGroup)

    date_requested = models.DateField(default=datetime.now(), blank=True)

    date_joined = models.DateField(null=True, db_index=True, blank=True)

    class Meta:

        unique_together = ("person", "group")

    def save(self, *args, **kwargs):

        if not self.id:

            if not self.group.moderation_enabled:

                self.date_joined = datetime.now()

        super(Membership, self).save(*args, **kwargs)

    @property

    def is_approved(self):

        if self.date_joined:

            return True

        return False

    def approve(self):

        if self.is_approved:

            return

        if self.group.max_participants:

            assert len(self.group.approved_members) + 1 <= self.group.max_participants, \

            'Maximum participant number has been reached.'

        self.date_joined = datetime.now()

        self.save()

        quota_disturbed.send(sender=self, users=(self.person,))

    def disapprove(self):

        approved = self.is_approved()

        self.delete()

        if approved:

            quota_disturbed.send(sender=self, users=(self.person,))

class AstakosGroupQuota(models.Model):

    objects = ExtendedManager()

    limit = models.PositiveIntegerField(_('Limit'), null=True)    # obsolete field

    uplimit = models.BigIntegerField(_('Up limit'), null=True)

    resource = models.ForeignKey(Resource)

    group = models.ForeignKey(AstakosGroup, blank=True)

    class Meta:

        unique_together = ("resource", "group")

_auto_accept_join = False

def get_auto_accept_join():

    global _auto_accept_join

    if _auto_accept_join is not False:

        return _auto_accept_join

    try:

        auto_accept = MemberJoinPolicy.objects.get(policy='auto_accept')

    except:

        auto_accept = None

    _auto_accept_join = auto_accept

    return auto_accept

_closed_join = False

def get_closed_join():

    global _closed_join

    if _closed_join is not False:

        return _closed_join

    try:

        closed = MemberJoinPolicy.objects.get(policy='closed')

    except:

        closed = None

    _closed_join = closed

    return closed

_auto_accept_leave = False

def get_auto_accept_leave():

    global _auto_accept_leave

    if _auto_accept_leave is not False:

        return _auto_accept_leave

    try:

        auto_accept = MemberLeavePolicy.objects.get(policy='auto_accept')

    except:

        auto_accept = None

    _auto_accept_leave = auto_accept

    return auto_accept

_closed_leave = False

def get_closed_leave():

    global _closed_leave

    if _closed_leave is not False:

        return _closed_leave

    try:

        closed = MemberLeavePolicy.objects.get(policy='closed')

    except:

        closed = None

    _closed_leave = closed

    return closed

### PROJECTS ###

################

def filter_queryset_by_property(q, property):

    """

    Incorporate list comprehension for filtering querysets by property

    since Queryset.filter() operates on the database level.

    """

    return (p for p in q if getattr(p, property, False))

def get_alive_projects():

    return filter_queryset_by_property(

        Project.objects.all(),

        'is_alive'

    )

def get_active_projects():

    return filter_queryset_by_property(

        Project.objects.all(),

        'is_active'

    )

def _create_object(model, **kwargs):

    o = model.objects.create(**kwargs)

    o.save()

    return o

# def astakosuser_pre_save(sender, instance, **kwargs):

#     instance.aquarium_report = False

#     instance.new = False

#     try:

#         db_instance = AstakosUser.objects.get(id=instance.id)

#     except AstakosUser.DoesNotExist:

#         # create event

#         instance.aquarium_report = True

#         instance.new = True

#     else:

#         get = AstakosUser.__getattribute__

#         l = filter(lambda f: get(db_instance, f) != get(instance, f),

#                    BILLING_FIELDS)

#         instance.aquarium_report = True if l else False

# pre_save.connect(astakosuser_pre_save, sender=AstakosUser)

# def set_default_group(user):

#     try:

#         default = AstakosGroup.objects.get(name='default')

#         Membership(

#             group=default, person=user, date_joined=datetime.now()).save()

#     except AstakosGroup.DoesNotExist, e:

#         logger.exception(e)

#     if instance.aquarium_report:

#         report_user_event(instance, create=instance.new)

#     set_default_group(instance)

# def on_quota_disturbed(sender, users, **kwargs):

# #     print '>>>', locals()

#     if not users:

#         return

#     send_quota(users)

#

# quota_disturbed = Signal(providing_args=["users"])

# quota_disturbed.connect(on_quota_disturbed)

# def send_quota_disturbed(sender, instance, **kwargs):

#     users = []

#     extend = users.extend

#     if sender == Membership:

#         if not instance.group.is_enabled:

#             return

#         extend([instance.person])

#     elif sender == AstakosUserQuota:

#         extend([instance.user])

#     elif sender == AstakosGroupQuota:

#         if not instance.group.is_enabled:

#             return

#         extend(instance.group.astakosuser_set.all())

#     elif sender == AstakosGroup:

#         if not instance.is_enabled:

#             return

#     quota_disturbed.send(sender=sender, users=users)

# post_delete.connect(send_quota_disturbed, sender=AstakosGroup)

# post_delete.connect(send_quota_disturbed, sender=Membership)

# post_save.connect(send_quota_disturbed, sender=AstakosUserQuota)

# post_delete.connect(send_quota_disturbed, sender=AstakosUserQuota)

# post_save.connect(send_quota_disturbed, sender=AstakosGroupQuota)

# post_delete.connect(send_quota_disturbed, sender=AstakosGroupQuota)