Models, MongoEngine, Python

models.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Copyright (c) 2011 The Octopus Apps Inc.
# Licensed under the Apache License, Version 2.0 (the "License")
#
# Author: Alejandro M. Bernardis
# Email: alejandro.m.bernardis at gmail.com
# Created: May 8, 2012, 6:25:25 PM 

import re, datetime

from bson.objectid import ObjectId
from com.ak.tornado.security import Password, Role, secret_key, activation_key
from mongoengine import Document, StringField, IntField, URLField, EmailField,\
                        DateTimeField, BooleanField, Q, ReferenceField, CASCADE

#: -- helpers ------------------------------------------------------------------

__all__ = [
    "User",
    "LegalAudit",
    "Location",
    "DateCompare",
    "get_date_compare",
]

#: -- fields -------------------------------------------------------------------

password_exp = re.compile(r"^sha1\$([A-Z0-9]+)", re.IGNORECASE)

class PasswordField(StringField):
    def __set__(self, instance, value):
        if value and not password_exp.search(str(value)):
            value = Password.generate(str(value))
        StringField.__set__(self, instance, value)

#: -- DateCompare --------------------------------------------------------------

class DateCompare(object):
    def __init__(self, date=None, date_min=-1, date_max=1):
        self.date = date or datetime.datetime.now()
        
        compare_min = datetime.datetime(self.date.year, self.date.month, 
                                        self.date.day, 23, 59, 59)
        
        self.min = datetime.timedelta(days=date_min) + compare_min
        
        compare_max = datetime.datetime(self.date.year, self.date.month, 
                                        self.date.day, 0, 0, 0)
        
        self.max = datetime.timedelta(days=date_max) + compare_max

#: -- models -------------------------------------------------------------------

class ControlDocument(Document):
    meta = {
        "abstract": True
    }
    
    #: fields
    availabled = BooleanField(default=False)
    enabled = BooleanField(default=False)
    created = DateTimeField(default=datetime.datetime.now())
    modified = DateTimeField(default=datetime.datetime.now())
    
    #: methods
    def get_date_compare(self, date=None, date_min=-1, date_max=1):
        return DateCompare(date, date_min, date_max)
    
    def _datetime_update(self, key, value=None, update_data=None):
        try:
            if not value:
                value = datetime.datetime.now()
            if not update_data:
                update_data = dict()
            update_data["set__"+key] = value
            self.update(**update_data)
            self.reload()
            return True
        except:
            return False
        
    def set_modified(self, value=None):
        return self._datetime_update("modified", value)
    
    def set_modified_with_data(self, update_data, value=None):
        return self._datetime_update("modified", value, update_data)
    
    def _status_update(self, key, value=False):
        try:
            update_data = dict()
            update_data["set__"+key] = value
            return self.set_modified_with_data(update_data)
        except:
            return False
    
    def set_availabled(self, value=False):
        return self._status_update("availabled", value)
    
    def set_enabled(self, value=False):
        return self._status_update("enabled", value)
    
#: -----------------------------------------------------------------------------

class UserRole(ControlDocument):
    meta = {
        "collection": "roles",
        "indexes": ["name"]
    }
    
    #: fields
    name = StringField(max_length=64, unique=True)
    permissions = IntField(default=0)
    level = IntField(default=0)
    admin = BooleanField(default=False)
    read = BooleanField(default=False)
    write = BooleanField(default=False)
    
    #: methods
    def allow(self, value):
        return value >= self.permissions
    
    def get_role_object(self):
        role = Role.get_role(self.name)
        if not role:
            role = Role(self.name, self.write, self.admin, self.level)
        return role
    
#: -----------------------------------------------------------------------------

class UserGender(ControlDocument):
    meta = {
        "collection": "genders",
        "indexes": ["uid"]
    }
    
    #: fields
    uid = IntField(unique=True)
    name = StringField(max_length=16)

#: -----------------------------------------------------------------------------

class User(ControlDocument):
    meta = {
        "collection": "users",
        "indexes": ["token", "facebook_uid", "username"]
    }
    
    #: reference
    role = ReferenceField(UserRole, CASCADE)
    gender = ReferenceField(UserGender, CASCADE)
    
    #: fields
    token = StringField(max_length=64, unique=True)
    facebook_uid = StringField(max_length=128, unique=True)
    username = StringField(max_length=32, required=True, unique=True)
    password = PasswordField(max_length=128, required=True)
    email = EmailField(max_length=255, required=True, unique=True)
    first_name = StringField(max_length=64)
    middle_name = StringField(max_length=64)
    last_name = StringField(max_length=64)
    birthday = DateTimeField()
    avatar = URLField()
    secret_question = StringField(max_length=255)
    secret_answer = StringField(max_length=255)
    activation_key = StringField(max_length=64)
    activation_key_expire = DateTimeField()
    notes = StringField(max_length=500)
    terms = BooleanField(default=False)
    policy = BooleanField(default=False)
    news = BooleanField(default=False)
    remote_ip = StringField(max_length=64)
    last_login = DateTimeField(default=datetime.datetime.now())
    
    #: methods
    def _set_new_password(self, password=None, update_data=None):
        try:
            if not password:
                password = secret_key(8)
            if not update_data:
                update_data = dict()
            update_data["set__password"] = password
            return self.set_modified_with_data(update_data)
        except:
            return False
    
    def set_new_password(self, password=None):
        return self._set_new_password(password)
        
    def set_activation_key(self, expire_days=1):
        try:
            key = activation_key(self.username, self.email)
            key_expire = datetime.datetime.now()\
                       + datetime.timedelta(days=expire_days)
            update_data = dict(
                set__enabled=False,
                set__activation_key=key,
                set__activation_key_expire=key_expire)
            return self.set_modified_with_data(update_data)
        except:
            return False
        
    def set_activation_key_password(self, password=None):
        update_data = dict(set__enabled=True)
        return self._set_new_password(password, update_data)
    
    def validate_activation_key(self, key):
        try:
            if not self.activation_key \
                or not self.activation_key_expire \
                or self.activation_key_expire < datetime.datetime.today():
                raise
            update_data = dict(
                set__enabled=True,
                set__activation_key=None,
                set__activation_key_expire=None)
            return self.set_modified_with_data(update_data)
        except:
            return False
        
    def set_last_login(self, value=None):
        return self._datetime_update("last_login", value)
    
#: -----------------------------------------------------------------------------