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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
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 = {}
self.username_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 find_by_username(self, username):
if not username:
return None
if username in self.username_cache:
return self.username_cache[username]
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
user = None
self.username_cache[username] = user
return user
def clear_cache(self):
self.cache = {}
self.username_cache = {}
# vim: set ts=4 sw=4 et:
|
