class ResourceA(db.Model):
"""
Example resource to build model and routes around
Owns many Resource B's while a Resource B is only associated with 1 Resource A
All Resource A's can be viewed by anyone -- signed-in user or not
Only resources you own can be edited by you, however
"""
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text, nullable=False)
owner_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
resource_b_set = db.relationship('ResourceB', backref='resourceA')
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
def __init__(self, **data):
self.name = data.get('name')
self.created_at = datetime.now()
def __str__(self):
return 'Resource A: {name}'.format(name=self.name)
def to_dict(self):
"""
Serialize data into publicly exposable dictionary
:return:
"""
return {
'id': self.id,
'name': self.name
}
class Role(db.Model, RoleMixin):
"""
Roles used for AdminUsers
"""
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text, unique=True)
description = db.Column(db.Text)
def __str__(self):
return self.name
class ResourceB(db.Model):
"""
Example resource used to demonstrate one-to-many relationships
Associated with one Resource A and does not own any resources
"""
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text, nullable=False)
resource_a_id = db.Column(db.Integer, db.ForeignKey('resourceA.id'), nullable=False)
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
def __init__(self, **data):
self.name = data.get('name')
self.created_at = datetime.now()
def __str__(self):
return 'Resource B: {name}'.format(name=self.name)
class OAuthConnection(db.Model):
"""
Class to create various connected accounts
"""
__tablename__ = 'oauth_connection'
id = db.Column(db.Integer, primary_key=True)
owner_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
email_address = db.Column(db.Text)
type = db.Column(db.Enum(OAuthConnectionType))
ext_user_id = db.Column(db.Text)
ext_access_token = db.Column(db.Text)
ext_refresh_token = db.Column(db.Text)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now())
updated_at = db.Column(db.DateTime)
def __init__(self, **data):
self.owner_id = data.get('owner_id')
self.email_address = data.get('email_address')
self.type = data.get('type')
self.ext_user_id = data.get('ext_user_id')
self.ext_access_token = data.get('ext_access_token')
self.ext_refresh_token = data.get('ext_refresh_token')
def to_dict(self):
"""
Serializes oauth connection
:return: dict()
"""
return {
'type': self.type,
'ext_access_token': self.ext_access_token,
'ext_refresh_token': self.ext_refresh_token,
'email_address': self.email_address,
}
class User(db.Model, UserMixin):
"""
User superclass to inherit auth token function
"""
id = db.Column(db.Integer, primary_key=True)
full_name = db.Column(db.Text)
first_name = db.Column(db.Text)
last_name = db.Column(db.Text)
email = db.Column(db.Text, unique=True, nullable=False)
password = db.Column(db.Text, nullable=False)
phone_number = db.Column(db.Text, unique=True)
image_url = db.Column(db.Text)
active = db.Column(db.Boolean)
is_admin = db.Column(db.Boolean)
oauth_connections = db.relationship('OAuthConnection', backref='owner')
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now())
updated_at = db.Column(db.DateTime)
confirmed_at = db.Column(db.DateTime)
last_login_at = db.Column(db.DateTime)
current_login_at = db.Column(db.DateTime)
last_login_ip = db.Column(db.Text)
current_login_ip = db.Column(db.Text)
login_count = db.Column(db.Integer)
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users'),
cascade="all,delete")
def __init__(self, **data):
self.full_name = data.get('full_name', '')
self.first_name = data.get('first_name', '')
self.last_name = data.get('last_name', '')
self.email = data.get('email', '')
self.password = hash_password(data.get('password', ''))
self.phone_number = data.get('phone_number', '')
self.image_url = data.get('image_url', '')
self.active = data.get('is_active', True)
self.is_admin = data.get('is_admin', False)
self.oauth_connections = data.get('oauth_connections', [])
self.created_at = datetime.now()
def change_password(self, old_password, new_password):
"""
Changes the user's password, hashes, saves and returns True
If old password is incorrect returns False
:return: True if password was successfully changed else False
"""
if not verify_password(old_password, self.password):
return False
self.password = hash_password(new_password)
db.session.commit()
return True
def to_dict(self):
"""
Serializes user's data into dictionary for API response
:return:
"""
return {
'id': self.id,
'first_name': self.first_name,
'last_name': self.last_name,
'email': self.email,
'phone_number': self.phone_number,
}
def public_dict(self):
"""
Serialize user's data into dictionary to be exposed publicly
:return:
"""
return {
'id': self.id,
'first_name': self.first_name,
'last_name': self.last_name,
}
def get_oauth_dicts_for(self, provider):
"""
Returns dict of info needed for async task that retrieves contacts
:return: dict()
"""
connections = self.get_my_oauth_connection_for(provider)
return [connection.to_dict() for connection in connections]
def get_my_oauth_connections_for(self, provider):
"""
Returns the user's connection for the
:param provider: Enum # used the word "provider" cause "type" is a keyword in python
:return: OAuthConnnection (db.Model)
"""
assert type(provider) == OAuthConnectionType, \
'Please send a OAuthConnectionType object as the "provider"'
return [
connection for connection in self.oauth_connections
if connection.type == provider
]
@classmethod
def get_user_by_attrs(cls, get_all=False, **attrs):
"""
Filters users by provided attributes
Provided attributes must be in User class
:param get_all: bool
:param attrs: dict
:return: user
"""
if not all(attr in cls.__dict__ for attr in attrs):
return None
filters = []
for attr, value in attrs.items():
filters.append(eval('{}.{}'.format(cls.__name__, attr)) == value)
query = cls.query.filter(and_(*filters))
return query.all() if get_all else query.first()
# pylint: disable=no-member,invalid-name,super-init-not-called,too-few-public-methods,too-many-instance-attributes
from enum import Enum
from datetime import datetime
from sqlalchemy.sql.expression import and_
from flask_security import UserMixin, RoleMixin
from flask_security.utils import hash_password, verify_password
from app_name.database import db
roles_users = db.Table(
'roles_users', db.Column('user_id', db.Integer, db.ForeignKey('user.id')),
db.Column('role_id', db.Integer, db.ForeignKey('role.id')))
class Role(db.Model, RoleMixin):
"""
Roles used for AdminUsers
"""
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text, unique=True)
description = db.Column(db.Text)
def __str__(self):
return self.name