class Product(db.Model):
__tablename__ = 'products'
id = db.Column(db.Integer, primary_key=True)
image_url = db.Column(db.String(255))
price = db.Column(db.DECIMAL)
title = db.Column(db.String(255))
description = db.Column(db.Text, default='')
ingredients = db.relationship('Flower', secondary=product_flower, lazy='subquery',
backref=db.backref('product', lazy=True))
categories = db.relationship('Category', secondary=product_category, lazy='subquery',
backref=db.backref('products', lazy=True))
class TrackOut(db.Model):
'''
Database Generated Fields
'''
id = db.Column(db.Integer, primary_key=True)
track_id = db.Column(db.Integer,
db.ForeignKey('track.uuid', ondelete='CASCADE'))
created_at = db.Column(db.DateTime, default=datetime.utcnow)
uuid = db.Column(db.String, default=generate_uuid)
'''
Configurable Fields
'''
user_id = db.Column(db.Integer)
name = db.Column(db.String(1000))
type = db.Column(db.String(50))
settings = db.Column(db.String(1000))
eq = db.relationship("Equalizer",
backref=db.backref("eq", passive_deletes=True),
lazy='subquery',
uselist=False)
de = db.relationship("Deesser",
backref=db.backref("de", passive_deletes=True),
lazy='subquery',
uselist=False)
co = db.relationship("Compressor",
backref=db.backref("co", passive_deletes=True),
lazy='subquery',
uselist=False)
re = db.relationship("Reverb",
backref=db.backref("re", passive_deletes=True),
lazy='subquery',
uselist=False)
'''
Wav File Representation
'''
path = db.Column(db.String(1000))
file_hash = db.Column(db.LargeBinary, unique=True)
def to_dict(self):
trackout = {
"id": self.id,
"uuid": self.uuid,
"user_id": self.user_id,
"track_id": self.track_id,
"created_at": self.created_at,
"name": self.name,
"type": self.type,
"path": self.path,
"settings": self.settings
}
return trackout
class Movie(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), unique=True, nullable=False)
genre_id = db.Column(db.Integer, db.ForeignKey('genre.id'), nullable=False)
genre = db.relationship('Genre', backref=db.backref('movie', lazy=True))
cast = db.relationship('Actor',
secondary=movies_actors_association,
lazy=True,
backref=db.backref('movies', lazy=True))
def __repr__(self):
return self.title
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(32), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
gardens = db.relationship('Garden', secondary=ownership, lazy='dynamic',
backref=db.backref('owners', lazy='dynamic'))
sensors = db.relationship('Sensor', backref='owner', lazy='dynamic')
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)
def generate_auth_token(self, expiration=600):
s = Serializer(app.config['SECRET_KEY'], expires_in=expiration)
return s.dumps({'id': self.id})
@staticmethod
def verify_auth_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
data = s.loads(token)
except SignatureExpired:
return None # Valid token but expired
except BadSignature:
return None # Invalid token
user = User.query.get(data['id'])
return user
def __repr__(self):
return '<User {}>'.format(self.username)
class DeckSelectedCard(db.AlchemyBase):
"""Tracks cards selected for use in First Five
`is_first_five` means cards that are explicitly included in the First Five. `is_paid_effect`
means that the player plans to pay the effect cost for that card in the first round.
`tutor_card_id` means that the card in `tutor_card_id` was used to fetch this card, which means
that it can functionally be either the First Sixth card and/or a paid effect cost.
"""
__tablename__ = "deck_selected_card"
deck_id = db.Column(db.Integer,
db.ForeignKey(Deck.id),
nullable=False,
primary_key=True)
card_id = db.Column(db.Integer,
db.ForeignKey(Card.id),
nullable=False,
primary_key=True)
tutor_card_id = db.Column(db.Integer,
nullable=False,
default=0,
primary_key=True)
is_first_five = db.Column(db.Boolean, nullable=False, default=False)
is_paid_effect = db.Column(db.Boolean, nullable=False, default=False)
deck = db.relationship(Deck,
backref=db.backref("selected_cards",
cascade="all, delete-orphan"))
class Client(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True)
id_phone = db.Column(db.Integer, db.ForeignKey('phone.id'), nullable=True)
email = db.Column(db.String(50), unique=True)
created = db.Column(db.DateTime)
# cria uma propriedade
# (não faz parte do banco de dados)
records = db.relationship(
'Record',
# backref='client': um jeito simples de declarar também uma nova propriedade na classe Record
# haverá a propriedade record.client para Record
backref='client',
# Indica quando os dados serão carregados do banco de dados
# o lazy='dynamic' retorna um objeto query que pode ser refinado antes de carregar items.
lazy='dynamic')
# cria uma propriedade que expressa um relacionamento um-para-um (uselist=False)
phone = db.relationship('Phone', backref='client', uselist=False)
groups = db.relationship('Group',
secondary=clients_groups,
backref=db.backref('members', lazy='dynamic'))
def __init__(self, username, email):
self.username = username
self.email = email
self.created = datetime.now()
class Speaker(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(150), nullable=False)
last_name = db.Column(db.String(150), nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
phone = db.Column(db.String(80), unique=True, nullable=True)
description = db.Column(db.String(255), nullable=True)
company_name = db.Column(db.String(140), nullable=True)
job_title = db.Column(db.String(120), nullable=True)
speaker_photo = db.Column(db.String(100), default="default.png")
website = db.Column(db.String(200))
workshop = db.relationship('Workshop',
backref=db.backref('workshop', lazy=True))
def __repr__(self):
return f"Speaker {self.firstName} {self.lastName}"
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
def update(self):
db.session.commit()
class CapitalCall(db.Model):
__tablename__ = 'capitalcall'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
date = db.Column(db.DateTime, default=datetime.now(), nullable=False)
name = db.Column(db.String(255), nullable=False, unique=True)
capital = db.Column(db.Float, nullable=False)
# Establish Many-to-Many relationship
investments = db.relationship(
'Investment',
secondary=FundInvestments,
backref=db.backref('capitalcall', lazy='dynamic')
)
def __init__(self, name, capital, date=None):
self.name = name
self.capital = capital
if date is not None:
self.date = date
def to_json(self):
return {
'id': self.id,
'name': self.name,
'capital': self.capital,
'date': self.date.strftime('%Y-%m-%d T%H:%M:%S.%f'),
'investments': [i.to_json() for i in self.investments]
}
class Fund(db.Model):
__tablename__ = 'fund'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(128), nullable=False, unique=True)
date = db.Column(db.DateTime, default=datetime.now(), nullable=False)
# Establish One-to-Many relationship
committments = db.relationship(
'Committment',
backref='fund',
lazy='dynamic'
)
# Establish Many-to-Many relationship
investments = db.relationship(
'Investment',
secondary=FundInvestments,
backref=db.backref('fund', lazy='dynamic')
)
def __init__(self, name):
self.name = name
def to_json(self):
return {
'id': self.id,
'name': self.name,
'date': self.date.strftime('%Y-%m-%d T%H:%M:%S.%f'),
'committments': [c.to_json() for c in self.committments],
}
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
def __str__(self):
return self.email
# Create customized model view class
class MyModelView(sqla.ModelView):
def is_accessible(self):
return (current_user.is_active and current_user.is_authenticated
and current_user.has_role('superuser'))
def _handle_view(self, name, **kwargs):
"""
Override builtin _handle_view in order to redirect users when a view is not accessible.
"""
if not self.is_accessible():
if current_user.is_authenticated:
# permission denied
abort(403)
else:
# login
return redirect(url_for('security.login', next=request.url))
class Lecturer(db.Model):
__tablename__ = 'lecturers'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(100))
email = db.Column(db.String(128), index=True)
department_id = db.Column(db.Integer, db.ForeignKey('departments.id'))
password_hash = db.Column(db.String(128))
assigned_courses = db.relationship('Course',
secondary=assigned_courses,
backref=db.backref('lecturers_assigned',
lazy='dynamic'),
lazy='dynamic')
created_at = db.Column(db.DateTime, default=datetime.utcnow)
def __init__(self, name, email, department_code, password):
self.name = name.title()
self.email = email
self.department = Department.query.filter_by(
code=department_code).first()
self.password = password
@property
def to_dict(self):
json_lecturer = {
'name': self.name,
'email': self.email,
'department': self.department.code,
'school': self.department.school.code,
'registered_on': arrow.get(self.created_at).for_json(),
'registered_since': arrow.get(self.created_at).humanize(),
}
return json_lecturer
def assign_course(self, course):
if not self.is_assigned(course):
self.assigned_courses.append(course)
def is_assigned(self, course):
return self.assigned_courses.filter(
assigned_courses.c.course_id == course.id).count() > 0
@property
def password(self):
raise AttributeError('Sorry mate :|. Read only field')
@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'Lecturer(name={self.name}, email={self.email})'
def save(self):
db.session.add(self)
db.session.commit()
class Tarefa(db.Model):
__tablename__ = "tarefa"
id = db.Column(db.Integer, primary_key=True, autoincrement=True, nullable=False)
titulo = db.Column(db.String(50), nullable=False)
descricao = db.Column(db.String(100), nullable=False)
data_expiracao = db.Column(db.Date, nullable=False)
projeto_id = db.Column(db.Integer, db.ForeignKey(projeto_model.Projeto.id))
projeto = db.relationship(projeto_model.Projeto, backref=db.backref("tarefas", lazy="dynamic"));
class Token(db.Model):
id = db.Column(db.Integer, primary_key=True)
auth_token = db.Column(db.String(255), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
user = db.relationship(User,
backref=db.backref('token',
lazy=True,
uselist=False,
cascade="all, delete"))
class ApplicantValue(db.Model):
__tablename__ = 'applicant_values'
id = db.Column(db.Integer, primary_key=True)
applicant_id = db.Column(db.Integer, db.ForeignKey('applicants.id'))
value_id = db.Column(db.Integer, db.ForeignKey('values.id'))
created_at = Column(DateTime(timezone=True),
nullable=False,
default=datetime.now())
# relationships
applicant = db.relationship('Applicant',
backref=db.backref(
"applicant_values",
cascade="all, delete-orphan"))
value = db.relationship('Value',
backref=db.backref("applicant_values",
cascade="all, delete-orphan"))
class Media(db.Model):
__tablename__ = 'media'
__table_args__ = {'schema': 'multiquestions'}
id = db.Column(db.Integer, primary_key=True, nullable=False, unique=True)
filetype = db.Column(db.String(32))
data = db.Column(db.LargeBinary)
question = db.relationship('Questions',
secondary='multiquestions.relationmedia',
backref=db.backref('medias', lazy='dynamic'))
class Types(db.Model):
__tablename__ = 'types'
__table_args__ = {'schema': 'multiquestions'}
id = db.Column(db.Integer, primary_key=True, nullable=False, unique=True)
type = db.Column(db.String(80), nullable=False)
typename = db.Column(db.String(80), nullable=False)
question = db.relationship('Questions',
secondary='multiquestions.relationtypes',
backref=db.backref('types', lazy='dynamic'))
class Show(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255))
url = db.Column(db.String(255))
start_date = db.Column(db.DateTime)
venue_id = db.Column(db.Integer, db.ForeignKey('venue.id'))
venue = db.relationship('Venue', db.backref('show', lazy='dynamic'))
source_id = db.Column(db.Integer, db.ForeignKey('source.id'))
source = db.relationship('Source', db.backref('source', lazy='dynamic'))
def __init__(self, title, url, start_date):
self.title = title
self.url = url
self.start_date = start_date
def save(self):
db.session.add(self)
db.session.commit()
class Business(db.Model):
""""""
__tablename__ = 'businesses'
id = db.Column(db.Integer, primary_key=True, index=True)
name = db.Column(db.String(100), nullable=False, unique=True)
description = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
location_id = db.Column(db.Integer, db.ForeignKey('locations.id'))
categories = db.relationship('Category',
secondary=business_category,
lazy='subquery',
backref=db.backref('businesses', lazy=True))
reviews = db.relationship('Review', backref='business', lazy=True)
photo = db.Column(db.String(200))
created_at = db.Column(db.DateTime, default=datetime.utcnow())
updated_at = db.Column(db.DateTime, default=datetime.utcnow())
def create(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.commit()
business = Business.query.get(self.id)
result = {
'message': 'Business updated successfully.',
'code': 200,
'business': Business.get_business_details(business)
}
return result
def delete(self):
db.session.delete(self)
db.session.commit()
@staticmethod
def get_business(id):
business = Business.query.get(int(id))
return business
@staticmethod
def get_business_details(business):
categories = [
Category.get_categories_details(c) for c in business.categories
]
return {'id': business.id, 'name':business.name, 'description': business.description, 'userId':business.user_id, \
'locationId':business.location_id, 'categories':categories, 'photo':business.photo}
@staticmethod
def get_businesses():
businesses = Business.query.all()
return businesses
def __repr__(self):
""""""
return '<Business : {0} >'.format(self.name)
class Recipe(db.Model):
'''Class to represent recipe table'''
__tablename__ = 'recipe'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), unique=False, nullable=False)
ingredients = db.Column(db.String(250))
description = db.Column(db.Text)
cat_id = db.Column(db.Integer,
db.ForeignKey('recipe_category.id'),
nullable=False)
user_id = db.Column(db.Integer, nullable=False)
category = db.relationship("RecipeCategory",
backref=db.backref(
"recipe", cascade="all, delete-orphan"))
def __init__(self,
name,
cat_id,
user_id,
ingredients=None,
description=None):
self.name = name
self.ingredients = ingredients
self.description = description
self.cat_id = cat_id
self.user_id = user_id
def save(self):
db.session.add(self)
db.session.commit()
@staticmethod
def update():
db.session.commit()
@staticmethod
def get_all():
return Recipe.query.all()
@staticmethod
def get_all_limit_offset(catid, userid, lim):
return Recipe.query.filter_by(cat_id=catid, user_id=\
userid).limit(lim).all()
@staticmethod
def get_all_limit(userid, lim):
return Recipe.query.filter_by(user_id=userid).limit(lim).all()
def delete(self):
db.session.delete(self)
db.session.commit()
def __repr__(self):
return "<Recipe: {}>".format(self.name)
class Transacao(db.Model):
__tablename__ = "transacao"
id = db.Column(db.Integer, primary_key=True, autoincrement=True, nullable=False)
titulo = db.Column(db.String(50), nullable=False)
descricao = db.Column(db.String(100), nullable=False)
valor = db.Column(db.Float, nullable=False)
tipo = db.Column(db.Enum(TipoEnum), nullable=False)
data = db.Column(db.Date, nullable=False)
conta_id = db.Column(db.Integer, db.ForeignKey("conta.id"))
conta = db.relationship("Conta", backref=db.backref("transacoes", lazy="dynamic"))
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(180), unique=True,
nullable=False)
username = db.Column(db.String(80), unique=True,
nullable=False)
password = db.Column(db.String(120), nullable=False)
role_id = db.Column(db.Integer, db.ForeignKey('role.id'),
nullable=False)
role = db.relationship('Role',
backref=db.backref('users', lazy=True))
created_date = db.Column(db.DateTime, nullable=False,
default=datetime.utcnow)
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
#! Delete All
@classmethod
def delete_all(cls):
try:
num_rows_deleted = db.session.query(cls).delete()
db.session.commit()
return {'message': f'{num_rows_deleted} row(s) deleted'}
except:
return {'message': 'Something went wrong'}
def update(self):
db.session.commit()
@classmethod
def find_by_email(cls, email):
return cls.query.filter_by(email=email).first()
@classmethod
def find_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@staticmethod
def generate_hash(password):
return generate_password_hash(password)
@staticmethod
def verify_hash(hashed, password):
return check_password_hash(hashed, password)
def __repr__(self):
return(f"{__class__.__name__} {self.username}")
class DeckDie(db.AlchemyBase):
__tablename__ = "deck_die"
deck_id = db.Column(db.Integer,
db.ForeignKey(Deck.id),
nullable=False,
primary_key=True)
die_flag = db.Column(db.Integer, nullable=False, primary_key=True)
count = db.Column(db.SmallInteger, nullable=False)
deck = db.relationship(Deck,
backref=db.backref("dice",
cascade="all, delete-orphan"))
class Task(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
completed = db.Column(db.Boolean, nullable=False, default=False)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, onupdate=datetime.utcnow)
planned_complete_date = db.Column(db.DateTime)
completed_at = db.Column(db.DateTime)
project_id = db.Column(db.Integer, db.ForeignKey('project.id'), nullable=False)
comments = db.relationship('Comment', backref='task', lazy='dynamic')
assignees = db.relationship('User',
secondary=assignees_for_tasks,
backref=db.backref('tasks', lazy='dynamic'),
lazy='dynamic'
)
def save(self):
db.session.add(self)
def delete(self):
db.session.delete(self)
@staticmethod
def get_all():
return Task.query.all()
def add_assignee(self, assignee):
self.assignees.append(assignee)
db.session.add(self)
def remove_assignee(self, assignee):
self.assignees.remove(assignee)
db.session.add(self)
def update_completed_state(self, old_task_completed):
print("Self completed")
print(self.completed)
print("OG task completed")
print(old_task_completed)
if self.completed != old_task_completed:
print("Got to first if")
if self.completed:
print("Got to second if")
self.completed_at = datetime.utcnow()
else:
self.completed_at = None
return self
def __repr__(self):
return f'<Task {self.name} | Created at {self.created_at} | {self.completed} | Completed at {self.completed_at}>'
class Tarefa(db.Model):
__tablename__ = 'tarefa'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
titulo = db.Column(db.String(50), nullable=False)
descricao = db.Column(db.String(100), nullable=False)
data_expiracao = db.Column(db.Date, nullable=False)
#Relacionamento de 1 para n
projeto_id = db.Column(db.Integer, db.ForeignKey('projeto.id'))
projeto = db.relationship(
'Projeto', backref=db.backref('tarefas',
lazy='dynamic')) #projeto_model.Projeto
class Camera(db.Model):
id = db.Column(db.Integer, primary_key=True)
model = db.Column(db.String(80), nullable=False)
iso_min = db.Column(db.Integer, nullable=False)
iso_max = db.Column(db.Integer, nullable=False)
resolution = db.Column(db.Float, nullable=False)
autofocus = db.Column(db.Integer, nullable=False)
ois = db.Column(db.Boolean, nullable=False)
wr = db.Column(db.Boolean, nullable=False)
wifi = db.Column(db.Boolean, nullable=False)
weight = db.Column(db.Float, nullable=False)
producer_id = db.Column(db.Integer,
db.ForeignKey('producer.id'),
nullable=False)
producer = db.relationship('Producer',
backref=db.backref('cameras', lazy=True))
sensor_format_id = db.Column(db.Integer,
db.ForeignKey('sensor_format.id'),
nullable=False)
sensor_format = db.relationship('SensorFormat',
backref=db.backref('cameras', lazy=True))
mount_id = db.Column(db.Integer, db.ForeignKey('mount.id'), nullable=False)
mount = db.relationship('Mount', backref=db.backref('cameras', lazy=True))
def __init__(self, model, iso_min, iso_max, resolution, autofocus, ois, wr,
wifi, weight, producer, sensor_format, mount):
self.model = model
self.iso_min = iso_min
self.iso_max = iso_max
self.resolution = resolution
self.autofocus = autofocus
self.ois = ois
self.wr = wr
self.wifi = wifi
self.weight = weight
self.producer = producer
self.sensor_format = sensor_format
self.mount = mount
class UserRelease(db.AlchemyBase):
__tablename__ = "user_release"
user_id = db.Column(db.Integer,
db.ForeignKey(User.id),
nullable=False,
primary_key=True,
index=True)
release_id = db.Column(db.Integer,
db.ForeignKey(Release.id),
nullable=False,
primary_key=True)
user = db.relationship(User,
backref=db.backref("collection",
cascade="all, delete-orphan"))
class Comment(db.Model):
__tablename__ = 'comments'
id = db.Column(db.Integer, primary_key=True)
comment = db.Column(db.String(250), nullable=False)
creation_date = db.Column(db.TIMESTAMP,
server_default=db.func.current_timestamp(),
nullable=False)
category_id = db.Column(db.Integer,
db.ForeignKey('categories.id', ondelete='CASCADE'),
nullable=False)
category = db.relationship('Category',
backref=db.backref('comments', lazy='dynamic'))
def __init__(self, comment, category_id):
self.comment = comment
self.category_id = category_id
class DeckCard(db.AlchemyBase):
__tablename__ = "deck_card"
deck_id = db.Column(db.Integer,
db.ForeignKey(Deck.id),
nullable=False,
primary_key=True)
card_id = db.Column(db.Integer,
db.ForeignKey(Card.id),
nullable=False,
primary_key=True)
count = db.Column(db.SmallInteger, nullable=False)
card = db.relationship(Card)
deck = db.relationship(Deck,
backref=db.backref("cards",
cascade="all, delete-orphan"))
class Tags(db.Model):
__tablename__ = 'tags'
__table_args__ = {'schema': 'multiquestions'}
id = db.Column(db.Integer, primary_key=True, nullable=False, unique=True)
tagname = db.Column(db.String(80), unique=True, nullable=False)
question = db.relationship('Questions',
secondary='multiquestions.relationtags',
backref=db.backref('tags', lazy='dynamic'))
def serialize(self):
output = []
for q in self.question:
mq = {}
mq['uid'] = q.uid
output.append(mq)
return {'tagname': self.tagname, 'question': output}
class NoteModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
note = db.Column(db.String(300), unique=False, nullable=False)
date = db.Column(db.DateTime, default=datetime.now)
author_id = db.Column(db.Integer, db.ForeignKey(UserModel.id))
private = db.Column(db.Boolean(),
default=True,
server_default="true",
nullable=False)
archive = db.Column(db.Boolean(),
default=False,
server_default="false",
nullable=False)
tags = db.relationship(TagModel,
secondary=tags,
lazy='subquery',
backref=db.backref('notes', lazy=True))
@classmethod
def get_all_notes(cls, author, archive):
if archive == "all":
return NoteModel.query.filter_by(author_id=author.id).all()
if archive == "no_archive":
return NoteModel.query.filter_by(author_id=author.id,
archive=False).all()
if archive == "archive":
return NoteModel.query.filter_by(author_id=author.id,
archive=True).all()
@classmethod
def get_all_public_notes(cls):
return NoteModel.query.filter_by(private=False, archive=False).all()
@classmethod
def get_notes_filtered_by_tags(cls, tag_name):
return NoteModel.query.filter(NoteModel.tags.any(name=tag_name),
NoteModel.archive == False).all()
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
