Synnefo

from django.db.models import Q

from astakos.im.settings import (DEFAULT_USER_LEVEL, INVITATIONS_PER_LEVEL,

from astakos.im.endpoints.quotaholder import register_users, send_quota

from astakos.im.endpoints.aquarium.producer import report_user_event

logger = logging.getLogger(__name__)

class Service(models.Model):

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

    url = models.FilePathField()

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

                                  null=True, blank=True)

    auth_token_created = models.DateTimeField('Token creation 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'))

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

        self.auth_token_created = datetime.now()

        self.auth_token_expires = self.auth_token_created + \

    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)

    policy = models.ManyToManyField(Resource, null=True, blank=True,

    creation_date = models.DateTimeField('Creation date',

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

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

    moderation_enabled = models.BooleanField('Moderated membership?',

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

    estimated_participants = models.PositiveIntegerField('Estimated #members',

    @property

    def is_disabled(self):

        if not self.approval_date:

            return True

        return False

    @property

    def is_enabled(self):

        if self.is_disabled:

        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)

    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)

        # update date_joined in any case

        m.save()

    def disapprove_member(self, person):

        self.membership_set.remove(person=person)

    @property

    def members(self):

        return [m.person for m in self.membership_set.all()]

    @property

    def approved_members(self):

        return [m.person for m in self.membership_set.all() if m.is_approved]

    @property

    def quota(self):

        d = defaultdict(int)

        for q in self.astakosgroupquota_set.all():

            d[q.resource] += q.limit

        return d

    @property

    def owners(self):

        return self.owner.all()

    @owners.setter

    def owners(self, l):

        self.owner = l

        map(self.approve_member, l)

class AstakosUser(User):

    """

    Extends ``django.contrib.auth.models.User`` by defining additional fields.

    #for invitations

    user_level = DEFAULT_USER_LEVEL

    level = models.IntegerField('Inviter level', default=user_level)

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

                                  null=True, blank=True)

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

    updated = models.DateTimeField('Update date')

    is_verified = models.BooleanField('Is verified?', default=False)

    # ex. screen_name for twitter, eppn for shibboleth

    email_verified = models.BooleanField('Email verified?', default=False)

    has_credits = models.BooleanField('Has credits?', default=False)

        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')

    __has_signed_terms = False

    class Meta:

        unique_together = ("provider", "third_party_identifier")

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

        super(AstakosUser, self).__init__(*args, **kwargs)

        self.__has_signed_terms = self.has_signed_terms

        if not self.id:

            self.is_active = False

    @property

    def realname(self):

    @realname.setter

    def realname(self, value):

            return Invitation.objects.get(username=self.email)

        except Invitation.DoesNotExist:

            return None

    @property

    def quota(self):

        d = defaultdict(int)

            d[q.resource.name] += q.limit

        for m in self.membership_set.all():

            if not m.is_approved:

                d[r] += limit

        # TODO set default for remaining

        return d

    def save(self, update_timestamps=True, **kwargs):

        if update_timestamps:

            if not self.id:

                self.date_joined = datetime.now()

            self.updated = datetime.now()

        # update date_signed_terms if necessary

        if self.__has_signed_terms != self.has_signed_terms:

            self.date_signed_terms = datetime.now()

        if not self.id:

            # set username

            while not self.username:

                try:

                except AstakosUser.DoesNotExist:

                    self.username = username

            if not self.provider:

        if self.is_active and self.activation_sent:

            # reset the activation sent

            self.activation_sent = None

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

    def renew_token(self):

        md5 = hashlib.md5()

        md5.update(self.username)

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

        self.auth_token_created = datetime.now()

        self.auth_token_expires = self.auth_token_created + \

        msg = 'Token renewed for %s' % self.email

        logger.log(LOGGING_LEVEL, msg)

    def __unicode__(self):

        return '%s (%s)' % (self.realname, self.email)

    def conflicting_email(self):

        if q.count() != 0:

            return True

        return False

    def validate_unique_email_isactive(self):

        """

        Implements a unique_together constraint for email and is_active fields.

        """

        if q.count() != 0:

    @property

    def signed_terms(self):

        term = get_latest_terms()

            return False

        return True

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):

        self.date_joined = datetime.now()

        self.save()

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

    def disapprove(self):

        self.delete()

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

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")

class ApprovalTerms(models.Model):

    """

    Model for approval terms

    """

    location = models.CharField('Terms location', max_length=255)

class Invitation(models.Model):

    """

    Model for registring invitations

    is_consumed = models.BooleanField('Consumed?', default=False)

    created = models.DateTimeField('Creation date', auto_now_add=True)

    consumed = models.DateTimeField('Consumption date', null=True, blank=True)

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

        super(Invitation, self).__init__(*args, **kwargs)

        if not self.id:

            self.code = _generate_invitation_code()

    def consume(self):

        self.is_consumed = True

        self.consumed = datetime.now()

    def __unicode__(self):

        return '%s -> %s [%d]' % (self.inviter, self.username, self.code)

class EmailChangeManager(models.Manager):

    @transaction.commit_on_success

    def change_email(self, activation_key):

        Throws ValueError if there is already

        """

        try:

            if email_change.activation_key_expired():

                email_change.delete()

                raise EmailChange.DoesNotExist

        except EmailChange.DoesNotExist:

            raise ValueError(_('Invalid activation key'))

class EmailChange(models.Model):

    new_email_address = models.EmailField(_(u'new e-mail address'), help_text=_(u'Your old email address will be used until you verify your new one.'))

    requested_at = models.DateTimeField(default=datetime.now())

    objects = EmailChangeManager()

        expiration_date = timedelta(days=EMAILCHANGE_ACTIVATION_DAYS)

        return self.requested_at + expiration_date < datetime.now()

class AdditionalMail(models.Model):

    """

    Model for registring invitations

    owner = models.ForeignKey(AstakosUser)

    email = models.EmailField()

def _generate_invitation_code():

    while True:

        try:

            Invitation.objects.get(code=code)

            # An invitation with this code already exists, try again

        except Invitation.DoesNotExist:

            return code

def get_latest_terms():

    try:

        term = ApprovalTerms.objects.order_by('-id')[0]

        pass

    return None

def create_astakos_user(u):

    try:

        AstakosUser.objects.get(user_ptr=u.pk)

        logger.exception(e)

        pass

def fix_superusers(sender, **kwargs):

    # Associate superusers with AstakosUser

    admins = User.objects.filter(is_superuser=True)

    for u in admins:

        create_astakos_user(u)

def user_post_save(sender, instance, created, **kwargs):

    if not created:

        return

    create_astakos_user(instance)

def set_default_group(user):

    try:

    except AstakosGroup.DoesNotExist, e:

        logger.exception(e)

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

    instance.aquarium_report = False

    instance.new = False

    try:

    except AstakosUser.DoesNotExist:

        # create event

        instance.aquarium_report = True

    else:

        get = AstakosUser.__getattribute__

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

        instance.aquarium_report = True if l else False

def astakosuser_post_save(sender, instance, created, **kwargs):

    if instance.aquarium_report:

        report_user_event(instance, create=instance.new)

    # TODO handle socket.error & IOError

    register_users((instance,))

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

    users = []

    extend = users.extend

            return

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

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

    print '>>>', locals()

    if not users:

post_save.connect(send_quota_disturbed, sender=AstakosUserQuota)

post_delete.connect(send_quota_disturbed, sender=AstakosUserQuota)

post_save.connect(send_quota_disturbed, sender=AstakosGroupQuota)