class User(flask_login.UserMixin, db.Model): id = db.Column(db.Integer(), primary_key=True) name = db.Column(db.String(32), unique=True) email = db.Column(db.String(128), unique=True) profile_pic_path = db.Column(db.String(), default="Fake -- Dont touch me") pp_path = db.Column(db.String(256), default='/static/uploads/default.png') password_hash = db.Column(db.String(256)) last_seen = db.Column(db.DateTime(), default=datetime.datetime.now()) posts = db.relationship('Post', backref="author") followed = db.relationship('User', secondary=followers, primaryjoin=(followers.c.follower_id == id), secondaryjoin=(followers.c.followed_id == id), backref=db.backref('followers', lazy='dynamic'), lazy='dynamic') def has_posts(self): return len(self.posts) > 0 def follows(self, user_id): user = self.followed.filter_by(id=user_id).first() if not user: return False return True def __repr__(self): return "<User {}>".format(self.name)
class User(UserMixin, db.Model): """Model to store blog's user related information.""" __tablename__ = "user" id = db.Column(db.Integer, primary_key=True, autoincrement=True) username = db.Column(db.String(32), nullable=False, unique=True) password_hash = db.Column(db.String(256), nullable=False) posts = db.relationship("Post", backref="user") comments = db.relationship("Comment", backref="user") liked_posts = db.relationship("Post", secondary=likes, backref="liked_by", lazy="dynamic") saved_posts = db.relationship( "Post", secondary=saves, backref="saved_by", lazy="dynamic", ) def set_password(self, password): """Create hashed password.""" self.password_hash = generate_password_hash(password, method="sha256") def check_password(self, password): """Check hashed password.""" return check_password_hash(self.password_hash, password)
class Post(db.Model): __tablename__ = 'posts' id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(128), nullable=False) body = db.Column(db.Text) created_at = db.Column(db.DateTime, server_default=db.func.now()) updated_at = db.Column(db.DateTime, server_default=db.func.now(), server_onupdate=db.func.now()) user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False) comments = db.relationship('Comment', backref='belong_to_post', lazy=True) add_category = db.relationship('Category', secondary=post_category, lazy='subquery', backref=db.backref('list_post', lazy=True)) def __init__(self, title, body, user_id): self.title = title self.body = body self.user_id = user_id def __repr__(self): return (f'This post has title {self.title}')
class AddProduct(db.Model): id=db.Column(db.Integer,primary_key=True) name=db.Column(db.String(80),nullable=False) price=db.Column(db.Integer,nullable=False) discount=db.Column(db.Integer,default=0) stock=db.Column(db.Integer,nullable=False) desc=db.Column(db.Text,nullable=False) brand_id=db.Column(db.Integer,db.ForeignKey('brand.id')) brand=db.relationship('Brand',backref=db.backref('brands',lazy=True)) category_id=db.Column(db.Integer,db.ForeignKey('category.id')) category=db.relationship('Category',backref=db.backref('categories',lazy=True)) buy_id=db.Column(db.Integer,db.ForeignKey('buy.id')) buy=db.relationship('Buy',backref=db.backref('buys',lazy=True)) colors=db.Column(db.String(80),nullable=False) date=db.Column(db.DateTime,nullable=False,default=datetime.utcnow) image1=db.Column(db.String(150),nullable=False,default='image.jpg') image2=db.Column(db.String(150),nullable=False,default='image.jpg') image3=db.Column(db.String(150),nullable=False,default='image.jpg') def __repr__(self): return f"AddProduct('{self.name}','{self.price}')"
class User(UserMixin, db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(100)) email = db.Column(db.String(255), unique=True, index=True, nullable=False) bio = db.Column(db.String(255)) profile_pic_path = db.Column(db.String()) password_hash = db.Column(db.String(255)) role_id = db.Column(db.Integer, db.ForeignKey('roles.id')) blogs = db.relationship('Blog', backref='user', lazy='dynamic') comments = db.relationship('Comment', backref='user', lazy='dynamic') @property def password(self): raise AttributeError('You cannot read the password attritube') @password.setter def password(self, password): self.password_hash = generate_password_hash(password) def verify_password(self, password): return check_password_hash(self.password_hash, password) def __repr__(self): return f'User {self.username}'
class User(UserMixin, db.Model): __tablename__ = 'user' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(50), nullable=False, unique=True) email = db.Column(db.String(50), nullable=False, unique=True) password = db.Column(db.String(500), nullable=False) firstname = db.Column(db.String(50), default='Firstname') lastname = db.Column(db.String(50), default='Lastname') city = db.Column(db.String(50), default='Moscow') birthdate = db.Column(db.String(50), nullable=True, default='1990-01-01') gender = db.Column(db.String(50), default='Male') is_confirmed = db.Column(db.Boolean, nullable=False, default=False) registration_date = db.Column(db.DateTime, nullable=True) userpic = db.Column(db.String(30), default='default.jpg') followers_qty = db.Column(db.Integer, default=0) posts = db.relationship('Post', backref='user', cascade="all, delete", lazy='dynamic') likes = db.relationship('Like', backref='user', cascade="all, delete", lazy='dynamic') @staticmethod def ensure_unique_username(name): """Ensure user name does not already exist""" if User.query.filter_by(name=name).first() is None: return name version = 1 while True: old_name = name new_name = name + '_' + str(version) if User.query.filter_by(name=new_name).first() is None: break version += 1 # flash('Your name has been changed to {} as user {} already exists.'.format(new_name, old_name), 'success') return new_name def __str__(self): return 'User {}'.format(self.username) def all_users(): return User.query.all() def get_user_by_username(username): return User.query.filter_by(username=username).first() def all_followers(id): return User.query.join( followers, (User.id == followers.c.follower_id)).filter_by(user_id=id).all() def all_followed_by_user(id): return User.query.join( followers, (User.id == followers.c.user_id)).filter_by(follower_id=id).all()
class User(flask_login.UserMixin, db.Model): id = db.Column(db.Integer(), primary_key=True) name = db.Column(db.String(32)) password_hash = db.Column(db.String(256)) last_seen = db.Column(db.DateTime(), default=datetime.datetime.now()) posts = db.relationship('Post', backref="author") followed = db.relationship('User', secondary=followers, primaryjoin=(followers.c.follower_id == id), secondaryjoin=(followers.c.followed_id == id), backref=db.backref('followers', lazy='dynamic'), lazy='dynamic') def has_posts(self): return len(self.posts) > 0 def follows(self, user_id): user = self.followed.filter_by(id=user_id).first() print("user id: {} {}".format(user_id, type(user_id))) print("Followed ids") for follower in self.followed: print(follower.id, type(follower.id)) if not user: print("I am false") return False print("I am True") return True def __repr__(self): return "<User {}>".format(self.name)
class Article(db.Model): __tablename__ = 'article' __bind_key__ = 'blog2' id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(100)) body = db.Column(db.Text) description = db.Column(db.String(500)) body_html = db.Column(db.Text) visited = db.Column(db.Integer, default=0) photo = db.Column(db.String(100)) create_date = db.Column(db.DateTime, default=datetime.now) create_user_id = db.Column(db.Integer, db.ForeignKey('user.id')) catalog_id = db.Column(db.Integer, db.ForeignKey('catalog.id')) recommand = db.Column(db.String(1)) hidden = db.Column(db.Integer) order_id = db.Column(db.Integer, default=0) create_user = db.relationship('User', backref='create_user', foreign_keys=create_user_id) catalogs = db.relationship('Catalog', backref='catalogs', foreign_keys=catalog_id) tags = db.relationship('Tag', secondary=articles_tags, backref='tags') def __repr__(self): return '<Article %r>' % self.title @staticmethod def on_body_changed(target, value, oldvalue, initiator): if value is None or value == '': target.body_html = '' else: target.body_html = markdown(value)
class Users(UserMixin, db.Model): userId = db.Column(db.Integer, primary_key=True) firstName = db.Column(db.String(40), nullable=False) lastName = db.Column(db.String(40), nullable=False) email = db.Column(db.String(255), nullable=False, unique=True) userName = db.Column(db.String(40), nullable=False, unique=True) passwordHash = db.Column(db.String(128), nullable=False) comment = db.relationship('Comments', backref='user', lazy=True) ratings = db.relationship('Ratings', backref='user', lazy=True) taggings = db.relationship('Taggings', backref='user', lazy=True) def __repr__(self): return f"User('{self.username}', '{self.email}')" def get_id(self): return self.userId @property def password(self): raise AttributeError('password is not a readable attribute') @password.setter def password(self, password): self.passwordHash = generate_password_hash(password) def verify_password(self, password): return check_password_hash(self.passwordHash, password) @login_manager.user_loader def load_user(user_id): return Users.query.get(int(user_id))
class User(UserMixin, db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(15), unique=True, nullable=False) email = db.Column(db.String(120), unique=True, nullable=False) password_hash = db.Column(db.String(128)) password = db.Column(db.String(60), nullable=False) post = db.relationship('Post', backref='user', lazy=True) comment=db.relationship('Comment',backref='user',lazy=True) like=db.relationship('Like',backref='user',lazy=True) tag=db.relationship('Tag',backref='user',lazy=True) first_name = db.Column(db.String(80)) last_name = db.Column(db.String(80)) mobile_phone = db.Column(db.String(11)) is_admin = db.Column(db.Boolean, nullable=False, default=False) def __repr__(self): return f"User('{self.username}', '{self.email}')" @property def password(self): raise AttributeError('Password is not a readable attribute.') @password.setter def password(self, password): self.password_hash = generate_password_hash(password) def verify_password(self, password): return check_password_hash(self.password_hash,password)
class User(UserMixin, db.Model): __tablename__ = 'user' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(32), unique=True) email = db.Column(db.String(64), unique=True, nullable=False) password_hash = db.Column(db.String(256)) favorite = db.relationship('Post', secondary=user_favorite_post, lazy='subquery', backref=db.backref('list_favorite_user', lazy=True)) posts = db.relationship('Post', backref='author', lazy='dynamic') comments = db.relationship('Comment', backref='author', lazy=True) def __init__(self, email): self.email = email def is_already_favorite(self, post_id): return post_id in self.favorite def set_password(self, password): self.password_hash = generate_password_hash(password) def check_password(self, password): return check_password_hash(self.password_hash, password)
class User(UserMixin, db.Model): id = db.Column(db.Integer, primary_key=True) access_level = db.Column(db.Integer) username = db.Column(db.String(64), index=True, unique=True) password = db.Column(db.String(128)) fullname = db.Column(db.String(128), index=True) email = db.Column(db.String(120), index=True, unique=True) phone_number = db.Column(db.String(10), index=True, unique=True) homeworks = db.relationship("HomeWork", backref="author", lazy="dynamic") solutions = db.relationship("Solution", backref="author", lazy="dynamic") messages_sent = db.relationship("Message", foreign_keys="Message.sender_id", backref="author", lazy="dynamic") messages_received = db.relationship("Message", foreign_keys="Message.recipent_id", backref="recipient", lazy="dynamic") last_message_read_time = db.Column(db.DateTime) def __repr__(self): return "<User {}>".format(self.username) def check_password(self, password): return self.password == password def is_teacher(self): return self.access_level == 1 def new_messages(self): last_read_time = self.last_message_read_time or datetime(1900, 1, 1) return Message.query.filter_by(recipient=self).filter( Message.timestamp > last_read_time).count()
class Segue(db.Model): __tablename__ = "segue" id = db.Column(db.Integer, primary_key=True) id_usuario = db.Column(db.Integer, ForeignKey('usuarios.id')) id_seguidor = db.Column(db.Integer, ForeignKey('usuarios.id')) usuario = db.relationship('Usuario', foreign_keys=id_usuario) seguidor = db.relationship('Usuario', foreign_keys=id_seguidor)
class Comment(db.Model, CRUDMixin, Serializer): __tablename__ = 'comments' id = db.Column(db.Integer, primary_key=True) body = db.Column(db.String(1000)) body_html = db.Column(db.Text) timestamp = db.Column(db.DateTime, default=lambda: datetime.utcnow()) disabled = db.Column(db.Boolean, default=False) author_id = db.Column(db.Integer, db.ForeignKey('users.id')) post_id = db.Column(db.Integer, db.ForeignKey('posts.id')) replied = db.relationship('Reply', foreign_keys=[Reply.reply_id], backref=db.backref('replies', lazy='joined'), lazy='dynamic', cascade='all, delete-orphan') replies = db.relationship('Reply', foreign_keys=[Reply.replied_id], backref=db.backref('replied', lazy='joined'), lazy='dynamic', cascade='all, delete-orphan') def __repr__(self): return str(self.json()).replace(',', '\n') def reply(self, comment): reply = Reply(replies=self, replied=comment) db.session.add(reply) db.session.commit() @staticmethod def on_change_body(target, value, oldvalue, initiator): allowed_tags = [ 'a', 'abbr', 'acronym', 'b', 'code', 'em', 'i', 'blockquote' 'strong', 'ol', 'li', 'ul', 'p', 'span', 'img', 'pre', 's' ] allowed_styles = ['background-color'] allowed_attributes = { 'a': ['href', 'title'], 'abbr': ['title'], 'acronym': ['title'], 'pre': ['class', 'spellcheck'] } target.body_html = bleach.linkify( bleach.clean(markdown(value, output_format='html'), tags=allowed_tags, strip=True, styles=allowed_styles, attributes=allowed_attributes)) def to_json(self): json_data = { 'body_html': self.body_html, 'timestamp': self.timestamp.strftime('%Y-%m-%d %H:%M:%S'), 'author': self.author.username, 'avatar': self.author.avatar, 'uid': self.author_id, 'id': self.id } return json_data
class User(db.Model, UserMixin): 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) posts = db.relationship('Post', backref='author', lazy=True) replies = db.relationship('Reply', backref='writer', lazy=True) def __repr__(self): return f"Username: {self.username}, Email: {self.email}"
class Post(db.Model): id = db.Column(db.Integer, primary_key = True) title = db.Column(db.String(200), nullable = False) content = db.Column(db.Text, nullable = False) date_posted = db.Column(db.DateTime, nullable = False, default = datetime.utcnow) photos = db.relationship('Photo', backref = 'post', lazy = "dynamic") comments = db.relationship('Comments', backref = 'post', lazy = True) def __repr__(self): return f"Post('{self.id}','{self.title}','{self.date_posted}')"
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(20), unique=True, nullable=False) email = db.Column(db.String(120), unique=True, nullable=False) image_file = db.Column(db.String(20), nullable=False, default='default.jpg') password = db.Column(db.String(60), nullable=False) posts = db.relationship('Post', backref='user', lazy=True) comments = db.relationship('Comment', backref='user', lazy=True)
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(20), unique=True, nullable=False) email = db.Column(db.String(120), unique=True, nullable=False) image_file = db.Column(db.String(20), nullable=False, default="default.jpg") password = db.Column(db.String(60), nullable=False) posts = db.relationship('Post', backref='author', lazy=True) comments = db.relationship('Comment', backref='commenter', lazy=True) def __repr__(self): return f"User {self.username}, {self.email}"
class Post(db.Model): id = db.Column(db.Integer, primary_key=True) date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow) title = db.Column(db.Text, nullable=False) content = db.Column(db.Text, nullable=False) image_file = db.Column(db.String(40), nullable=False, default='default.jpg') author_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False) likes=db.Column(db.Integer, nullable=False, default=0) comment=db.relationship('Comment',backref='post',lazy=True) like=db.relationship('Like',backref='post',lazy=True) tag=db.relationship('Tag',backref='post',lazy=True) def __repr__(self): return f"Post('{self.date}', '{self.title}', '{self.content}')"
class Post(db.Model): id = db.Column(db.Integer, primary_key=True) date_posted = db.Column(db.DateTime(), nullable=False, default=datetime.utcnow) user_id = db.Column(db.Integer, db.ForeignKey('user.id')) pokemons = db.relationship('Pokemon', backref='post', lazy='dynamic') wins = db.Column(db.Integer, default=0) loses = db.Column(db.Integer, default=0) likes = db.relationship('PostLike', backref='post', lazy='dynamic') comments = db.relationship('Comment', backref='post', lazy='dynamic') def __repr__(self): return f"Post('{self.pokemons}', '{self.date_posted}', '{self.likes.count()}')"
class Comment(db.Model): """""" id = db.Column(db.Integer, primary_key=True) author_id = db.Column(db.ForeignKey(User.uid), nullable=False) parent = db.Column(db.ForeignKey(Post.id), nullable=False) comment = db.Column(db.TEXT(8388608), nullable=False) created_at = db.Column(db.DateTime, nullable=False, default=datetime.utcnow) post_author = db.relationship(User, lazy="joined", backref="comments") parent_post = db.relationship(Post, lazy="joined", backref="comments") def __repr__(self): return "<Comment {0}> <User {1}>".format(self.id, self.author_id)
class Author(db.Model): __tablename__ = 'author' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(120), unique=True) passwd = db.Column(db.String(120)) article = db.relationship('Article', backref='author', lazy='dynamic') def __init__(self, name, passwd): self.name = name self.passwd = passwd def __repr__(self): return '<User:%r>' % (self.name) def is_authenticated(self): return True def is_active(self): return True def is_anonymous(self): return False def get_id(self): return unicode(self.id)
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(20), unique=True, nullable=False) email = db.Column(db.String(100), unique=True, nullable=False) imageFile = db.Column(db.String(20), nullable=False, default="default.jpg") password = db.Column(db.String(60), nullable=False) #Here, posts references the Post class. Backref creats an attribute on a Post object #accessed by doing Post.author posts = db.relationship("Post", backref="author", lazy=True) def get_reset_token(self, expireSeconds=1800): serializer = Serializer(current_app.config['SECRET_KEY'], expireSeconds) return serializer.dumps({"userID": self.id}).decode("utf-8") @staticmethod def verify_reset_token(token): serializer = Serializer(current_app.config['SECRET_KEY']) try: userID = serializer.loads(token)['userID'] except: return None return User.query.get(userID) #User is represented as User(Username, Email, ProfileImageFile) def __repr__(self): return f"User('{self.username}', '{self.email}', '{self.imageFile}')"
class User(db.Model,UserMixin): id=db.Column(db.Integer,primary_key=True) username=db.Column(db.String(15),unique=True,nullable=False) password=db.Column(db.String(100),nullable=False) email=db.Column(db.String(50),unique=True,nullable=False) information=db.Column(db.String(100)) twitter=db.Column(db.String(30)) Linkedin=db.Column(db.String(50)) image=db.Column(db.String(100),nullable=False,default="default.jpg") instagram=db.Column(db.String(30)) posts=db.relationship("Post",backref="author",lazy=True) def get_reset_token(self,expires_sec=3600): s=Serializer(app.config["SECRET_KEY"],expires_sec) return s.dumps({"user_id":self.id}).decode("utf-8") @staticmethod def verify_reset_token(token): s=Serializer(app.config["SECRET_KEY"]) try: user_id=s.loads(token)["user_id"] except: return None return User.query.get(user_id) def __repr__(self): return (f"username:{self.username},id:{self.id}")
class Post(db.Model): """ A post on the blog :key slug: Slug of this post (KEY) :key date: Date of this post :key title: Title of this post :key lead: The first two sentences of the post for display on selection pages :key body_md: Markdown version of this post :key body_html: HTML version of this post (generated automatically from markdown) :key css_file: Optional name of the custom css file (optional) :key js_file: Optional name of the custom css file (optional) :key user_shortname: Shortname of the user who posted this :key user: User who posted this :key tags: Tags for this post """ slug = db.Column(db.String, primary_key=True) date = db.Column(db.Date, default=date.today()) title = db.Column(db.String) lead = db.Column(db.Text) body_md = db.Column(db.Text) body_html = db.Column(db.Text) css_file = db.Column(db.String, default=None, nullable=True) js_file = db.Column(db.String, default=None, nullable=True) user_shortname = db.Column(db.String, db.ForeignKey('user.shortname')) tags = db.relationship('Tag', secondary=tags, backref=db.backref('posts')) def __str__(self): """ Return a string representation of the object :return: :rtype: str """ return self.title
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(20), unique=True, nullable=False) email = db.Column(db.String(120), unique=True, nullable=False) image_file = db.Column(db.String(20), nullable=False, default='default.jpg') password = db.Column( db.String(60), nullable=False) # hashing creates a 60 character string posts = db.relationship( 'Post', backref='author', lazy=True ) # backref creates and allows us to use "author" attribute in Post def get_reset_token(self, expires_sec=1800): s = Serializer(app.config['SECRET_KEY'], expires_sec) return s.dumps({'user_id': self.id}).decode('utf-8') @staticmethod # not to expect a self argument def verify_reset_token(token): s = Serializer(app.config['SECRET_KEY']) try: user_id = s.loads(token)['user_id'] except: return None return User.query.get(user_id) def __repr__(self): return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(20), unique=True, nullable=False) email = db.Column(db.String(120), unique=True, nullable=False) image_file = db.Column(db.String(20), nullable=False, default='default.png') password = db.Column(db.String(60), nullable=False) # relationship between User and Post model posts = db.relationship('Post', backref='author', lazy=True) # expires in 30 minutes def get_reset_token(self, expires_sec=1800): # generates time-sensitive token s = Serializer(app.config['SECRET_KEY'], expires_sec) # returns the token for the specific id return s.dumps({'user_id': self.id}).decode('utf-8') @staticmethod def verify_set_token(token): s = Serializer(app.config['SECRET_KEY']) try: user_id = s.load(token)['user_id'] except: return None return User.query.get(user_id) def __repr__(self): return f"User('{self.username}, {self.email}, {self.image_file}')"
class User(db.Model, UserMixin): user_id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(20), unique=True, nullable=False) email = db.Column(db.String(120), unique=True, nullable=False) image = db.Column(db.String(20), nullable=False, default="default.jpg") password = db.Column(db.String(60), nullable=False) posts = db.relationship("Post", backref="author", lazy=True) def get_reset_token(self, expires_sec=1800): s = Serializer(app.config["SECRET_KEY"], expires_in=expires_sec) return s.dumps({"user_id": self.get_id()}).decode("utf-8") @staticmethod def verify_reset_token(token): s = Serializer(app.config["SECRET_KEY"]) try: user_id = s.loads(token)["user_id"] except Exception: return None return User.query.get(user_id) def get_id(self): return self.user_id def __repr__(self): return f"User({self.username}, {self.email}, {self.image})"
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(20), unique=True, nullable=False) email = db.Column(db.String(120), unique=True, nullable=False) image_file = db.Column(db.String(20), nullable=False, default='default.png') password = db.Column(db.String(60), nullable=False) posts = db.relationship('Post', backref='author', lazy=True) def get_reset_token(self, expires_sec=1800): s = Serializer(current_app.config['SECRET_KEY'], expires_sec) return s.dumps({'user_id': self.id}).decode('utf-8') @staticmethod def verify_reset_token(token): s = Serializer(current_app.config['SECRET_KEY']) try: user_id = s.loads(token)['user_id'] except: return None return User.query.get(user_id) def __repr__(self): return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(40), nullable=False) email = db.Column(db.String(40), nullable=False) first_name = db.Column(db.String(40), nullable=False) last_name = db.Column(db.String(40), nullable=False) password_hash = db.Column(db.String(255), nullable=False) is_active = db.Column(db.Boolean(), default=True, nullable=False) is_superuser = db.Column(db.Boolean(), default=False, nullable=False) date_joined = db.Column(db.DateTime(timezone=True), server_default=func.now()) blogs = db.relationship("Blog", backref="user") def __init__(self, username, email, first_name, last_name, password): self.username = username self.email = email self.first_name = first_name self.last_name = last_name self.password_hash = generate_password_hash(password) def check_password(self, password): return check_password_hash(self.password_hash, password) def set_password(self, password): self.password_hash = generate_password_hash(password) def __repr__(self): return f'{self.first_name} {self.last_name}'