# Mark Huang <mlhuang@cs.princeton.edu>
# Copyright (C) 2006 The Trustees of Princeton University
#
-# $Id: Persons.py,v 1.29 2007/01/08 16:34:12 tmack Exp $
+# $Id: Persons.py,v 1.39 2007/10/01 20:51:46 tmack Exp $
#
from types import StringTypes
'bio': Parameter(str, "Biography", max = 254, nullok = True),
'enabled': Parameter(bool, "Has been enabled"),
'password': Parameter(str, "Account password in crypt() form", max = 254),
- 'verification_key': Parameter(str, "Reset password key", max = 254),
- 'verification_expires': Parameter(int, "Date and time when verification_key expires"),
+ 'verification_key': Parameter(str, "Reset password key", max = 254, nullok = True),
+ 'verification_expires': Parameter(int, "Date and time when verification_key expires", nullok = True),
'last_updated': Parameter(int, "Date and time of last update", ro = True),
'date_created': Parameter(int, "Date and time when account was created", ro = True),
'role_ids': Parameter([int], "List of role identifiers"),
rest = email[at_sign+1:]
domain = rest.split('.')
- # This means local, unqualified addresses, are no allowed
+ # This means local, unqualified addresses, are not allowed
if not domain:
raise invalid_email
if len(domain) < 2:
raise invalid_email
- conflicts = Persons(self.api, [email])
- for person in conflicts:
+ # check only against users on the same peer
+ if 'peer_id' in self:
+ namespace_peer_id = self['peer_id']
+ else:
+ namespace_peer_id = None
+
+ conflicts = Persons(self.api, {'email':email,'peer_id':namespace_peer_id})
+
+ for person in conflicts:
if 'person_id' not in self or self['person_id'] != person['person_id']:
raise PLCInvalidArgument, "E-mail address already in use"
self['site_ids'].remove(site_id)
self['site_ids'].insert(0, site_id)
- def send_initiate_password_reset_email(self):
- # email user next step instructions
- to_addr = {}
- to_addr[self['email']] = "%s %s" % \
- (self['first_name'], self['last_name'])
- from_addr = {}
- from_addr[self.api.config.PLC_MAIL_SUPPORT_ADDRESS] = \
- "%s %s" % ('Planetlab', 'Support')
-
- # fill in template
- messages = Messages(self.api, ['ASSWORD_RESET_INITIATE'])
- if not messages:
- print >> log, "No such message template"
- return 1
-
- message = messages[0]
- subject = message['subject']
- template = message['template'] % \
- (self.api.config.PLC_WWW_HOST,
- self['verification_key'], self['person_id'],
- self.api.config.PLC_MAIL_SUPPORT_ADDRESS,
- self.api.config.PLC_WWW_HOST)
-
- self.api.mailer.mail(to_addr, None, from_addr, subject, template)
-
- def send_account_registered_email(self, site):
- to_addr = {}
- cc_addr = {}
- from_addr = {}
- from_addr[self.api.config.PLC_MAIL_SUPPORT_ADDRESS] = \
- "%s %s" % ('Planetlab', 'Support')
-
- # email user
- user_full_name = "%s %s" % (self['first_name'], self['last_name'])
- to_addr[self['email']] = "%s" % user_full_name
-
- # if the account had a admin role or a pi role, email support.
- if set(['admin', 'pi']).intersection(self['roles']):
- to_addr[self.api.config.PLC_MAIL_SUPPORT_ADDRESS] = \
- "%s %s" % ('Planetlab', 'Support')
+ def update_last_updated(self, commit = True):
+ """
+ Update last_updated field with current time
+ """
- # cc site pi's
- site_persons = Persons(self.api, site['person_ids'])
- for person in site_persons:
- if 'pi' in person['roles'] and not person['email'] in to_addr.keys():
- cc_addr[person['email']] = "%s %s" % \
- (person['first_name'], person['last_name'])
-
- # fill in template
- messages = Messages(self.api, ['ACCOUNT_REGISTERED'])
- if not messages:
- print >> log, "No such message template"
- return 1
-
- message = messages[0]
- subject = message['subject'] % (user_full_name, site['name'])
- template = message['template'] % \
- (user_full_name, site['name'], ", ".join(self['roles']),
- self.api.config.PLC_WWW_HOST, self['person_id'],
- self.api.config.PLC_MAIL_SUPPORT_ADDRESS,
- self.api.config.PLC_WWW_HOST)
-
- self.api.mailer.mail(to_addr, cc_addr, from_addr, subject, template)
+ assert 'person_id' in self
+ assert self.table_name
+
+ self.api.db.do("UPDATE %s SET last_updated = CURRENT_TIMESTAMP " % (self.table_name) + \
+ " where person_id = %d" % (self['person_id']) )
+ self.sync(commit)
def delete(self, commit = True):
"""
database.
"""
- def __init__(self, api, person_filter = None, columns = None, peer_id = None):
+ def __init__(self, api, person_filter = None, columns = None):
Table.__init__(self, api, Person, columns)
-
- sql = "SELECT %s FROM view_persons WHERE deleted IS False" % \
- ", ".join(self.columns)
-
- if peer_id is None:
- sql += " AND peer_id IS NULL"
- elif isinstance(peer_id, (int, long)):
- sql += " AND peer_id = %d" % peer_id
-
+ #sql = "SELECT %s FROM view_persons WHERE deleted IS False" % \
+ # ", ".join(self.columns)
+ foreign_fields = {'role_ids': ('role_id', 'person_role'),
+ 'roles': ('name', 'roles'),
+ 'site_ids': ('site_id', 'person_site'),
+ 'key_ids': ('key_id', 'person_key'),
+ 'slice_ids': ('slice_id', 'slice_person')
+ }
+ foreign_keys = {}
+ db_fields = filter(lambda field: field not in foreign_fields.keys(), Person.fields.keys())
+ all_fields = db_fields + [value[0] for value in foreign_fields.values()]
+ fields = []
+ _select = "SELECT "
+ _from = " FROM persons "
+ _join = " LEFT JOIN peer_person USING (person_id) "
+ _where = " WHERE deleted IS False "
+
+ if not columns:
+ # include all columns
+ fields = all_fields
+ tables = [value[1] for value in foreign_fields.values()]
+ tables.sort()
+ for key in foreign_fields.keys():
+ foreign_keys[foreign_fields[key][0]] = key
+ for table in tables:
+ if table in ['roles']:
+ _join += " LEFT JOIN roles USING(role_id) "
+ else:
+ _join += " LEFT JOIN %s USING (person_id) " % (table)
+ else:
+ tables = set()
+ columns = filter(lambda column: column in db_fields+foreign_fields.keys(), columns)
+ columns.sort()
+ for column in columns:
+ if column in foreign_fields.keys():
+ (field, table) = foreign_fields[column]
+ foreign_keys[field] = column
+ fields += [field]
+ tables.add(table)
+ if column in ['roles']:
+ _join += " LEFT JOIN roles USING(role_id) "
+ else:
+ _join += " LEFT JOIN %s USING (person_id)" % \
+ (foreign_fields[column][1])
+
+ else:
+ fields += [column]
+
+ # postgres will return timestamps as datetime objects.
+ # XMLPRC cannot marshal datetime so convert to int
+ timestamps = ['date_created', 'last_updated', 'verification_expires']
+ for field in fields:
+ if field in timestamps:
+ fields[fields.index(field)] = \
+ "CAST(date_part('epoch', %s) AS bigint) AS %s" % (field, field)
+
+ _select += ", ".join(fields)
+ sql = _select + _from + _join + _where
+
+ # deal with filter
if person_filter is not None:
if isinstance(person_filter, (list, tuple, set)):
# Separate the list into integers and strings
elif isinstance(person_filter, dict):
person_filter = Filter(Person.fields, person_filter)
sql += " AND (%s)" % person_filter.sql(api, "AND")
- self.selectall(sql)
+ elif isinstance (person_filter, StringTypes):
+ person_filter = Filter(Person.fields, {'email':[person_filter]})
+ sql += " AND (%s)" % person_filter.sql(api, "AND")
+ elif isinstance (person_filter, int):
+ person_filter = Filter(Person.fields, {'person_id':[person_filter]})
+ sql += " AND (%s)" % person_filter.sql(api, "AND")
+ else:
+ raise PLCInvalidArgument, "Wrong person filter %r"%person_filter
+
+ # aggregate data
+ all_persons = {}
+ for row in self.api.db.selectall(sql):
+ person_id = row['person_id']
+
+ if all_persons.has_key(person_id):
+ for (key, key_list) in foreign_keys.items():
+ data = row.pop(key)
+ row[key_list] = [data]
+ if data and data not in all_persons[person_id][key_list]:
+ all_persons[person_id][key_list].append(data)
+ else:
+ for key in foreign_keys.keys():
+ value = row.pop(key)
+ if value:
+ row[foreign_keys[key]] = [value]
+ else:
+ row[foreign_keys[key]] = []
+ if row:
+ all_persons[person_id] = row
+
+ # populate self
+ for row in all_persons.values():
+ obj = self.classobj(self.api, row)
+ self.append(obj)
+
git://git.onelab.eu / plcapi.git / blobdiff