Synnefo

class Service(models.Model):

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

    url = models.FilePathField()

    icon = models.FilePathField(blank=True)

    auth_token = models.CharField('Authentication Token', max_length=32,

                                  null=True, blank=True)

    auth_token_created = models.DateTimeField('Token creation date', null=True)

    auth_token_expires = models.DateTimeField('Token expiration date', null=True)

    def save(self, **kwargs):

        if not self.id:

            self.renew_token()

        self.full_clean()

        super(Service, self).save(**kwargs)

    def renew_token(self):

        md5 = hashlib.md5()

        md5.update(self.name.encode('ascii', 'ignore'))

        md5.update(self.url.encode('ascii', 'ignore'))

        md5.update(asctime())

        self.auth_token = b64encode(md5.digest())

        self.auth_token_created = datetime.now()

        self.auth_token_expires = self.auth_token_created + \

                                  timedelta(hours=AUTH_TOKEN_DURATION)

    def __str__(self):

        return self.name

class ResourceMetadata(models.Model):

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

    value = models.CharField('Value', max_length=255)

class Resource(models.Model):

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

    meta = models.ManyToManyField(ResourceMetadata)

    service = models.ForeignKey(Service)

    def __str__(self):

        return '%s : %s' % (self.service, self.name)

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)

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

    identifier = models.URLField('URI identifier', unique=True, default='', db_index=True)

    policy = models.ManyToManyField(Resource, null=True, blank=True, through='AstakosGroupQuota')

    creation_date = models.DateTimeField('Creation date', default=datetime.now())

    issue_date = models.DateTimeField('Issue date', null=True)

    expiration_date = models.DateTimeField('Expiration date', null=True)

    moderatation_enabled = models.BooleanField('Moderated membership?', default=False)

    approval_date = models.DateTimeField('Activation date', null=True, blank=True)

    estimated_participants = models.PositiveIntegerField('Estimated number of participants', null=True)

    @property

    def is_disabled(self):

        if not approval_date:

            return False

        return True

    @property

    def is_active(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

    @property

    def participants(self):

        if not self.id:

            return 0

        return self.user_set.count()

    def approve(self):

        self.approval_date = datetime.now()

        self.save()

    def disapprove(self):

        self.approval_date = None

        self.save()

    def approve_member(self, member):

        m = self.membership_set.get(person=member)

        m.date_joined = datetime.now()

        m.save()

    def disapprove_member(self, member):

        m = self.membership_set.remove(member)

    def get_members(self, approved=True):

        if approved:

            return self.membership_set().filter(is_approved=True)

        return self.membership_set().all()

    policy = models.ManyToManyField(Resource, null=True, through='AstakosUserQuota')

    astakos_groups = models.ManyToManyField(AstakosGroup, verbose_name=_('agroups'), blank=True,

        help_text=_("In addition to the permissions manually assigned, this user will also get all permissions granted to each group he/she is in."),

        through='Membership')

    owner = models.ManyToManyField(AstakosGroup, related_name='owner', null=True)

    def enroll_group(self, group):

        self.membership_set.add(group)

    def get_astakos_groups(self, approved=True):

        if approved:

            return self.membership_set().filter(is_approved=True)

        return self.membership_set().all()

class Membership(models.Model):

    person = models.ForeignKey(AstakosUser)

    group = models.ForeignKey(AstakosGroup)

    date_requested = models.DateField(default=datetime.now())

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

    class Meta:

        unique_together = ("person", "group")

    @property

    def is_approved(self):

        if self.date_joined:

            return True

        return False

class AstakosGroupQuota(models.Model):

    limit = models.PositiveIntegerField('Limit')

    resource = models.ForeignKey(Resource)

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

    class Meta:

        unique_together = ("resource", "group")

class AstakosUserQuota(models.Model):

    limit = models.PositiveIntegerField('Limit')

    resource = models.ForeignKey(Resource)

    user = models.ForeignKey(AstakosUser)

    class Meta:

        unique_together = ("resource", "user")

        try:

            db_instance = AstakosUser.objects.get(id = user.id)

        except AstakosUser.DoesNotExist:

            return True