class FeatureParticipation(ModelBase):
__tablename__ = 'feature_participation'
user_id = db.Column(db.Integer(), db.ForeignKey('app_user.id', onupdate='CASCADE', ondelete='CASCADE'),
primary_key=True)
feature_id = db.Column(db.Integer(), db.ForeignKey('feature.id', onupdate='CASCADE', ondelete='CASCADE'),
primary_key=True)
def __init__(self, user_id: int, feature_id: int):
if not isinstance(user_id, int):
raise expected('user_id', user_id, int)
if not isinstance(feature_id, int):
raise expected('feature_id', feature_id, int)
self.user_id = user_id
self.feature_id = feature_id
@staticmethod
def create(user: AppUser, feature: Feature) -> 'Optional[FeatureParticipation]':
participation = FeatureParticipation(user.id, feature.id)
db.session.add(participation)
return participation
@staticmethod
def get_for_user(user: AppUser, feature: Feature) -> 'Optional[FeatureParticipation]':
return FeatureParticipation.query.filter_by(user_id=user.id, feature_id=feature.id).first()
def __hash__(self):
return hash((self.user_id, self.feature_id))
class CITypeRelation(db.Model):
__tablename__ = "ci_type_relations"
ctr_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
parent_id = db.Column(db.Integer,
db.ForeignKey("ci_types.type_id"),
primary_key=True)
parent = db.relationship(
"CIType", primaryjoin="CIType.type_id==CITypeRelation.parent_id")
child_id = db.Column(db.Integer,
db.ForeignKey("ci_types.type_id"),
primary_key=True)
child = db.relationship(
"CIType", primaryjoin="CIType.type_id==CITypeRelation.child_id")
relation_type = db.Column(db.String(7),
db.Enum("contain",
"connect",
"deploy",
"install",
name="relation_type"),
default="contain")
__table_args__ = (db.UniqueConstraint("parent_id",
"child_id",
name="parent_child_uniq"), )
class Token(db.Model):
id = db.Column(db.Integer, primary_key=True)
client_id = db.Column(
db.String(40),
db.ForeignKey('client.client_id'),
nullable=False,
)
client = db.relationship('Client')
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User')
# currently only bearer is supported
token_type = db.Column(db.String(40))
access_token = db.Column(db.String(255), unique=True)
refresh_token = db.Column(db.String(255), unique=True)
expires = db.Column(db.DateTime)
_scopes = db.Column(db.Text)
@property
def scopes(self):
if self._scopes:
return self._scopes.split()
return []
class Sentence(db.Model):
__tablename__ = 'sentence'
id = db.Column(db.Integer(), primary_key=True)
text = db.Column(db.String())
sentiment = db.Column(db.Float())
status = db.Column(db.String()) #CONTEXT, SENTIMENT, PRED, DONE
date = db.Column(db.String())
time = db.Column(db.String())
article_id = db.Column(db.Integer(), db.ForeignKey('article.id'))
context = db.Column(db.String(), db.ForeignKey("company.stock_code"))
def __init__(self, text, article_id, date, time):
#self.id = id
self.text = text
self.article_id = article_id
self.status = "CONTEXT"
self.date = self.time = datetime.strptime(date, '%m/%d/%Y')
self.time = datetime.strptime(time, '%H:%M:%S')
def __repr__(self):
return '<id {}>'.format(self.id)
def serialize(self):
return {
'id': self.id,
'text': self.text,
'sentiment': self.sentiment,
'status': self.status,
'article_id': self.article_id,
'date': self.date.strftime("%m/%d/%Y"),
'time': self.time.strftime("%H:%M:%S"),
'context': self.context
}
class Reservation(db.Model):
__tablename__ = 'reservation'
id = db.Column(db.Integer, primary_key=True) # generoitu
user_id = db.Column(db.Integer(), db.ForeignKey("user.id")) # varauksen tekijän id
workspace_id = db.Column(db.Integer(), db.ForeignKey("workspace.id")) # työtilan id
# default lähinnä testinä, todellisuudessa ei tietty voi varata tilaa ilman aikaa
start_time = db.Column(db.DateTime(), nullable=False, server_default=db.func.now()) # aloitusaika
# defaultend = db.func.now() + timedelta(hours=1)
# server_default= defaultend
# ilmesesti sqalkemian timestamp-hässäkkä ei ole yhteensopiva pythonin oman timestamp-hässäkän kanssa
end_time = db.Column(db.DateTime(), nullable=False, server_default=db.func.now()) # lopetusaika
created_at = db.Column(db.DateTime(), nullable=False, server_default=db.func.now())
updated_at = db.Column(db.DateTime(), nullable=False, server_default=db.func.now(), onupdate=db.func.now())
@classmethod
def get_by_id(cls, id):
return cls.query.filter_by(username=id).first()
@classmethod
def get_by_user_id(cls, user_id):
return cls.query.filter_by(email=user_id).first()
def save(self):
db.session.add(self)
db.session.commit()
class Grant(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id',
ondelete='CASCADE'))
user = db.relationship('User')
client_id = db.Column(
db.String(40),
db.ForeignKey('client.client_id'),
nullable=False,
)
client = db.relationship('Client')
code = db.Column(db.String(255), index=True, nullable=False)
redirect_uri = db.Column(db.String(255))
expires = db.Column(db.DateTime)
_scopes = db.Column(db.Text)
def delete(self):
db.session.delete(self)
db.session.commit()
return self
@property
def scopes(self):
if self._scopes:
return self._scopes.split()
return []
class Votes(db.Model):
__tablename__ = "m_votes"
id = db.Column(db.Integer(),
primary_key=True,
unique=True,
nullable=False,
index=True,
autoincrement=True)
author_id = db.Column(db.Integer(),
db.ForeignKey("m_user.id"),
nullable=False)
topic_id = db.Column(db.Integer(),
db.ForeignKey("t_topics.id"),
nullable=False)
answer_id = db.Column(db.Integer(),
db.ForeignKey("m_answer.id"),
nullable=False)
up_votes = db.Column(db.Integer(), nullable=True, default=0)
down_votes = db.Column(db.Integer(), nullable=True, default=0)
@classmethod
def check_author_if_voted(cls, author_id, topic_id, answer_id):
return cls.query.filter_by(author_id=author_id).filter_by(
topic_id=topic_id).filter_by(answer_id=answer_id).first()
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class UserDishWeight(db.Model):
__tablename__ = 'user_dish_weight'
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), primary_key=True)
dish_id = db.Column(db.Integer, db.ForeignKey('dish.id'), primary_key=True)
user = db.relationship('User')
dish = db.relationship('Dish')
weight = db.Column(db.Float, default=1.0)
class PhoneAlarm(BaseModel):
__tablename__ = "phone_alarm"
phone_id = db.Column(db.CHAR(36),
db.ForeignKey("phone.pid"),
primary_key=True)
alarm_id = db.Column(db.Integer,
db.ForeignKey("alarm.aid"),
primary_key=True)
timestamp = db.Column(db.DateTime(), nullable=True)
status = db.Column(db.BOOLEAN, nullable=True)
alarm = relationship("Alarm", back_populates="phones")
phone = relationship("Phone", back_populates="alarms")
def serialize(self):
return {
"pid":
self.phone_id,
"aid":
self.alarm_id,
"status":
self.status,
"timestamp":
re.sub('[-:+]', '', self.timestamp.isoformat()) +
'Z' if self.timestamp is not None else None
}
class LikesOfComment(db.Model):
"""[Class for the likes on the coments]
RelationShips:
1:1 Wiht User
1:M With Comments
Args:
db.Model ([sqlAlchemy]): [sqlALCHEMY]
"""
__tablename__ = "likes_of_comment"
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
created_date = db.Column(db.DateTime, default=datetime.datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
comment_id = db.Column(db.Integer,
db.ForeignKey('comments.id'),
nullable=False)
def convert_to_json(self):
return {
"id": self.id,
"user_id": self.user_id,
"comment_id": self.comment_id,
"created_date": self.created_date
}
def __repr__(self):
return "<Likes %r,%r" % (self.id, self.created_date)
class Likes(db.Model):
"""[Likes Models]
RelationsShips:
M:1 With User
M:1 With Beach
Args:
db.Model ([sqlAlchemy]): [sqlAlchemy instance]
"""
__tablename__ = "likes"
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
created_date = db.Column(db.DateTime, default=datetime.datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
beach_id = db.Column(db.Integer, db.ForeignKey("beach.id"), nullable=False)
def convert_to_json(self):
return {
"id": self.id,
"user_id": self.user_id,
"created_date": self.created_date,
"beach_id": self.beach_id
}
def __repr__(self):
return "<Likes %r,%r>" % (self.id, self.created_date)
class Reservation(db.Model):
__tablename__ = 'reservation'
id = db.Column(db.Integer, primary_key=True)
client_id = db.Column(db.Integer(), db.ForeignKey("client.id"))
workspace_id = db.Column(db.Integer(), db.ForeignKey("workspace.id"))
created_at = db.Column(db.DateTime(), nullable=False, server_default=db.func.now())
updated_at = db.Column(db.DateTime(), nullable=False, server_default=db.func.now(), onupdate=db.func.now())
@classmethod
def get_all_by_client(cls, client_id):
return cls.query.filter_by(client_id=client_id).all()
@classmethod
def get_by_id(cls, reservation_id):
return cls.query.filter_by(id=reservation_id).first()
@classmethod
def get_by_client(cls, client_id):
return cls.query.filter_by(client_id=client_id).first()
@classmethod
def get_by_workspace(cls, workspace_id):
return cls.query.filter_by(workspace_id=workspace_id).first()
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class CIRelation(db.Model):
__tablename__ = "ci_relations"
cr_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
first_ci_id = db.Column(db.Integer,
db.ForeignKey("cis.ci_id"),
primary_key=True)
second_ci_id = db.Column(db.Integer,
db.ForeignKey("cis.ci_id"),
primary_key=True)
first_ci = db.relationship("CI",
primaryjoin="CI.ci_id==CIRelation.first_ci_id")
second_ci = db.relationship(
"CI", primaryjoin="CI.ci_id==CIRelation.second_ci_id")
relation_type = db.Column(db.String(8),
db.Enum("connect",
"deploy",
"install",
"contain",
name="relation_type"),
nullable=False)
more = db.Column(db.Integer, db.ForeignKey("cis.ci_id"))
__table_args__ = (db.UniqueConstraint("first_ci_id",
"second_ci_id",
name="first_second_uniq"), )
class Invoice(db.Model):
id = db.Column(db.Integer, primary_key=True)
ref = db.Column(db.String(40), nullable=False, index=True)
company_id = db.Column(db.Integer,
db.ForeignKey('company.id', ondelete='CASCADE'),
nullable=False)
staff = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
datetime = db.Column(db.DateTime,
default=datetime.utcnow,
nullable=False,
index=True)
customer_id = db.Column(db.Integer,
db.ForeignKey('customer.id', ondelete='CASCADE'),
nullable=False)
delivery_charge = db.Column(db.Integer, nullable=False, default=0)
remarks = db.Column(db.String(100))
discount_id = db.Column(db.Integer,
db.ForeignKey('discount.id', ondelete=None))
payment = db.relationship('Payment',
backref='invoice',
uselist=False,
lazy=True)
item = db.relationship('InvoicedItem', backref='invoice', lazy=True)
shipment = db.relationship('Shipment',
backref='invoice',
lazy=True,
uselist=False)
discount = db.relationship('Discount')
class user_account(UserMixin, db.Model):
__tablename__ = 'user_account'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('user_personal.id'),
nullable=False)
role_id = db.Column(db.Integer,
db.ForeignKey('user_role.id'),
nullable=False)
username = db.Column(db.String(30), nullable=False)
password = db.Column(db.String(30), nullable=False)
date_created = db.Column(db.DateTime, nullable=False)
last_active = db.Column(db.DateTime, nullable=False)
status = db.Column(db.String(1), nullable=False)
user_account_id = db.relationship('blood_center',
backref='user_account',
lazy=True)
user_request_id = db.relationship('blood_request',
backref='user_account',
lazy=True)
user_participate_id = db.relationship('event_participate',
backref='user_account',
lazy=True)
def __repr__(self, active=True):
return '<user_account {}>'.format(self.username)
class Show(db.Model):
__tablename__ = 'Show'
id = db.Column(db.Integer, primary_key=True)
start_time = db.Column(db.DateTime(), nullable=False)
venue_id = db.Column(db.Integer, db.ForeignKey('Venue.id'), nullable=False)
artist_id = db.Column(db.Integer, db.ForeignKey('Artist.id'), nullable=False)
class LibraryEntry(db.Model):
__tablename__ = 'libraries'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
game_id = db.Column(db.Integer, db.ForeignKey('games.id'), nullable=False)
release_id = db.Column(db.Integer,
db.ForeignKey('releases.id'),
nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
play_status_id = db.Column(db.Integer,
db.ForeignKey('play_statuses.id'),
nullable=False)
score = db.Column(db.Integer)
own = db.Column(db.Integer, nullable=False, default=1)
digital = db.Column(db.Integer, nullable=False, default=0)
hours = db.Column(db.Integer)
notes = db.Column(db.String)
created_at = db.Column(db.DateTime, nullable=True, default=datetime.now)
updated_at = db.Column(db.DateTime,
nullable=True,
default=datetime.now,
onupdate=datetime.now)
game = db.relationship('Game')
release = db.relationship('Release')
user = db.relationship('User')
play_status = db.relationship('PlayStatus')
def __repr__(self):
return '<LibraryEntry %r>' % self.id
class Application(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
last_name = db.Column(db.String(100), nullable=False)
email = db.Column(db.String(100), nullable=False)
tel = db.Column(db.String(19), nullable=False)
car_brand_id = db.Column(db.Integer, db.ForeignKey('car_brand.id'), nullable=False)
car_brand = db.relationship('CarBrand')
car_model_id = db.Column(db.Integer, db.ForeignKey('car_model.id'), nullable=False)
car_model = db.relationship('CarModel')
unique_track_number = db.Column(db.Integer, default=_generate_unique_track_number)
date = db.Column(db.DateTime, default=datetime.now())
status_id = db.Column(db.Integer, db.ForeignKey('status.id'), default=1)
status = db.relationship('Status')
def __repr__(self):
return f'<Application id: {self.id}, Name: {self.name}, Last name: {self.last_name}, E-mail: {self.email},' \
f' Telephone number: {self.tel}, Car brand id: {self.car_brand_id}, Car model id: {self.car_model_id}, ' \
f'Date: {self.date} '
def serialize(self):
result = {
'track_number': self.unique_track_number,
'car_brand': self.car_brand.name,
'car_model': self.car_model.name,
'price': self.car_model.price,
'date': self.date,
'status': self.status.name
}
return result
class Round(db.Model):
id = db.Column(db.Integer, primary_key=True)
poem_id = db.Column(db.Integer, db.ForeignKey('poem.id'), nullable=False)
number = db.Column(db.Integer)
current = db.Column(db.Boolean, default=True)
length = db.Column(
db.Integer) # if corpus is timed, then length is prescriptive
first_line_id = db.Column(db.Integer, db.ForeignKey("line.id"))
second_line_id = db.Column(db.Integer, db.ForeignKey("line.id"))
first_line = db.relationship(
'Line',
foreign_keys=[first_line_id],
backref='roundAppearingAsPrompt',
lazy=True) #maybe alias as exposed_line for number > 0
second_line = db.relationship('Line',
foreign_keys=[second_line_id],
backref='roundWrittenIn',
lazy=True)
start_time = db.Column(db.DateTime,
server_default=db.func.now(),
nullable=False)
completed_time = db.Column(db.DateTime, nullable=True)
def __init__(self, number):
self.number = number
def complete(self):
self.current = False
class Recommendation(db.Model):
__tablename__ = 'recommendations'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
game_id = db.Column(db.Integer, db.ForeignKey('games.id'), nullable=False)
release_id = db.Column(db.Integer,
db.ForeignKey('releases.id'),
nullable=False)
second_game_id = db.Column(db.Integer,
db.ForeignKey('games.id'),
nullable=False)
second_release_id = db.Column(db.Integer,
db.ForeignKey('releases.id'),
nullable=False)
created_at = db.Column(db.DateTime, nullable=True, default=datetime.now)
updated_at = db.Column(db.DateTime,
nullable=True,
default=datetime.now,
onupdate=datetime.now)
user = db.relationship('User')
game = db.relationship('Game', foreign_keys=[game_id])
release = db.relationship('Release', foreign_keys=[release_id])
recommended_game = db.relationship('Game', foreign_keys=[second_game_id])
recommended_release = db.relationship('Release',
foreign_keys=[second_release_id])
def __repr__(self):
return '<Recommendation %r>' % self.id
class Colonne(db.Model):
numCol = db.Column(db.Integer, primary_key=True)
graphId = db.Column(db.Integer, db.ForeignKey('graphique.graphId'))
graphique = db.relationship("Graphique",
backref=db.backref("colonnes", lazy="dynamic"))
colName = db.Column(db.String(255))
dateDebut = db.Column(db.Date())
dateFin = db.Column(db.Date())
agregatSimple = db.Column(db.String(255))
capteur_id = db.Column(db.Integer, db.ForeignKey('capteur.captId'))
capteur = db.relationship("Capteur")
def __repr__(self):
return "<Colonne (%d) (%s) >" % (self.numCol, self.colName)
@property
def aggreger(self):
return agregats.get(self.agregatSimple, lambda x: 0)
@property
def valeurs(self):
valeurs = [m.valeur for m in self.capteur.mesures.all()]
if not self.agregatSimple:
return valeurs
else:
v = self.aggreger(valeurs)
return [v for _ in range(len(self.capteur.mesures.all()))]
@property
def valeurs_datees(self):
return list(zip(self.dates, self.valeurs))
@property
def dates(self):
return [m.date for m in self.capteur.mesures.all()]
class EventSignup(db.Model):
__tablename__ = 'event_signups'
event_id = db.Column(db.Integer,
db.ForeignKey('events.id'),
primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
primary_key=True)
created_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now())
updated_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now(),
onupdate=db.func.now())
@classmethod
def find_by_event_and_user(cls, event_id, user_id):
return cls.query \
.filter(EventSignup.event_id == event_id) \
.filter(EventSignup.user_id == user_id).first()
def delete(self):
db.session.delete(self)
db.session.commit()
class Label(db.Model):
# 1(Task)-to-Many(Label)
task_id = db.Column(db.String(80),
db.ForeignKey('task.id'),
primary_key=True,
nullable=False)
# 1(Task)-to-Many(User)
user_id = db.Column(db.String(80),
db.ForeignKey('user.id'),
primary_key=True,
nullable=False)
label_data = db.Column(db.JSON(), nullable=False) # JSON
created_at = db.Column(db.DateTime(), nullable=False)
def __repr__(self):
return f"<Label | task_id : {self.task_id} | user_id : {self.user_id}>"
def to_response(self):
return {
"task_id": self.task_id,
"user_id": self.user_id,
"label_data": self.label_data,
"created_at": self.created_at
}
class StaffSalary(db.Model):
id = db.Column(db.Integer, primary_key=True)
staff_id = db.Column(db.Integer, db.ForeignKey('staff.user_id', ondelete='CASCADE'), nullable=False)
datetime = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
amount = db.Column(db.Integer, nullable=False)
paid_by = db.Column(db.Integer, db.ForeignKey('staff.user_id'), nullable=False)
staff = db.relationship(Staff, backref='salary_info', lazy=True, foreign_keys=[staff_id])
class UserItem(db.Model):
__tablename__ = 'user_items'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
item_id = db.Column(db.Integer, db.ForeignKey('items.id'))
amount = db.Column(db.Integer)
item = db.relationship("Item", uselist=False)
class Quantity(db.Model):
id = db.Column(db.Integer, primary_key=True)
quantity = db.Column(db.Float)
recipe_id = db.Column(db.Integer,
db.ForeignKey('recipe.id', ondelete="CASCADE"),
nullable=False)
recipe = db.relationship('Recipe',
backref=db.backref('quantities',
cascade="all,delete",
lazy=True))
ingredient_id = db.Column(db.Integer,
db.ForeignKey('ingredient.id'),
nullable=False)
ingredient = db.relationship('Ingredient',
backref=db.backref('quantities', lazy=True))
measurement_id = db.Column(db.Integer,
db.ForeignKey('measurement.id'),
nullable=False)
measurement = db.relationship('Measurement',
backref=db.backref('quantities', lazy=True))
def __init__(self, quantity, recipe, ingredient, measurement):
self.quantity = quantity
self.recipe = recipe
self.ingredient = ingredient
self.measurement = measurement
def __repr__(self):
return '<Quantity %r>' % self.quantity
class ClosingDays(ModelBase):
__tablename__ = 'closing_days'
id = db.Column(db.Integer(), primary_key=True, autoincrement=True)
campus_id = db.Column(db.Integer(), db.ForeignKey('campus.id'), nullable=False)
first_day = db.Column(db.Date(), nullable=False)
last_day = db.Column(db.Date(), nullable=True, server_default=None)
translatable_id = db.Column(db.Integer(), db.ForeignKey('translatable.id', onupdate='CASCADE', ondelete='RESTRICT'),
nullable=False)
def __init__(self, campus_id: int, first_day: datetime.date, last_day: datetime.date,
translatable_id: int):
if not isinstance(campus_id, int):
raise expected('campus_id', campus_id, int)
if not isinstance(first_day, datetime.date):
raise expected('first_day', first_day, datetime.date)
if last_day is not None and not isinstance(last_day, datetime.date):
raise expected_or_none('last_day', last_day, datetime.date)
if not isinstance(translatable_id, int):
raise expected('translatable_id', translatable_id, int)
self.campus_id = campus_id
self.first_day = first_day
self.last_day = last_day
self.translatable_id = translatable_id
@staticmethod
def create(campus: Campus, first_day: datetime.date, last_day: Optional[datetime.date], reason: str, language: str,
add_to_db=True) -> 'ClosingDays':
translatable, translation = Translatable.get_or_create(reason, language)
result = ClosingDays(campus.id, first_day, last_day, translatable.id)
if add_to_db:
db.session.add(result)
return result
@staticmethod
def find_is_closed(campus: Campus, day: datetime.date) -> 'Optional[ClosingDays]':
return ClosingDays.query.filter(db.and_(ClosingDays.campus_id == campus.id,
ClosingDays.first_day <= day,
db.or_(
ClosingDays.last_day == None,
ClosingDays.last_day >= day
)
)).first()
@staticmethod
def find_closing_days_including(campus: Campus,
start_date: datetime.date,
end_date: datetime.date) -> 'List[ClosingDays]':
return ClosingDays.query.filter(db.and_(ClosingDays.campus_id == campus.id,
ClosingDays.first_day <= end_date,
db.or_(
ClosingDays.last_day == None,
ClosingDays.last_day >= start_date
)
)).all()
class Schedule(db.Model):
__tablename__ = 'schedule'
id = db.Column(db.Integer, primary_key=True)
day = db.Column(db.String(30), unique=True, nullable=False)
interval_id = db.Column(db.Integer, db.ForeignKey('interval.id'))
subject_id = db.Column(db.Integer, db.ForeignKey('subject.id'))
lecturer_id = db.Column(db.Integer, db.ForeignKey('lecturer.id'))
group_id = db.Column(db.Integer, db.ForeignKey('group.id'))
class Expense(db.Model):
id = db.Column(db.Integer, primary_key=True)
company_id = db.Column(db.Integer, db.ForeignKey('company.id', ondelete='CASCADE'), nullable=False)
status = db.Column(db.Boolean, nullable=False, default=True)
amount = db.Column(db.Integer, nullable=False)
type = db.Column(db.Integer, db.ForeignKey('expense_type.id'), nullable=False)
account = db.Column(db.Integer, db.ForeignKey('payment_method.id', ondelete='CASCADE'), nullable=False)
datetime = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
class ReceitaIngrediente(db.Model):
__tablename__ = "ReceitaIngrediente"
id_receita = db.Column(db.Integer, db.ForeignKey('Receita.id'), primary_key=True)
id_ingrediente = db.Column(db.Integer, db.ForeignKey('Ingrediente.id'), primary_key=True)
porcentagem = db.Column(db.Float)
filho = db.relationship("Ingrediente", back_populates="parentes")
parente = db.relationship("Receita", back_populates="filhos")
