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
|
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').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]
matches = re.match(r'^([^<]+)? ?<([^>]*)>', userstring)
if not matches:
name = userstring
email = None
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:
|
