class Category (db.Model):
__tablename__ = 'category_model'
id = db.Column (db.Integer, primary_key = True)
name = db.Column (db.String (30) , nullable = False, unique = True)
#color = db.Column (db.String (10), nullable = False)
subcategories = db.relationship ('SubCategory' , cascade = 'all,delete', backref = 'category_model' , lazy = True)
def __init__ (self, name):#, color = '#00000000'):
self.name = name
#self.color = color
def save (self):
db.session.add (self)
db.session.commit()
def edit (self, name):
self.name = name
db.session.commit()
def delete (self):
db.session.delete (self)
db.session.commit()
def append_subcategory (self, subcategory):
self.subcategories.append (subcategory)
db.session.commit()
def serialize_one (self):
return CategorySchema().dump(self)
@staticmethod
def serialize_many (arg):
return CategorySchema(many=True).dump(arg)
class Podcast(db.Model):
__tablename__ = 'podcast_model'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(40), nullable=False)
description = db.Column(db.Text, nullable=False)
url = db.Column(db.Text, nullable=False)
timestamp = db.Column(db.DateTime)
def __init__(self, title, description, url):
self.title = title
self.description = description
self.url = url
self.timestamp = datetime.now()
def save(self):
db.session.add(self)
db.session.commit()
def edit(self, title, description, url):
self.title = title
self.description = description
self.url = url
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
def serialize_one(self):
return PodcastSchema().dump(self)
@staticmethod
def serialize_many(arg):
return PodcastSchema(many=True).dump(arg)
class Motivation (db.Model):
__tablename__ = 'motivation_model'
id = db.Column(db.Integer, primary_key = True)
title = db.Column (db.String(40), nullable = True)
description = db.Column (db.Text , nullable = False)
subcategory_id = db.Column(db.Integer, db.ForeignKey('subcategory_model.id', ondelete = 'CASCADE'))
timestamp = db.Column (db.DateTime)
usermotivations = db.relationship ('UserMotivation' , cascade = 'all,delete', backref = 'motivation_model' , lazy = True)
def __init__ (self, description, subcategory_id, title = None):
self.title = title
self.description = description
self.timestamp = datetime.now()
if title :
self.title = title
self.subcategory_id = subcategory_id
def save (self):
db.session.add (self)
db.session.commit()
def edit (self, title, description):
self.title = title
self.description = description
db.session.commit()
def delete (self):
db.session.delete (self)
db.session.commit()
def append_usermotivation (self, usermotivation):
self.usermotivations.append (usermotivation)
db.session.commit()
def serialize_one (self):
return MotivationSchema().dump(self)
@staticmethod
def serialize_many (arg):
return MotivationSchema(many=True).dump(arg)
class SubCategory (db.Model):
__tablename__ = 'subcategory_model'
id = db.Column (db.Integer, primary_key = True)
name = db.Column (db.String (50) , nullable = False)
icon_url = db.Column (db.Text)
category_id = db.Column(db.Integer, db.ForeignKey('category_model.id', ondelete = 'CASCADE'))
motivations = db.relationship ('Motivation' , cascade = 'all,delete', backref = 'subcategory_model' , lazy = True)
usermotivations = db.relationship ('UserMotivation' , cascade = 'all,delete', backref = 'subcategory_model' , lazy = True)
def __init__ (self, name, url, category_id):
self.name = name
self.icon_url = url
self.category_id = category_id
def save (self):
db.session.add (self)
db.session.commit()
def edit (self, name, icon):
self.name = name
self.icon_url = icon
db.session.commit()
def delete (self):
db.session.delete (self)
db.session.commit()
def append_motivation (self, motivation):
self.motivations.append (motivation)
db.session.commit()
def serialize_one (self):
return SubCategorySchema().dump(self)
@staticmethod
def serialize_many (arg):
return SubCategorySchema(many=True).dump(arg)
class User(db.Model, UserMixin):
__tablename__ = 'user_model'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
email = db.Column(db.String(50), unique=True, nullable=False)
role = db.Column(db.String(10), nullable=False) #user, admin, owner
pass_hash = db.Column(db.Text)
motivation_count = db.Column(db.Integer, nullable=False)
usermotivations = db.relationship('UserMotivation',
cascade='all,delete',
backref='user_model',
lazy=True)
motivation_bookmark = db.relationship('Motivation',
secondary=user_motivation_bookmark)
def __init__(self, name, email, password, role='user', count=5):
self.name = name
self.email = email.lower()
self.role = role
self.pass_hash = generate_password_hash(password)
self.motivation_count = count
def check_password(self, password):
return check_password_hash(self.pass_hash, password)
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
def rename(self, new_name):
self.name = new_name
db.session.commit()
def change_password(self, pw):
self.pass_hash = generate_password_hash(pw)
db.session.commit()
def edit_count(self, count):
self.motivation_count = count
db.session.commit()
def add_bookmark(self, motivation):
self.motivation_bookmark.append(motivation)
db.session.commit()
def remove_bookmark(self, motivation):
self.motivation_bookmark.remove(motivation)
db.session.commit()
def get_bookmark(self):
return self.motivation_bookmark
def clear_visited_motivations(self):
UserMotivation.query.filter(UserMotivation.user_id == self.id,
UserMotivation.visited == False).delete()
db.session.commit()
@staticmethod
def initialize_motivations(user_id, user_count):
random.seed(user_id)
for subcategory_id, in SubCategory.query.with_entities(
SubCategory.id).all():
motivations = Motivation.query.filter_by(
subcategory_id=subcategory_id).all()
samples = random.sample(motivations, user_count * 7)
for i in range(7):
for j in range(user_count):
new_record = UserMotivation(user_id,
samples[j +
(i * user_count)].id,
subcategory_id,
days=i)
new_record.save()
print("DONE###########################################")
@staticmethod
def reinitialize_motivations(user_id, user_count):
random.seed(user_id)
for subcategory_id, in SubCategory.query.with_entities(
SubCategory.id).all():
useless_motivations = UserMotivation.query.with_entities\
(UserMotivation.motivation_id)\
.filter(UserMotivation.user_id == user_id,\
UserMotivation.subcategory_id == subcategory_id).all()
#motivations from this category except those which are useless
useful_motivations = Motivation.query.filter \
(~Motivation.id.in_ (useless_motivations),\
Motivation.subcategory_id == subcategory_id).all()
samples = random.sample(useful_motivations, user_count * 7)
for i in range(7):
for j in range(user_count):
new_record = UserMotivation(user_id,
samples[j +
(i * user_count)].id,
subcategory_id,
days=i)
new_record.save()
print("DONE REINIT$$$$$$$$$$$##################")
@staticmethod
def query_by_email(email):
return User.query.filter_by(email=email).first()
def serialize_one(self):
return UserSchema().dump(self)
@staticmethod
def serialize_many(arg):
return UserSchema(many=True).dump(arg)