示例#1
0
from gim.events.models import Event, EventPart

from .managers import ActivityManager


class _Repository(models.Model):
    class Meta:
        abstract = True

    @property
    def activity(self):
        from .limpyd_models import RepositoryActivity
        a, created = RepositoryActivity.get_or_connect(object_id=self.id)
        return a

contribute_to_model(_Repository, Repository)


class _Issue(models.Model):
    class Meta:
        abstract = True

    @property
    def activity(self):
        if not hasattr(self, '_activity_limpyd_object'):
            from .limpyd_models import IssueActivity
            self._activity_limpyd_object, created = IssueActivity.get_or_connect(object_id=self.id)
        return self._activity_limpyd_object

    def ask_for_activity_update(self):
        from gim.activity.tasks import ResetIssueActivity
示例#2
0
                                    self.user.username,
                                    self.get_state_display())


class _Repository(models.Model):
    class Meta:
        abstract = True

    def has_subscriptions(self, states=SUBSCRIPTION_STATES.READ_RIGHTS):
        """
        Return True if the repository has at least one subscription with the
        given rights (by detault all reading&more rights)
        """
        return self.subscriptions.filter(state__in=states).exists()

contribute_to_model(_Repository, Repository)


class _GithubUser(models.Model):
    class Meta:
        abstract = True

    AUTHORIZED_RIGHTS = {
        SUBSCRIPTION_STATES.ADMIN: ('admin', ),
        SUBSCRIPTION_STATES.USER: ('admin', 'push', ),
        SUBSCRIPTION_STATES.READ: ('admin', 'push', 'pull', ),
    }

    MAX_RIGHT = {
        'admin': SUBSCRIPTION_STATES.ADMIN,
        'push': SUBSCRIPTION_STATES.USER,
示例#3
0
            return None

        hook_id = self.check_hook(gh, force=True)
        if hook_id:
            identifiers = self.github_callable_identifiers_for_hooks + [hook_id]
            gh_callable = self.__class__.objects.get_github_callable(gh, identifiers)
            gh_callable.delete()

            self.hook_set = False
            self.save(update_fields=['hook_set'])

            return True

        return False

contribute_to_model(_Repository, core_models.Repository)


class EventManager(object):
    def __init__(self, repository_payload=None, repository=None):
        if repository is not None:
            self.repository = repository
        else:
            self.get_repository(repository_payload)

    def get_repository(self, repository_payload):
        try:
            self.repository = core_models.Repository.objects.get(github_id=repository_payload['id'])
        except Exception:
            self.repository = None
        return self.repository
示例#4
0
        if self.avatar_url:
            avatar_url = self.AVATAR_START.sub('', self.avatar_url, count=1)
        return hash((self.username, avatar_url, ))

    def get_related_issues(self):
        """
        Return a list of all issues related to this user (it may be the creator,
        the assignee, or the closer)
        """
        return core_models.Issue.objects.filter(
                                                   models.Q(user=self)
                                                 | models.Q(assignee=self)
                                                 | models.Q(closed_by=self)
                                               )

contribute_to_model(_GithubUser, core_models.GithubUser)


class _Repository(models.Model):
    class Meta:
        abstract = True

    def get_reverse_kwargs(self):
        """
        Return the kwargs to use for "reverse"
        """
        return {
            'owner_username': self.owner.username,
            'repository_name': self.name,
        }
示例#5
0
from django.db.models.signals import post_save
from django.dispatch import receiver

from gim.core.models import Repository, Issue
from gim.core.utils import contribute_to_model


class _Repository(models.Model):
    class Meta:
        abstract = True

    @property
    def graphs(self):
        if not hasattr(self, '_graphs_limpyd_object'):
            from .limpyd_models import GraphData
            self._graphs_limpyd_object, created = GraphData.get_or_connect(repository_id=self.id)
        return self._graphs_limpyd_object

contribute_to_model(_Repository, Repository)


@receiver(post_save, sender=Issue, dispatch_uid="update_graphs_data")
def update_graphs_data(sender, instance, created, **kwargs):
    if not isinstance(instance, Issue):
        return
    from gim.graphs.tasks import UpdateGraphsData
    UpdateGraphsData.add_job(instance.repository_id, delayed_for=timedelta(minutes=15))


from gim.graphs.tasks import *