Synnefo

    credit = models.IntegerField('Credit Balance')

    max_invitations = models.IntegerField('Max number of invitations',

            null=True)

    def get_limit(self, limit_name):

        """Returns the limit value for the specified limit"""

        limit_objs = Limit.objects.filter(name=limit_name, user=self)

        if len(limit_objs) == 1:

            return limit_objs[0].value

        return 0

    @property

    def credit_quota(self):

        """Internal getter function for credit quota"""

        return self.get_limit('QUOTA_CREDIT')

    @property

    def monthly_rate(self):

        """Internal getter function for monthly credit issue rate"""

        return self.get_limit('MONTHLY_RATE')

    @property

    def min_credits(self):

        """Internal getter function for maximum number of violations"""

        return self.get_limit('MIN_CREDITS')

class Limit(models.Model):

    LIMITS = (

        ('QUOTA_CREDIT', 'Maximum amount of credits per user'),

        ('MIN_CREDITS', 'Minimum amount of credits per user'),

        ('MONTHLY_RATE', 'Monthly credit issue rate')

    )

    user = models.ForeignKey(SynnefoUser)

    name = models.CharField('Limit key name', choices=LIMITS, max_length=30,

            null=False)

    value = models.IntegerField('Limit current value')

    class Meta:

        verbose_name = u'Enforced limit for user'

    def __unicode__(self):

        return u'Limit %s for user %s: %d' % (self.value, self.user,

                self.value)

    def _current_cost(self, active):

        """Returns active/inactive cost value

        set active = True to get active cost and False for the inactive.

        """

        costs = FlavorCost.objects.filter(flavor=self)

        fch_list = costs.order_by('-effective_from')

        if len(fch_list) > 0:

            if active:

                return fch_list[0].cost_active

            else:

                return fch_list[0].cost_inactive

        return 0

    @property

    def current_cost_active(self):

        """Returns current active cost (property method)"""

        return self._current_cost(True)

    @property

    def current_cost_inactive(self):

        """Returns current inactive cost (property method)"""

        return self._current_cost(False)

class FlavorCost(models.Model):

    cost_active = models.PositiveIntegerField('Active Cost')

    cost_inactive = models.PositiveIntegerField('Inactive Cost')

    effective_from = models.DateTimeField()

    flavor = models.ForeignKey(Flavor)

    class Meta:

        verbose_name = u'Pricing history for flavors'

    def __unicode__(self):

        return u'Costs (up, down)=(%d, %d) for %s since %s' % (

                int(self.cost_active), int(self.cost_inactive),

                self.flavor.name, self.effective_from)

class VirtualMachineGroup(models.Model):

    """Groups of VMs for SynnefoUsers"""

    name = models.CharField(max_length=255)

    created = models.DateTimeField('Time of creation', auto_now_add=True)

    updated = models.DateTimeField('Time of last update', auto_now=True)

    owner = models.ForeignKey(SynnefoUser)

    machines = models.ManyToManyField(VirtualMachine)

    class Meta:

        verbose_name = u'Virtual Machine Group'

        verbose_name_plural = 'Virtual Machine Groups'

        ordering = ['name']

    def __unicode__(self):

        return self.name

class Debit(models.Model):

    when = models.DateTimeField()

    user = models.ForeignKey(SynnefoUser)

    vm = models.ForeignKey(VirtualMachine)

    description = models.TextField()

    class Meta:

        verbose_name = u'Accounting log'

    def __unicode__(self):

        return u'%s - %s - %s - %s' % (self.user.id, self.vm.name,

                self.when, self.description)

class Invitations(models.Model):

    source = models.ForeignKey(SynnefoUser, related_name="source")

    target = models.ForeignKey(SynnefoUser, related_name="target")

    accepted = models.BooleanField('Is the invitation accepted?',

            default=False)

    created = models.DateTimeField(auto_now_add=True)

    updated = models.DateTimeField(auto_now=True)

    level = models.IntegerField('Invitation depth level', null=True)

    def __unicode__(self):

        return "From: %s, To: %s" % (self.source, self.target)