class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(255), unique=True)
pw_hash = db.Column(db.String(255), unique=True)
todos = relationship('Todo')
def __init__(self, username, password):
self.username = username
self.set_password(password)
def get_security_payload(self):
return {'id': self.id, 'username': self.username}
@property
def jsonified(self):
return jsonify(id=self.id, username=self.username)
def set_password(self, password):
self.pw_hash = generate_password_hash(
password, method=app.config['PASSWORD_HASH_METHOD'])
def check_password(self, password):
return check_password_hash(self.pw_hash, password)
class Users(db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(255),index=True,unique=True,nullable=False) password = db.Column(db.String(255),nullable=False) def __repr__(self): return '<Users %r>' % (self.username)
class users(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(255), nullable=False)
password = db.Column(db.String(255), nullable=False)
def __repr__(self):
return '<user {}>'.format(self.username)
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(255), index=True, unique=True)
password = db.Column(db.String(255))
todos = db.relationship('Todo', backref='owner', lazy='dynamic')
def __repr__(self):
return '<User {}>'.format(self.username)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
password = db.Column(db.String(80), nullable=False)
todos = db.relationship('Todo', backref='user', lazy=True)
def __repr__(self):
return '<User %r>' % self.username
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(255), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
def __repr__(self):
return '<User %r>' % self.username
class Users(db.Model):
__tablename__ = "users"
id = db.Column('id',
db.Integer,
unique=True,
nullable=False,
primary_key=True)
username = db.Column(db.String(255), nullable=False)
password = db.Column(db.String(255), nullable=False)
def as_dict(self):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True)
password = db.Column(db.String(80))
def __init__(self, username, password):
self.username = username
self.password = password
def __repr__(self):
return '<User %r>' % self.username
class Users(db.Model):
__tablename__ = 'user'
id = db.Column('user_id', db.Integer, primary_key=True)
password = db.Column('password', db.String(255), nullable=False)
username = db.Column('username', db.String(25), nullable=False)
def serialize(self):
return {
'id': self.id,
}
def __repr__(self):
return '<User %r>' % self.id
class Users(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(255), nullable=False)
password = db.Column(db.String(255), nullable=False)
def __repr__(self):
return '<Users {}>'.format(self.username)
def to_dict_unsensitive(self):
return {'id': self.id, 'username': self.username}
def validate_password(self, password):
return bcrypt.verify(password, self.password)
class Users(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(255), nullable=False)
password = db.Column(db.String(255), nullable=False)
def to_dict(self):
return {
'id': self.id,
'username': self.username,
'password': self.password
}
class Todos(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
description = db.Column(db.String(255), nullable=False)
status = db.Column(db.String(255), nullable=False)
def __repr__(self):
return {
'id': self.id,
'user_id': self.user_id,
'description': self.description,
'status': self.status
}
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
password = db.Column(db.String(128))
def __repr__(self):
return '<User id={},username={}>'.format(self.id, self.username)
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(255), nullable=False)
password = db.Column(db.String(255))
def __repr__(self):
return '<User {}>'.format(self.username)
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
class Users(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(64), index=True, unique=True)
password = db.Column(db.String(128))
todos = db.relationship('Todos', backref='users', lazy=True)
def set_pass(self, password):
self.password = generate_password_hash(password)
def check_pass(self, password):
return check_password_hash(self.password, password)
def __repr__(self):
return {'id': self.id, 'username': self.username}
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(255), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
def __init__(self, username: str, password: str) -> None:
self.username = username
self.password = password
@classmethod
def get(cls, username: str) -> object:
return cls.query.filter_by(username=username).first()
def hash_password(self) -> str:
"""
Hashes a plaintext password using SHA256 with a randomly generated salt
Not called in our code as we do not create users, but shows how the hashing is done.
ref:
https://www.vitoshacademy.com/hashing-passwords-in-python/
"""
salt = hashlib.sha256(os.urandom(60)).hexdigest().encode('ascii')
pwdhash = hashlib.pbkdf2_hmac('sha512',
self.password.encode('utf-8'),
salt,
100000
)
pwdhash = binascii.hexlify(pwdhash)
return (salt + pwdhash).decode('ascii')
def verify(self, provided_password: str) -> bool:
"""
Verifies a user login by comparing the provided password with the stored one using cool hashing algos.
:param provided_password: plaintext password provided in login form
:return: True if provided_password matches the hashed stored password
"""
salt = self.password[:64]
stored_password = self.password[64:]
pwdhash = hashlib.pbkdf2_hmac('sha512',
provided_password.encode('utf-8'),
salt.encode('ascii'),
100000
)
pwdhash = binascii.hexlify(pwdhash).decode('ascii')
return pwdhash == stored_password
def __repr__(self) -> str:
return '<User %r>' % self.username
class User(db.Model, UserMixin):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
todos = db.relationship('Todo', backref='user', lazy=True)
def __repr__(self):
return f"User('{self.username}')"
def set_password(self, password):
self.password = bcrypt.generate_password_hash(password).decode('utf8')
def check_password(self, password):
return bcrypt.check_password_hash(self.password, password)
class Todo(db.Model):
__tablename__ = 'todos'
id = db.Column(db.Integer, primary_key=True)
description = db.Column(db.String(300))
completed = db.Column(db.Boolean)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship('User',
backref=db.backref('todos', lazy='dynamic'))
def __init__(self, description, user):
self.description = description
self.user = user
@db.validates('description')
def validate_description(self, key, description):
if not description:
raise ValueError('Description cannot be empty')
return description
def as_dict(self):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
def __repr__(self):
return '<Todo %r>' % self.description
class Todo(db.Model):
__tablename__ = 'todos'
id = db.Column(db.Integer, primary_key=True)
description = db.Column(db.String(255), nullable=False)
completed = db.Column(db.Boolean, default=False, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
def __init__(self, user_id: str, description: str) -> None:
self.user_id = user_id
self.description = description
@classmethod
def get(cls, id: int) -> object:
return cls.query.filter_by(id=id).first()
@classmethod
def add(cls, user_id: str, description: str) -> None:
todo = cls(user_id, description)
db.session.add(todo)
db.session.commit()
@classmethod
def delete(cls, id: int) -> None:
todo = cls.get(id)
db.session.delete(todo)
db.session.commit()
@classmethod
def toggle_completion(cls, id: int) -> None:
todo = cls.get(id)
todo.completed = not todo.completed
db.session.commit()
@classmethod
def paginate(cls, user_id: int, page: int) -> Pagination:
"""
Uses SQLAlchemy's builtin pagination tools to return paginated queries
:param user_id: specifies the user who's tasks are to be gotten
:param page: target page number
:return: flask_sqlalchemy.Pagination object for use in views
"""
return cls.query.filter_by(user_id=user_id).paginate(
page=page,
per_page=app.config.get('PAGE_ITEM_LIMIT', 5),
error_out=False)
def to_dict(self) -> dict:
return {
'id': self.id,
'description': self.description,
'completed': self.completed,
'user_id': self.user_id
}
def json(self) -> str:
return jsonify(self.to_dict())
def __repr__(self) -> str:
return '<Todo %r>' % self.description
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(255), nullable=False)
password = db.Column(db.String(255), nullable=False)
todos = db.relationship("Todo", backref="users", order_by="Todo.id")
def __repr__(self):
return '<User %r>' % self.username
def get_dict(self):
return {
'id': self.id,
'username': self.username,
'password': self.password
}
class Todos(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
description = db.Column(db.String(255),nullable=False)
is_completed = db.Column(db.Boolean, unique=False, default=False)
def __repr__(self):
return '<Todos %r>' % (self.description)
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(255), nullable=False)
password = db.Column(db.String(255), nullable=False)
def __init__(self, email, username, password):
self.email = email
self.username = username
self.password = bcrypt.hashpw(password.encode('utf-8'),
bcrypt.gensalt())
def check_password(self, password):
return flask_bcrypt.check_password_hash(self.password, password)
def __repr__(self):
return "UserName: {username}".format(username=self.username)
class Todo(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
description = db.Column(db.String(255))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
completed = db.Column(db.Boolean, default=False)
def __repr__(self):
return '<Todo #{}>'.format(self.id)
class todos(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
description = db.Column(db.String(255))
completed = db.Column(db.Boolean)
def __repr__(self):
return '<todo {}>'.format(self.description)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(255), nullable=False, unique=True)
password = db.Column(db.String(255))
todos = db.relationship('Todo', backref='user', lazy=True)
def __init__(self, username, password):
self.username = username
self.password = password
def __repr__(self):
return '<User {}>' % self.username
def set_password(self, password):
self.password = bcrypt.generate_password_hash(password)
def check_password(self, candidate):
return bcrypt.check_password_hash(self.password, candidate)
class Todo(db.Model):
__tablename__ = "todos"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, nullable=False)
description = db.Column(db.String(255))
completed = db.Column(db.Integer)
def __repr__(self):
return '<Todo %r>' % self.description
class Todos(db.Model):
__tablename__ = "todos"
id = db.Column('id',
db.Integer,
unique=True,
nullable=False,
primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
description = db.Column(db.String(255))
completed = db.Column(db.Boolean, default=False)
def as_dict(self):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
class Todo(db.Model):
id = db.Column(db.Integer, primary_key=True)
description = db.Column(db.String(140))
completed = db.Column(db.Boolean, default=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
def __init__(self, description, user_id, completed=False):
self.description = description
self.completed = completed
self.user_id = user_id
def __repr__(self):
return '<Todo desc={},completed={}>'.format(self.description,
self.completed)
class Todos(db.Model):
__tablename__ = 'todos'
id = db.Column('todo_id', db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey(Users.id), nullable=False)
description = db.Column(db.String(255), nullable=False)
done = db.Column(db.Boolean)
def serialize(self):
return {
'id': self.id,
'users': self.user_id,
'description': self.description,
'done': self.done
}
class Todo(db.Model):
__tablename__ = 'todos'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
description = db.Column(db.String(255), nullable=False)
completed = db.Column(db.Boolean, default=0)
def __init__(self, user_id, description, completed):
self.user_id = user_id
self.description = description
self.completed = completed
def __repr__(self):
return '<Todo: id=%r, completed=%r>' % (self.description,
self.completed)
