summaryrefslogtreecommitdiffstats
path: root/devel/utils.py
blob: d7a154a8a468274fa5204fd6c107d6b463ef0298 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
import re

from django.contrib.auth.models import User
from django.db import connection
from django.db.models import Count, Q

from main.utils import cache_function
from main.models import Package
from packages.models import PackageRelation

@cache_function(300)
def get_annotated_maintainers():
    maintainers = User.objects.filter(is_active=True).order_by(
            'first_name', 'last_name')

    # annotate the maintainers with # of maintained and flagged packages
    pkg_count_sql = """
SELECT pr.user_id, COUNT(*), COUNT(p.flag_date)
    FROM packages_packagerelation pr
    JOIN packages p
    ON pr.pkgbase = p.pkgbase
    WHERE pr.type = %s
    GROUP BY pr.user_id
"""
    cursor = connection.cursor()
    cursor.execute(pkg_count_sql, [PackageRelation.MAINTAINER])
    results = cursor.fetchall()

    pkg_count = {}
    flag_count = {}
    for k, total, flagged in results:
        pkg_count[k] = total
        flag_count[k] = flagged

    update_count = Package.objects.values_list('packager').order_by(
            'packager').annotate(Count('packager'))
    update_count = dict(update_count)

    for m in maintainers:
        m.package_count = pkg_count.get(m.id, 0)
        m.flagged_count = flag_count.get(m.id, 0)
        m.updated_count = update_count.get(m.id, 0)

    return maintainers


class UserFinder(object):
    def __init__(self):
        self.cache = {}

    @staticmethod
    def user_email(name, email):
        if email:
            return User.objects.get(email=email)
        return None

    @staticmethod
    def profile_email(name, email):
        if email:
            return User.objects.get(userprofile__public_email=email)
        return None

    @staticmethod
    def user_name(name, email):
        # yes, a bit odd but this is the easiest way since we can't always be
        # sure how to split the name. Ensure every 'token' appears in at least
        # one of the two name fields.
        if not name:
            return None
        name_q = Q()
        for token in name.split():
            # ignore quoted parts; e.g. nicknames in strings
            if re.match(r'^[\'"].*[\'"]$', token):
                continue
            name_q &= (Q(first_name__icontains=token) |
                    Q(last_name__icontains=token))
        return User.objects.get(name_q)

    def find(self, userstring):
        '''
        Attempt to find the corresponding User object for a standard
        packager string, e.g. something like
            'A. U. Thor <author@example.com>'.
        We start by searching for a matching email address; we then move onto
        matching by first/last name. If we cannot find a user, then return None.
        '''
        if not userstring:
            return None
        if userstring in self.cache:
            return self.cache[userstring]

        name = email = None

        matches = re.match(r'^([^<]+)? ?<([^>]*)>?', userstring)
        if not matches:
            name = userstring.strip()
        else:
            name = matches.group(1)
            email = matches.group(2)

        user = None
        find_methods = (self.user_email, self.profile_email, self.user_name)
        for matcher in find_methods:
            try:
                user = matcher(name, email)
                if user != None:
                    break
            except (User.DoesNotExist, User.MultipleObjectsReturned):
                pass

        self.cache[userstring] = user
        return user

    def clear_cache(self):
        self.cache = {}

# vim: set ts=4 sw=4 et: