backend/users.py

   1 #!/usr/bin/python
   2
   3 import hashlib
   4 import logging
   5 import random
   6 import string
   7 import urllib
   8
   9 import tornado.locale
  10
  11 import base
  12
  13 class Users(base.Object):
  14         def auth(self, name, passphrase):
  15                 # If either name or passphrase is None, we don't check at all.
  16                 if None in (name, passphrase):
  17                         return
  18
  19                 user = self.db.get("""SELECT id FROM users WHERE name = %s
  20                         AND passphrase = SHA1(%s) AND activated = 'Y' AND deleted = 'N'""",
  21                         name, passphrase)
  22
  23                 if user:
  24                         return User(self.pakfire, user.id)
  25
  26         def register(self, name, passphrase, email, realname, locale=None):
  27                 return User.new(self.pakfire, name, passphrase, email, realname, locale)
  28
  29         def name_is_used(self, name):
  30                 users = self.db.query("SELECT id FROM users WHERE name = %s", name)
  31
  32                 if users:
  33                         return True
  34
  35                 return False
  36
  37         def email_is_used(self, email):
  38                 users = self.db.query("SELECT id FROM users WHERE email = %s", email)
  39
  40                 if users:
  41                         return True
  42
  43                 return False
  44
  45         def get_all(self):
  46                 users = self.db.query("""SELECT id FROM users WHERE activated = 'Y' AND
  47                         deleted = 'N' ORDER BY realname, name""")
  48
  49                 return [User(self.pakfire, u.id) for u in users]
  50
  51         def get_by_id(self, id):
  52                 user = self.db.get("SELECT id FROM users WHERE id = %s LIMIT 1", id)
  53
  54                 if user:
  55                         return User(self.pakfire, user.id)
  56
  57         def get_by_name(self, name):
  58                 user = self.db.get("SELECT id FROM users WHERE name = %s LIMIT 1", name)
  59
  60                 if user:
  61                         return User(self.pakfire, user.id)
  62
  63         def get_by_email(self, email):
  64                 user = self.db.get("SELECT id FROM users WHERE email = %s LIMIT 1", email)
  65
  66                 if user:
  67                         return User(self.pakfire, user.id)
  68
  69
  70 class User(base.Object):
  71         def __init__(self, pakfire, id):
  72                 base.Object.__init__(self, pakfire)
  73                 self.id = id
  74
  75                 self.data = self.db.get("SELECT * FROM users WHERE id = %s" % self.id)
  76
  77         def __cmp__(self, other):
  78                 return cmp(self.id, other.id)
  79
  80         @classmethod
  81         def new(cls, pakfire, name, passphrase, email, realname, locale=None):
  82
  83                 id = pakfire.db.execute("""INSERT INTO users(name, passphrase, email, realname)
  84                         VALUES(%s, SHA1(%s), %s, %s)""", name, passphrase, email, realname)
  85
  86                 user = cls(pakfire, id)
  87
  88                 # If we have a guessed locale, we save it (for sending emails).
  89                 if locale:
  90                         user.locale = locale
  91
  92                 user.send_activation_mail()
  93
  94                 return user
  95
  96         def delete(self):
  97                 self.db.execute("UPDATE users SET deleted = 'Y' WHERE id = %s", self.id)
  98
  99         def activate(self):
 100                 self.db.execute("UPDATE users SET activated = 'Y' WHERE id = %s", self.id)
 101
 102         def set_passphrase(self, passphrase):
 103                 """
 104                         Update the passphrase the users uses to log on.
 105                 """
 106                 self.db.execute("UPDATE users SET passphrase = SHA1(%s) WHERE id = %s",
 107                         passphrase, self.id)
 108
 109         passphrase = property(lambda x: None, set_passphrase)
 110
 111         @property
 112         def activation_code(self):
 113                 return self.data.activation_code
 114
 115         def get_realname(self):
 116                 if not self.data.realname:
 117                         return self.name
 118
 119                 return self.data.realname
 120
 121         def set_realname(self, realname):
 122                 self.db.execute("UPDATE users SET realname = %s WHERE id = %s",
 123                         realname, self.id)
 124                 self.data["realname"] = realname
 125
 126         realname = property(get_realname, set_realname)
 127
 128         @property
 129         def name(self):
 130                 return self.data.name
 131
 132         def get_email(self):
 133                 return self.data.email
 134
 135         def set_email(self, email):
 136                 if email == self.email:
 137                         return
 138
 139                 self.db.execute("""UPDATE users SET email = %s, activated = 'N'
 140                         WHERE id = %s""", email, self.id)
 141
 142                 self.data.update({
 143                         "email" : email,
 144                         "activated" : "N",
 145                 })
 146
 147                 # Inform the user, that he or she has to re-activate the account.
 148                 self.send_activation_mail()
 149
 150         email = property(get_email, set_email)
 151
 152         def get_state(self):
 153                 return self.data.state
 154
 155         def set_state(self, state):
 156                 self.db.execute("UPDATE users SET state = %s WHERE id = %s", state,
 157                         self.id)
 158                 self.data["state"] = state
 159
 160         state = property(get_state, set_state)
 161
 162         def get_locale(self):
 163                 return self.data.locale or ""
 164
 165         def set_locale(self, locale):
 166                 self.db.execute("UPDATE users SET locale = %s WHERE id = %s", locale,
 167                         self.id)
 168                 self.data["locale"] = locale
 169
 170         locale = property(get_locale, set_locale)
 171
 172         @property
 173         def activated(self):
 174                 return self.data.activated == "Y"
 175
 176         @property
 177         def registered(self):
 178                 return self.data.registered
 179
 180         def gravatar_icon(self, size=128):
 181                 # construct the url
 182                 gravatar_url = "http://www.gravatar.com/avatar/" + \
 183                         hashlib.md5(self.email.lower()).hexdigest() + "?"
 184                 gravatar_url += urllib.urlencode({'d': "mm", 's': str(size)})
 185
 186                 return gravatar_url
 187
 188         def is_admin(self):
 189                 return self.state == "admin"
 190
 191         def is_tester(self):
 192                 return self.state == "tester"
 193
 194         def send_activation_mail(self):
 195                 logging.debug("Sending activation mail to %s" % self.email)
 196
 197                 # Generate a random activation code.
 198                 source = string.ascii_letters + string.digits
 199                 self.data["activation_code"] = "".join(random.sample(source * 20, 20))
 200                 self.db.execute("UPDATE users SET activation_code = %s WHERE id = %s",
 201                         self.activation_code, self.id)
 202
 203                 # Get the saved locale from the user.
 204                 locale = tornado.locale.get(self.locale)
 205                 _ = locale.translate
 206
 207                 subject = _("Account Activation")
 208
 209                 message  = _("You, or somebody using you email address, has registered an account on the Pakfire Build Service.")
 210                 message += "\n"*2
 211                 message += _("To activate your account, please click on the link below.")
 212                 message += "\n"*2
 213                 message += "    http://pakfire.ipfire.org/user/%(name)s/activate/%(activation_code)s" \
 214                         % { "name" : self.name, "activation_code" : self.activation_code, }
 215                 message += "\n"*2
 216                 message += "Sincerely,\n    The Pakfire Build Service"
 217
 218                 self.pakfire.messages.add("%s <%s>" % (self.realname, self.email), subject, message)
 219
 220         @property
 221         def comments(self, limit=5):
 222                 comments = self.db.query("""SELECT * FROM package_comments
 223                         WHERE user_id = %s ORDER BY time DESC LIMIT %s""", self.id, limit)
 224
 225                 return comments
 226
 227         @property
 228         def log(self):
 229                 log = self.db.query("SELECT * FROM log WHERE user_id = %s ORDER BY time DESC",
 230                         self.id)
 231
 232                 return log