class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String, nullable=False)
password = db.Column(db.Binary(60), nullable=False)
registrations = relationship("WeatherRegistration", backref="user")
def __init__(self, username, password):
self.username = username
self.password = bcrypt.generate_password_hash(password)
def __repr__(self):
return '{}'.format(self.username)
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return str(self.id)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, unique=True, nullable=False)
email = db.Column(db.String, unique=True, nullable=False)
_password = db.Column(db.Binary(60), nullable=False)
tasks = db.relationship('Task', backref='poster')
role = db.Column(db.String, default='user')
def __init__(self, name: str='', email: str='', password: str='', role=None):
self.name = name
self.email = email
self.password = password
self.role = role
@hybrid_property
def password(self):
return self._password
@password.setter
def set_password(self, plaintext_password):
self._password = bcrypt.generate_password_hash(plaintext_password)
@hybrid_method
def is_correct_password(self, plaintext_password):
return bcrypt.check_password_hash(self.password, plaintext_password)
def __str__(self):
return f'<User {self.name}>'
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String, unique=True, nullable=False)
_password = db.Column(db.Binary(60), nullable=False)
authenticated = db.Column(db.Boolean, default=False)
def __init__(self, email, password_plaintext):
self.email = email
self.password = password_plaintext
self.authenticated = False
'''
Hybrid properties allow you to treat calculations (e.g. first_name + last_name like any other database column.
See
https://github.com/flask-admin/flask-admin/tree/master/examples/sqla-hybrid_property
http://docs.sqlalchemy.org/en/latest/orm/extensions/hybrid.html#working-with-relationships
'''
@hybrid_property
def password(self):
return self._password
@password.setter
def set_password(self, plaintext_password):
self._password = bcrypt.generate_password_hash(plaintext_password)
@hybrid_method
def is_correct_password(self, plaintext_password):
return bcrypt.check_password_hash(self.password, self.plaintext_password)
def __repr__(self):
return "<User {0}".format(self.name)
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.Binary(128), nullable=False)
def __repr__(self):
return '<User {}>'.format(self.username)
def get_reset_password_token(self, expires_in=600):
return jwt.encode(
{
'reset_password': self.id,
'exp': time() + expires_in
},
current_app.config['SECRET_KEY'],
algorithm='HS256').decode('utf-8')
@staticmethod
def verify_reset_password_token(token):
try:
id = jwt.decode(token,
current_app.config['SECRET_KEY'],
algorithms=['HS256'])['reset_password']
except:
return
return User.query.get(id)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String, unique=True, nullable=False)
_password = db.Column(db.Binary(60), nullable=False)
authenticated = db.Column(db.Boolean, default=False)
email_confirmation_sent_on = db.Column(db.DateTime, nullable=True)
email_confirmed = db.Column(db.Boolean, nullable=True, default=False)
email_confirmed_on = db.Column(db.DateTime, nullable=True)
registered_on = db.Column(db.DateTime, nullable=True)
last_logged_in = db.Column(db.DateTime, nullable=True)
current_logged_in = db.Column(db.DateTime, nullable=True)
def __init__(self, email, password_plaintext, email_confirmation_sent_on=None):
self.email = email
self.password = password_plaintext
self.authenticated = False
self.email_confirmation_sent_on = email_confirmation_sent_on
self.email_confirmed = False
self.email_confirmed_on = None
self.registered_on = datetime.now()
self.last_logged_in = None
self.current_logged_in = datetime.now()
@hybrid_property
def password(self):
return self._password
@password.setter
def set_password(self, plaintext_password):
self._password = bcrypt.generate_password_hash(plaintext_password)
@hybrid_method
def is_correct_password(self, plaintext_password):
return bcrypt.check_password_hash(self.password, plaintext_password)
@property
def is_authenticated(self):
"""Return True if the user is authenticated."""
return self.authenticated
@property
def is_active(self):
"""Always True, as all users are active."""
return True
@property
def is_anonymous(self):
"""Always False, as anonymous users aren't supported."""
return False
def get_id(self):
"""Return the email address to satisfy Flask-Login's requirements."""
"""Requires use of Python 3"""
return str(self.id)
def __repr__(self):
return '<User {0}>'.format(self.name)
class User(db.Model):
"""
Class that represents a user of the application
The following attributes of a user are stored in this table:
email address
password (hashed using Bcrypt)
authenticated flag (indicates if a user is logged in or not)
date that the user registered on
"""
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String, unique=True, nullable=False)
hashed_password = db.Column(db.Binary(60), nullable=False)
authenticated = db.Column(db.Boolean, default=False)
registered_on = db.Column(db.DateTime, nullable=True)
role = db.Column(db.String, default='user')
def __init__(self, email, plaintext_password, role='user'):
self.email = email
self.hashed_password = bcrypt.generate_password_hash(
plaintext_password)
self.authenticated = False
self.registered_on = datetime.now()
self.role = role
def set_password(self, plaintext_password):
self.hashed_password = bcrypt.generate_password_hash(
plaintext_password)
def is_correct_password(self, plaintext_password):
return bcrypt.check_password_hash(self.hashed_password,
plaintext_password)
@property
def is_authenticated(self):
"""Return True if the user is authenticated."""
return self.authenticated
@property
def is_active(self):
"""Always True, as all users are active."""
return True
@property
def is_anonymous(self):
"""Always False, as anonymous users aren't supported."""
return False
def get_id(self):
"""Return the id of a user to satisfy Flask-Login's requirements."""
return str(self.id)
def __repr__(self):
return '<User {}>'.format(self.email)
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
first_name = db.Column(db.String, unique=False, nullable=False)
last_name = db.Column(db.String, unique=False, nullable=False)
email = db.Column(db.String, unique=True, nullable=False)
_password = db.Column(
db.Binary(60),
nullable=False) # _password com underline, atributo privado
authenticated = db.Column(db.Boolean, default=False)
def __init__(self, first_name, last_name, email, password_text):
self.first_name = first_name
self.last_name = last_name
self.email = email
self.password = password_text
self.authenticated = False
@hybrid_property
def password(self):
return self._password
# o @password.setter permite definir a password que tá armazenada no atributo _password
@password.setter
def password(self, password_text):
self._password = bcrypt.generate_password_hash(password_text)
@hybrid_method
def is_correct_password(self, password_text):
return bcrypt.check_password_hash(self._password, password_text)
# @property permite que o método possa ser acessado como se fosse um atributo
@property
def is_authenticated(self):
"""Return True if the user is authenticated."""
return self.authenticated
@property
def is_active(self):
"""Always True, as all users are active."""
return True
@property
def is_anonymous(self):
"""Always False, as anonymous users aren't supported"""
return False
def get_id(self):
"""Return the email address to satisfy Flask-Login's requirements"""
return str(self.id)
def __repr__(self):
return '<User {0}>'.format(self.name)
class User(db.Model):
__tablename__ = "Users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
first_name = db.Column(db.String(255), nullable=False)
last_name = db.Column(db.String(255), nullable=False)
email = db.Column(db.String(255), unique=True, nullable=False)
password = db.Column(db.Binary(255), nullable=False)
team = db.Column(db.String(255), nullable=False)
position = db.Column(db.String(255), nullable=False)
registered_on = db.Column(db.DateTime, nullable=False)
admin = db.Column(db.Boolean, nullable=False, default=False)
active = db.Column(db.Boolean, nullable=False, default=True)
def __init__(self,
first_name,
last_name,
email,
password,
team,
position,
admin=False,
active=True):
self.email = email
self.first_name = first_name
self.last_name = last_name
self.password = bcrypt.generate_password_hash(password)
self.team = team
self.position = position
self.registered_on = datetime.datetime.now()
self.admin = admin
self.active = active
def is_authenticated(self):
return True
def is_active(self):
return self.active
def is_anonymous(self):
return False
def get_id(self):
return self.id
def __repr__(self):
return '<User {0}>'.format(self.email)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String(60), unique=True, nullable=False)
_password = db.Column(db.Binary(60), nullable=False)
authenticated = db.Column(db.Boolean, default=False)
email_confirmation_sent_on = db.Column(db.DateTime, nullable=True)
email_confirmed = db.Column(db.Boolean, nullable=True, default=False)
email_confirmed_on = db.Column(db.DateTime, nullable=True)
registered_on = db.Column(db.DateTime, nullable=True)
last_logged_in = db.Column(db.DateTime, nullable=True)
current_logged_in = db.Column(db.DateTime, nullable=True)
role = db.Column(db.String(60), default='user')
items = db.relationship('Items',
cascade="all,delete",
backref='user',
lazy='dynamic')
clouds = db.relationship('Cloud', cascade="all,delete", backref='user')
vpc = db.relationship('VPC', cascade="all, delete", backref="user")
keypairs = db.relationship('Keypair',
cascade="all, delete",
backref="user")
def __json__(self):
return [
'id', 'email', '_password', 'authenticated',
'email_confirmation_sent_on', 'email_confirmed',
'email_confirmed_on', 'registered_on', 'last_logged_in',
'current_logged_in', 'role', 'items'
]
def __init__(self,
email,
password,
email_confirmation_sent_on=None,
role='user'):
self.email = email
self.password = password
self.authenticated = False
self.email_confirmation_sent_on = email_confirmation_sent_on
self.email_confirmed = False
self.email_confirmed_on = None
self.registered_on = datetime.datetime.now()
self.last_logged_in = None
self.current_logged_in = datetime.datetime.now()
self.role = role
@hybrid_property
def password(self):
return self._password
@password.setter
def password(self, password):
self._password = bcrypt.generate_password_hash(password)
@hybrid_method
def is_correct_password(self, password):
return bcrypt.check_password_hash(self.password, password)
@property
def is_authenticated(self):
"""Return True if the user is authenticated."""
return self.authenticated
@property
def is_active(self):
"""Always True, as all users are active."""
return True
@property
def is_email_confirmed(self):
"""Return True if the user confirmed their email address."""
return self.email_confirmed
@property
def is_anonymous(self):
"""Always False, as anonymous users aren't supported."""
return False
def get_id(self):
"""Return the email address to satisfy Flask-Login's requirements."""
"""Requires use of Python 3"""
return str(self.id)
def __repr__(self):
return '<User {}>'.format(self.email)
def encode_auth_token(self, user_id):
"""
Generates the Auth Token
:return: string
"""
try:
payload = {
'exp':
datetime.datetime.utcnow() +
datetime.timedelta(days=0, seconds=5),
'iat':
datetime.datetime.utcnow(),
'sub':
user_id
}
# print("SECRET KEY{}".format(app.config.get("SECRET_KEY")))
return jwt.encode(payload,
app.config.get("SECRET_KEY"),
algorithm='HS256')
except Exception as e:
print("Error")
return e
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String, unique=True, nullable=False)
_password = db.Column(db.Binary(60), nullable=False)
authenticated = db.Column(db.Boolean, default=False)
email_confirmation_sent_on = db.Column(db.DateTime, nullable=True)
email_confirmed = db.Column(db.Boolean, nullable=True, default=False)
email_confirmed_on = db.Column(db.DateTime, nullable=True)
registered_on = db.Column(db.DateTime, nullable=True)
last_logged_in = db.Column(db.DateTime, nullable=True)
current_logged_in = db.Column(db.DateTime, nullable=True)
role = db.Column(db.String, default='user')
screen_data = db.relationship('vitamins', backref='user', lazy='dynamic')
def __init__(self,
email,
plaintext_password,
email_confirmation_sent_on=None,
role='user'):
self.email = email
self.password = plaintext_password
self.authenticated = False
self.email_confirmation_sent_on = email_confirmation_sent_on
self.email_confirmed = False
self.email_confirmed_on = None
self.registered_on = datetime.now()
self.last_logged_in = None
self.current_logged_in = datetime.now()
self.role = role
@hybrid_property
def password(self):
return self._password
@password.setter
def set_password(self, plaintext_password):
self._password = bcrypt.generate_password_hash(plaintext_password)
@hybrid_method
def is_correct_password(self, plaintext_password):
return bcrypt.check_password_hash(self.password, plaintext_password)
@property
def is_authenticated(self):
"""Return True if the user is authenticated."""
return self.authenticated
@property
def is_active(self):
"""Always True, as all users are active."""
return True
@property
def is_anonymous(self):
"""Always False, as anonymous users aren't supported."""
return False
def get_id(self):
"""Return the email address to satisfy Flask-Login's requirements."""
"""Requires use of Python 3"""
return str(self.id)
def generate_auth_token(self, expires_in=3600):
s = Serializer(app.config['SECRET_KEY'], expires_in=expires_in)
return s.dumps({'id': self.id}).decode('utf-8')
@staticmethod
def verify_auth_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
data = s.loads(token)
except:
return None
return User.query.get(data['id'])
def __repr__(self):
return '<User {}>'.format(self.email)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String, unique=True, nullable=False)
_password = db.Column(db.Binary(60), nullable=False)
authenticated = db.Column(db.Boolean, default=False)
email_confirmation_sent_on = db.Column(db.DateTime, nullable=True)
email_confirmed = db.Column(db.Boolean, nullable=True, default=False)
email_confirmed_on = db.Column(db.DateTime, nullable=True)
registered_on = db.Column(db.DateTime, nullable=True)
last_logged_in = db.Column(db.DateTime, nullable=True)
current_logged_in = db.Column(db.DateTime, nullable=True)
role = db.Column(db.String, default='user')
recipes = db.relationship('Recipe', backref='user', lazy='dynamic')
def __init__(self,
email,
plaintext_password,
email_confirmation_sent_on=None,
role='user'):
self.email = email
self.password = plaintext_password
self.authenticated = False
self.email_confirmation_sent_on = email_confirmation_sent_on
self.email_confirmed = False
self.email_confirmed_on = None
self.registered_on = datetime.now()
self.last_logged_in = None
self.current_logged_in = datetime.now()
self.role = role
def import_form_data(self, form):
"""Import the data for this recipe that was input via the EditUserForm
class. This can only be done by the administrator. Additionally, it
is assumed that the form has already been validated prior to being
passed in here."""
try:
if form.email.data != self.email:
self.email = form.email.data
if form.user_role.data != self.role:
self.role = form.user_role.data
if form.email_confirmed.data and not self.email_confirmed:
self.email_confirmed = True
self.email_confirmed_on = datetime.now()
elif not form.email_confirmed.data and self.email_confirmed:
self.email_confirmed = False
self.email_confirmed_on = None
if form.new_password.data:
self.password = form.new_password.data
except KeyError as e:
raise ValidationError('Invalid user: missing ' + e.args[0])
return self
@hybrid_property
def password(self):
return self._password
@password.setter
def set_password(self, plaintext_password):
self._password = bcrypt.generate_password_hash(plaintext_password)
@hybrid_method
def is_correct_password(self, plaintext_password):
return bcrypt.check_password_hash(self.password, plaintext_password)
@property
def is_authenticated(self):
"""Return True if the user is authenticated."""
return self.authenticated
@property
def is_active(self):
"""Always True, as all users are active."""
return True
@property
def is_anonymous(self):
"""Always False, as anonymous users aren't supported."""
return False
def get_id(self):
"""Return the email address to satisfy Flask-Login's requirements."""
"""Requires use of Python 3"""
return str(self.id)
def generate_auth_token(self, expires_in=3600):
s = Serializer(app.config['SECRET_KEY'], expires_in=expires_in)
return s.dumps({'id': self.id}).decode('utf-8')
@staticmethod
def verify_auth_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
data = s.loads(token)
except:
return None
return User.query.get(data['id'])
def __repr__(self):
return '<User {}>'.format(self.email)
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String, unique=True, nullable=False)
password = db.Column(db.Binary(60), nullable=False)
authenticated = db.Column(db.Boolean, default=False) # online or not
confirmation_email_sent_date = db.Column(db.DateTime, nullable=True)
email_confirmed = db.Column(db.Boolean, nullable=True)
email_confirmation_date = db.Column(db.DateTime, nullable=True)
last_logged_in = db.Column(db.DateTime, nullable=True)
registration_date = db.Column(db.DateTime, nullable=True)
current_logged_in = db.Column(db.DateTime, nullable=True)
role = db.Column(db.String, default='user')
def __init__(self, email, pw, cesd=None):
self.email = email
# calls the setter
self.password_ = pw
self.authenticated = False
self.confirmation_email_sent_date = cesd
self.email_confirmed = False
self.email_confirmation_date = None
self.last_logged_in = None
self.current_logged_in = datetime.now()
def __repr__(self):
return '<User {}'.format(self.name)
# password encryption
@hybrid_property
def password_(self):
return self.password
@password_.setter
def password_(self, pw):
self.password = bcrypt.generate_password_hash(pw)
@hybrid_method
def is_correct_password(self, pw):
return bcrypt.check_password_hash(self.password_, pw)
# methods required for user login (flask_login module)
@property
def is_authenticated(self):
return self.authenticated
@property
def is_active(self):
"""
All users are active.
"""
return True
@property
def is_anonymous(self):
"""
Don't support anonymous users
"""
return False
def get_id(self):
return str(self.id)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String, unique=True, nullable=False)
_password = db.Column(db.Binary(60), nullable=False)
authenticated = db.Column(db.Boolean, default=False)
email_confirmation_sent_on = db.Column(db.DateTime, nullable=True)
email_confirmed = db.Column(db.Boolean, nullable=True, default=False)
email_confirmed_on = db.Column(db.DateTime, nullable=True)
registered_on = db.Column(db.DateTime, nullable=True)
last_logged_in = db.Column(db.DateTime, nullable=True)
current_logged_in = db.Column(db.DateTime, nullable=True)
username = db.Column(db.String, unique=True, nullable=False)
role = db.Column(db.String, default='user')
program = db.Column(db.String, nullable=False)
year = db.Column(db.Integer, nullable=False)
session = db.Column(db.String, nullable=False)
location = db.Column(db.String, nullable=False)
evaluations = db.relationship('Evaluation', backref='user', lazy='dynamic')
answers = db.relationship('Answer', backref='user', lazy='dynamic')
def __init__(self, email, plaintext_password, email_confirmation_sent_on=None, role='user',\
program='Team',year='2000',session='None',location='Silicon Valley'):
self.email = email
self.password = plaintext_password
self.authenticated = False
self.email_confirmation_sent_on = email_confirmation_sent_on
self.email_confirmed = False
self.email_confirmed_on = None
self.registered_on = datetime.now()
self.last_logged_in = None
self.current_logged_in = datetime.now()
self.username = email
self.role = role
self.program = program
self.year = year
self.session = session
self.location = location
@hybrid_property
def password(self):
return self._password
@password.setter
def set_password(self, plaintext_password):
self._password = bcrypt.generate_password_hash(plaintext_password)
@hybrid_method
def is_correct_password(self, plaintext_password):
return bcrypt.check_password_hash(self.password, plaintext_password)
@property
def is_authenticated(self):
"""Return True if the user is authenticated."""
return self.authenticated
@property
def is_active(self):
"""Always True, as all users are active."""
return True
@property
def is_anonymous(self):
"""Always False, as anonymous users aren't supported."""
return False
def get_id(self):
"""Return the email address to satisfy Flask-Login's requirements."""
"""Requires use of Python 3"""
return str(self.id)
