class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50), unique=True)
email = db.Column(db.String(100), unique=True)
# set the backref = user.. so in Bookmark it can use the User class named user. Don't need to use user_id
bookmarks = db.relationship('Bookmark', backref='user', lazy='dynamic')
# this will stored the hashvalue for password
password_hash = db.Column(db.String)
# can only write not read, and this will not be stored in DB
@property
def password(self):
raise AttributeError('Password is write-only field')
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
@staticmethod
def get_by_username(username):
return User.query.filter_by(username=username).first()
def __repr__(self):
return '<User %r>' % self.username
@staticmethod
def get_by_userid(userid):
return User.query.get(int(userid))
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True)
email = db.Column(db.String(120), unique=True)
def __repr__(self):
return "<User '%r'>" % self.username
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True)
email = db.Column(db.String(120), unique=True)
bookmarks = db.relationship('Bookmark', backref='user', lazy='dynamic')
password_hash = db.Column(db.String(256))
@property
def password(self):
raise AttributeError(
'Password: Write Only Field. Check the models file if you are unsure'
)
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
@staticmethod
def get_by_username(username):
return User.query.filter_by(username=username).first()
# ToDo: Add a get_userid_by_user
def __repr__(self):
return '<User %r>' % self.username
class Bookmark(db.Model):
id_bookmark = db.Column(db.Integer, primary_key=True)
nm_url = db.Column(db.Text, nullable=False)
dt_bookmark = db.Column(db.DateTime, default=datetime.utcnow)
nm_description = db.Column(db.String(300))
id_user = db.Column(db.Integer,
db.ForeignKey('user.id_user'),
nullable=False)
_tags = db.relationship('Tag',
secondary=tags,
lazy='joined',
backref=db.backref('bookmarks', lazy='dynamic'))
@property
def tags(self):
return ','.join(tag.nm_tag for tag in self._tags)
@tags.setter
def tags(self, sTags):
if sTags:
self._tags = [Tag.get_or_create(t) for t in sTags.split(',')]
else:
self._tags = []
@staticmethod
def newest(num):
return Bookmark.query.order_by(desc(Bookmark.dt_bookmark)).limit(num)
def __repr__(self):
return "<Bookmark '{}': '{}'>".format(self.nm_description, self.nm_url)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True)
email = db.Column(db.String(120), unique=True)
bookmarks = db.relationship('Bookmark', backref='user', lazy='dynamic')
password_hash = db.Column(db.String)
#setting property so that the field can only be written into
@property
def password(self):
raise AttributeError('password: write-only field')
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
@staticmethod
def get_by_username(username):
return User.query.filter_by(username=username).first()
def __repr__(self):
return "<User {}>".format(self.username)
class Bookmark(db.Model):
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.Text, nullable=False)
date = db.Column(db.DateTime, default=datetime.utcnow)
description = db.Column(db.String(300))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
_tags = db.relationship('Tag',
secondary=tags,
lazy='joined',
backref=db.backref('bookmarks', lazy='dynamic'))
@staticmethod
def newest(num):
return Bookmark.query.order_by(desc(Bookmark.date)).limit(num)
@property
def tags(self):
return ",".join([t.name for t in self._tags])
@tags.setter
def tags(self, string):
if string:
self._tags = [
Tag.get_or_create(name) for name in string.split(',')
]
else:
self._tags = []
def __repr__(self):
return "<Bookmark '{}': '{}'>".format(self.description, self.url)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True)
email = db.Column(db.String(120), unique=True)
bookmarks = db.relationship('Bookmark', backref='user', lazy='dynamic')
password_hash = db.Column(db.String)
# Creates a property in the database that is write only and can't be
# accessed by the user, only the app
@property
def password(self):
raise AttributeError('password: write-only field')
# Creates the password hash and saves it to the passwordHash variable
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
# Hashes the users current login password and compares it against the
# hash in the database
def checkPassword(self, password):
return check_password_hash(self.password_hash, password)
@staticmethod
def getByUsername(username):
return User.query.filter_by(username=username).first()
@staticmethod
def getByEmail(email):
return User.query.filter_by(email=email).first()
def __repr__(self):
return "<User '{}'>".format(self.username)
class Tag(db.Model):
"""
tag model
"""
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(25), nullable=False, unique=True, index=True)
@staticmethod
def get_or_create(name):
"""
get or create tag
"""
try:
return Tag.query.filter_by(name=name).one()
except:
return Tag(name=name)
@staticmethod
def all():
"""
all tags
"""
return Tag.query.all()
def __repr__(self):
return self.name
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
user = db.Column(db.String(80), unique=True)
email = db.Column(db.String(80), unique=True)
bookmark = db.relationship('Bookmark', backref='User', lazy='dynamic')
def __repr__(self):
return "<Bookmark %r" % self.user
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True)
email = db.Column(db.String(120), unique=True)
bookmarks = db.relationship('Bookmark', backref='user', lazy='dynamic')
def __repr__(self):
return '<User %r>' % self.username
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True)
email = db.Column(db.String(120), unique=True)
bookmarks = db.relationship("Bookmark", backref="user", lazy="dynamic")
def __repr__(self):
return "<User '{}'>".format(self.username)
class Bookmark(db.Model):
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.Text, nullable=False)
date = db.Column(db.DateTime, default=datetime.utcnow)
description = db.Column(db.String, 300)
def __repr__(self):
return "<Bookmark '{}': '{}'".format(self.description, self.url)
class Bookmark(db.Model):
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db .Text, nullable=False)
date = db.Column(db.DateTime, default=datetime.utcnow)
description = db.Column(db.String(300))
@staticmethod
def newest(num):
return Bookmark.query.order_by(desc(Bookmark.date)).limit(num)
def __repr__(self):
return "<Bookmark '{}': '{}'>".format(self.description, self.url)
class User(db.Model, UserMixin):
"""
User ORM model
"""
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True)
email = db.Column(db.String(120), unique=True)
bookmarks = db.relationship('Bookmark', backref='user', lazy='dynamic')
password_hash = db.Column(db.String)
@property
def password(self):
"""
getter not implemented
"""
raise AttributeError('password: write-only filed')
@password.setter
def password(self, password):
"""
password setter
"""
self.password_hash = generate_password_hash(password)
def check_password(self, password):
"""
check password
"""
return check_password_hash(self.password_hash, password)
@staticmethod
def get_by_username(username):
"""
get by username
"""
return User.query.filter_by(username=username).first()
@staticmethod
def get_by_id(userid):
"""
get by id
"""
return User.query.get(int(userid))
@staticmethod
def get_by_email(email):
"""
get by email
"""
return User.query.filter_by(email=email).first()
def __repr__(self):
return "{}".format(self.username)
class Tag(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(25), unique=True, nullable=False, index=True)
@staticmethod
def get_or_create(name):
try:
return Tag.query.filter_by(name=name).one()
except:
return Tag(name=name)
def __repr__(self):
return f'{self.name}'
class Bookmark(db.Model):
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.Text, nullable=False)
date = db.Column(db.DateTime, default=datetime.utcnow)
description = db.Column(db.String(3000))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
@staticmethod
def newest(num):
return Bookmark.query.order_by(desc(Bookmark.date)).limit(num)
def __repr__(self):
return '<Url %r>' % self.url
class Bookmark(db.Model):
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.Text, nullable=False)
date = db.Column(db.DateTime, default=datetime.utcnow)
description = db.Column(db.String(300))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
# Set the relationship with the Tag class, need to use a string as it's not defined until later. ToDo: Move it up
# and replace it with the class name for future proofing. The second argument to the relationship call is the
# argument 'secondary' which tells the relationship to use our junction table called "tags" above. We also defined
# a backref called 'bookmarks' which will add an attribute called bookmarks to the other side of the relationship.
# So each tag will get a bookmarks attribute containing a list of the associated bookmarks. Dynamic loading in case
# there are a large number of bookmarks associated with each tag.
# Underscore as I don't want to access this directly from other classes.
_tags = db.relationship('Tag',
secondary=tags,
lazy='joined',
backref=db.backref('bookmarks', lazy='dynamic'))
@staticmethod
def newest(num):
return Bookmark.query.order_by(desc(Bookmark.date)).limit(num)
# In the view and the form, we handle the list of tags as a comma separated string. So it's convenient to create a
# tag property that provides a list of strings as well. The getter takes the contents of the _tags list which holds
# actual Tag model objects. Then it takes the name from each and joins it into a string. So when we ask for the
# value of the tags property on a bookmark, we get a string, with a list of tag names.
@property
def tags(self):
return ",".join([t.name for t in self._tags])
# When we pass a string with a list of tags to be set to this property, we need to find out for each of those tags
# whether it already exists in the database. If it doesn't, we need to insert a new tag into the tag table and then
# add the new model object to the tag list for this bookmark. If it does exist, we can simply retrieve it and put it
# in the list. So if it exists, we create a new method get_or_create that takes the name of a tag and returns a tag
# model instance by either creating or retrieving a tag with that name. We then do a for loop over all the words in
# the string we received and then call the method on each of those words. The resulting list is a list of tag model
# objects and we can assign that to the _tags attribute. Assigning a list of tag objects is all we have to do and
# SQLAlchemy will take it from there and create all the relevant rows in the database.
@tags.setter
def tags(self, string):
# Check if the tags are a string
if string:
self._tags = [
Tag.get_or_create(name) for name in string.split(',')
]
# If not, set the list ot an empty list, otherwise, it will always fail the test.
else:
self._tags = []
def __repr__(self):
return "Bookmark '{}': '{}'>".format(self.description, self.url)
class Bookmark(db.Model):
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.Text, nullable=False)
date = db.Column(db.DateTime, default=datetime.utcnow)
description = db.Column(db.String(300))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
@staticmethod
def getRecentBookmarks(num):
return Bookmark.query.order_by(desc(Bookmark.date)).limit(num)
@staticmethod
def getAllBookmarks(user):
return Bookmark.query.filter_by(user_id=user.id).all()
def __repr__(self):
return "<Bookmark '{}': '{}'>".format(self.url, self.description)
class Tag(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(25), nullable=False, unique=True, index=True)
@classmethod
def get_or_create(cls, name):
try:
return cls.query.filter_by(name=name).one()
except NoResultFound as exc:
print("Tag {} is not found in database. Creating new tag.".format(name))
return cls(name=name)
except Exception as exc:
template = "An exception of type {0} occurred. Arguments:\n{1!r}"
message = template.format(type(exc).__name__, exc.args)
print(message)
raise exc
def __repr__(self):
return self.name
class Tag(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), nullable=False, unique=True, index=True)
# Get_or_create uses a Try statement to retrieve a tag with a given name. If that throws an exception (tag doesn't
# exist), we create a new tag and return that. So this way, we can convert strings to tags and back.
# ToDo: Fix Exception warning
@staticmethod
def get_or_create(name):
try:
return Tag.query.filter_by(name=name).one()
except:
return Tag(name=name)
# To use with the context processor all_tags() method, allowing all tags to accessible from all template contexts.
@staticmethod
def all():
return Tag.query.all()
def __repr__(self):
return self.name
class Bookmark(db.Model):
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.Text, nullable=False)
date = db.Column(db.DateTime, default=datetime.utcnow)
description = db.Column(db.String(300))
bkmrkusername = db.Column(db.String(400))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
_tags = db.relationship("Tag", secondary=tags, backref=db.backref("bookmarks", lazy="dynamic"))
@property
def tags(self):
return ",".join([t.name for t in self._tags])
@tags.setter
def tags(self, string):
if string:
self._tags = [Tag.get_or_create(name) for name in string.split(",")]
@classmethod
def newbookmarks(cls, num):
return cls.query.filter_by(user=current_user).order_by(desc(cls.date)).limit(num)
def __repr__(self):
return "<Bookmark '{}': '{}'>".format(self.url, self.description)
class Tag(db.Model):
id_tag = db.Column(db.Integer, primary_key=True)
nm_tag = db.Column(db.String(25), nullable=False, unique=True, index=True)
@staticmethod
def get_or_create(nm_tag):
try:
return Tag.query.filter_by(nm_tag=nm_tag).one()
except:
return Tag(nm_tag=nm_tag)
@staticmethod
def all():
return Tag.query.all()
@staticmethod
def get_by_name(name, site=False):
if (site):
return Tag.query.filter_by(nm_tag=name).first_or_404()
else:
return Tag.query.filter_by(nm_tag=name).first()
def __repr__(self):
return self.nm_tag
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50), unique=True)
email = db.Column(db.String(120), unique=True)
password_hash = db.Column(db.String, nullable=False)
bookmarks = db.relationship('Bookmark', backref="user", lazy="dynamic")
def __repr__(self):
return "<User {}>".format(self.username)
@property
def password(self):
raise AttributeError("Password write-only field")
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def _checkpassword(self, password):
return check_password_hash(self.password_hash, password=password)
@classmethod
def getuserbyusername(cls, username):
return cls.query.filter_by(username=username).first()
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True)
email = db.Column(db.String(300), unique=True)
bookmarks = db.relationship('Bookmark', backref='user', lazy='dynamic')
password_hash = db.Column(db.String)
@property
def password(self):
raise ArithmeticError('password : write-only-field')
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
@staticmethod
def get_by_username(username):
return User.query.filter_by(username=username).first()
def __repr__(self):
return '<User %r>' % self.username
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True)
email = db.Column(db.String(120), unique=True)
bookmarks = db.relationship("Bookmark", backref="user", lazy="dynamic")
password_hash = db.Column(db.String)
@property
def password(self):
raise AttributeError("password: write-only field")
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
@staticmethod
def get_by_username(username):
return User.query.filter_by(username=username).first()
def __repr__(self):
return "<User '{}'>".format(self.username)
class User(db.Model, UserMixin):
id_user = db.Column(db.Integer, primary_key=True)
nm_firstName = db.Column(db.String(120), nullable=False)
nm_lastName = db.Column(db.String(120), nullable=False)
nm_userName = db.Column(db.String(80), unique=True)
nm_passwordHash = db.Column(db.String)
nm_email = db.Column(db.String(120), unique=True)
bookmarks = db.relationship('Bookmark', backref='user', lazy='dynamic')
def get_id(self):
'''Overrride method from UserMixin'''
try:
return self.id_user
except AttributeError:
raise NotImplementedError('No `id` attribute - override `get_id`')
@property
def password(self):
raise AttributeError('password: write-only field')
@password.setter
def password(self, password):
self.nm_passwordHash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.nm_passwordHash, password)
@staticmethod
def get_by_username(username, site=False):
if (site):
return User.query.filter_by(nm_userName=username).first_or_404()
else:
return User.query.filter_by(nm_userName=username).first()
@staticmethod
def get_by_email(email):
return User.query.filter_by(nm_email=email).first()
@staticmethod
def get_by_id(userid):
return User.query.get(userid)
def __repr__(self):
return '<User %r>' % self.nm_userName
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(30), unique=True)
email = db.Column(db.String(300), unique=True)
class Bookmark(db.Model):
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.Text, nullable=False)
date = db.Column(db.DateTime, default=datetime.utcnow)
description = db.Column(db.String(300))
from datetime import datetime
from sqlalchemy import desc
from flask_login import UserMixin
from werkzeug.security import check_password_hash, generate_password_hash
from thermos import db
tags = db.Table(
"bookmark_tag",
db.Column("tag_id", db.Integer, db.ForeignKey("tag.id")),
db.Column("bookmark_id", db.Integer, db.ForeignKey("bookmark.id")),
)
class Bookmark(db.Model):
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.Text, nullable=False)
date = db.Column(db.DateTime, default=datetime.utcnow)
description = db.Column(db.String(300))
user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
_tags = db.relationship(
"Tag",
secondary=tags,
lazy="joined",
backref=db.backref("bookmarks", lazy="dynamic"),
)
@staticmethod
def newest(num):
return Bookmark.query.order_by(desc(Bookmark.date)).limit(num)
from datetime import datetime
from flask_login import UserMixin
from sqlalchemy import desc
from werkzeug.security import generate_password_hash, check_password_hash
from thermos import db
tags = db.Table(
'bookmark_tag', db.Column('tag_id', db.Integer, db.ForeignKey('tag.id')),
db.Column('bookmark_id', db.Integer, db.ForeignKey('bookmark.id')))
class Bookmark(db.Model):
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.Text, nullable=False)
date = db.Column(db.DateTime, default=datetime.utcnow)
description = db.Column(db.String(300))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
_tags = db.relationship('Tag',
secondary=tags,
lazy='joined',
backref=db.backref('bookmarks', lazy='dynamic'))
@staticmethod
def newest(num):
return Bookmark.query.order_by(desc(Bookmark.date)).limit(num)
@property
def tags(self):
return ",".join([t.name for t in self._tags])
