Initial Contributionv1.0

1 files changed, 302 insertions, 0 deletions

diff --git a/webapp/codereview/people.py b/webapp/codereview/people.py
new file mode 100644
index 0000000000..0621796a73
--- /dev/null
+++ b/webapp/codereview/people.py
@@ -0,0 +1,302 @@
+# Copyright 2008 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Info about the users
+
+This requires Django 0.97.pre.
+"""
+
+import datetime
+import logging
+
+from django import forms
+from django import http
+from django.utils import simplejson
+
+import models
+import views
+import fields
+from view_util import *
+
+def respond_json(obj):
+  data = simplejson.dumps(obj)
+  return http.HttpResponse(data,
+      mimetype="text/javascript; charset=utf-8")
+
+def get_user_info(request):
+  """check if the requested user exists
+  
+  Parameters:
+    id: the user's email address or the group name
+    allow_users: whether users are allowed, true by default
+    allow_groups: whether groups are allowed, true by default
+
+  Result:
+  If user/group not found:
+    null
+  If user found: map of
+    type: "user"
+    key: a unique key for this user
+    email: their email address
+    real_name: the user's real name
+  If group found: map of
+    type: "group"
+    key: a unique key for this group
+    name: the name of the group
+
+  If users or groups are not allowed, then null will be returned
+  even if there does happen to be a user or group with that name
+  """
+  id = request.REQUEST.get("id", None)
+  if not id:
+    return http.HttpResponseServerError("id not provided")
+  allow_users = request.REQUEST.get("allow_users", "true")
+  allow_groups = request.REQUEST.get("allow_groups", "true")
+  if allow_users != "false":
+    account = models.Account.get_account_for_email(id)
+    if account:
+      return respond_json({
+          'allow_users': allow_users,
+          'allow_groups': allow_groups,
+          'type': 'user',
+          'key': "user/" + account.email,
+          'email': account.email,
+          'real_name': account.real_name,
+          })
+  if allow_groups != "false":
+    group = models.AccountGroup.get_group_for_name(id)
+    if group:
+      return respond_json({
+          'allow_users': allow_users,
+          'allow_groups': allow_groups,
+          'type': 'group',
+          'key': "group/" + str(group.key()),
+          'name': group.name,
+          })
+  return respond_json(None)
+
+@admin_required
+def admin_people_info(request):
+  """/admin/people_info"""
+  op = request.REQUEST.get("op", None)
+  if op == "get_user_info":
+    return get_user_info(request);
+  return http.HttpResponseServerError("op=" + str(op))
+
+@admin_required
+def admin_users(request):
+  """/admin/users - list of all users"""
+  accounts = models.Account.get_all_accounts()
+  return respond(request, 'admin_users.html', {'users': accounts})
+
+@admin_required
+def admin_users_verify_cla(request):
+  """/admin/users - list of all users"""
+  accounts = models.Account.gql('WHERE welcomed=True '
+                              + 'AND individual_cla_version != 0'
+                              + 'AND cla_verified=False').fetch(1000)
+  return respond(request, 'admin_users.html', {'users': accounts})
+
+
+def _get_groups_for_account(account):
+  return models.gql(models.AccountGroup,
+                    'WHERE members = :1',
+                    account.user).fetch(models.FETCH_MAX)
+
+def _set_groups_for_account(account, groups):
+  u = account.user
+  existing = _get_groups_for_account(account)
+  # remove from the ones that don't have it any more
+  group_keys = [g.key() for g in groups]
+  for g in existing:
+    if g.key() not in group_keys:
+      g.members.remove(u)
+      g.put()
+  # add to the ones that didn't have it before
+  existing_keys = [g.key() for g in existing]
+  for g in groups:
+    if g.key() not in existing_keys:
+      g.members.append(u)
+      g.put()
+  
+class AdminUserForm(BaseForm):
+  _template = 'admin_user.html'
+
+  dest = forms.fields.CharField(widget=forms.widgets.HiddenInput)
+
+  # user info
+  real_name = forms.CharField(max_length=60)
+  preferred_email = forms.EmailField(required=False)
+  mailing_address = forms.CharField(required=False,
+                          max_length=150,
+                          widget=forms.Textarea(attrs={'rows': 4, 'cols': 60}))
+  mailing_address_country = forms.CharField(max_length=30, required=False)
+  phone_number = forms.CharField(max_length=30, required=False)
+  fax_number = forms.CharField(max_length=30, required=False)
+
+  # groups
+  groups = fields.UserGroupField(allow_users=False, allow_groups=True)
+
+  # cla
+  cla_verified = forms.fields.BooleanField(required=False)
+  cla_comments = forms.CharField(required=False,
+                          max_length=300,
+                          widget=forms.Textarea(attrs={'rows': 6, 'cols': 60}))
+
+  @classmethod
+  def _init(cls, state):
+    account = state['account']
+    dest = state['dest']
+    return {
+        'initial': {
+            'dest': dest,
+            'real_name': account.real_name,
+            'preferred_email': account.preferred_email,
+            'mailing_address': account.mailing_address,
+            'mailing_address_country': account.mailing_address_country,
+            'phone_number': account.phone_number,
+            'fax_number': account.fax_number,
+            'groups': _get_groups_for_account(account),
+            'cla_verified': account.cla_verified,
+            'cla_verified_by': account.cla_verified_by,
+            'cla_verified_timestamp': account.cla_verified_timestamp,
+            'individual_cla_version': account.individual_cla_version,
+            'individual_cla_timestamp': account.individual_cla_timestamp,
+            'cla_comments': account.cla_comments,
+          },
+        }
+
+  def _save(self, cd, state):
+    account = state['account']
+    account.real_name = cd['real_name'].strip()
+    if cd['preferred_email']:
+      account.preferred_email = cd['preferred_email']
+    account.mailing_address = cd['mailing_address']
+    account.mailing_address_country = cd['mailing_address_country']
+    account.phone_number = cd['phone_number']
+    account.fax_number = cd['fax_number']
+    if account.cla_verified != cd['cla_verified']:
+      account.cla_verified = cd['cla_verified']
+      account.cla_verified_by = models.Account.current_user_account.user
+    if cd['cla_verified'] and account.cla_verified_timestamp is None:
+      account.cla_verified_timestamp = datetime.datetime.utcnow()
+    account.cla_comments = cd['cla_comments']
+    account.put()
+    _set_groups_for_account(account, 
+                            fields.UserGroupField.get_groups(cd['groups']))
+    if self.is_valid():
+      return HttpResponseRedirect(cd['dest'])
+
+
+@admin_required
+def admin_user(request, email):
+  """/admin/user/email@address.com - edit this user"""
+  account = models.Account.get_account_for_email(email)
+  referrer = request.META.get('HTTP_REFERER', '/admin/users')
+  state = {
+      'account': account,
+      'dest': referrer,
+    }
+  return process_form(request, AdminUserForm, state, None, {'email':email})
+  
+@admin_required
+def admin_groups(request):
+  """/admin/groups - list of all groups"""
+  models.AccountGroup.create_groups()
+  groups = models.AccountGroup.get_all_groups()
+  return respond(request, 'admin_groups.html', {'groups': groups})
+
+class AdminGroupForm(BaseForm):
+  _template = 'admin_group.html'
+
+  name = forms.CharField(max_length=30)
+  comment = forms.CharField(required=False,
+                            max_length=10000,
+                            widget=forms.Textarea(attrs={'cols': 60}))
+  members = fields.UserGroupField(allow_users=True, allow_groups=False)
+
+  @classmethod
+  def _init(cls, group):
+     who = group.members
+     who = fields.UserGroupField.field_value_for_keys(users = who)
+     return {'initial': {'name': group.name,
+             'comment': group.comment,
+             'members': who
+            }}
+
+  def _save(self, cd, group):
+    new_name = cd['name'].strip()
+    if group.is_auto_group and group.name != new_name:
+      self.errors['name'] = ['Name can not be changed']
+
+    # TODO(joeo): Big race condition here.
+    #
+    in_use = models.AccountGroup.get_group_for_name(new_name)
+    if in_use and group.key() != in_use.key():
+      self.errors['name'] = ['Name is already in use']
+
+    if self.is_valid():
+      group.name = new_name
+      group.comment = cd['comment']
+      group.members = fields.UserGroupField.get_users(cd['members'])
+      group.put()
+
+@admin_required
+def admin_group(request, name):
+  """/admin/group/group - edit this group"""
+  group = models.AccountGroup.get_group_for_name(name)
+  def done():
+    return HttpResponseRedirect('/admin/groups')
+  return process_form(request, AdminGroupForm, group, done,
+                      {'group': group,
+                       'del_url': '/admin/group_delete/%s' % group.name,
+                      })
+  
+class AdminNewGroupForm(AdminGroupForm):
+  @classmethod
+  def _init(cls, group):
+     return {'initial': {'name': '', 'comment': ''}}
+
+  def _save(self, cd, group):
+    new_name = cd['name'].strip()
+
+    # TODO(joeo): Big race condition here.
+    #
+    if models.AccountGroup.get_group_for_name(new_name):
+      self.errors['name'] = ['Name is already in use']
+
+    if self.is_valid():
+      who = fields.UserGroupField.get_users(cd['members'])
+      group = models.AccountGroup(name = new_name,
+                                  comment = cd['comment'],
+                                  members = who)
+      group.put()
+
+@admin_required
+def admin_group_new(request):
+  """/admin/group/GROUP - add a new group"""
+  def done():
+    return HttpResponseRedirect('/admin/groups')
+  return process_form(request, AdminNewGroupForm, [], done)
+
+@gae_admin_required
+@xsrf_required
+def admin_group_delete(request, name):
+  """/admin/group_delete/GROUP - add a new group"""
+  group = models.AccountGroup.get_group_for_name(name)
+  assert group
+  group.remove()
+  return HttpResponseRedirect('/admin/groups')
+
+