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)