class distributionfigures_gfd(db.Model):
__tablename__ = 'distributionfigures_gfd' # To do: rename the table distributionfigures_monthly
id = db.Column(db.Integer, primary_key=True)
month = db.Column(db.Integer,
unique=False,
nullable=True,
primary_key=False)
year = db.Column(db.Integer,
unique=False,
nullable=True,
primary_key=False)
hh_reached = db.Column(db.Integer,
unique=False,
nullable=True,
primary_key=False)
hh_planned = db.Column(db.Integer,
unique=False,
nullable=True,
primary_key=False)
distribution_point = db.Column(db.Integer,
db.ForeignKey('distribution_points2.id'),
nullable=False,
primary_key=False)
moomken = db.Column(db.Boolean())
wfp = db.Column(db.Boolean())
class Attendance(db.Model):
__tablename__ = 'event_attendance'
id = db.Column(db.Integer, primary_key=True)
meetup_user_id = db.Column(db.String())
event_id = db.Column(db.Integer,
db.ForeignKey('events.id'),
nullable=False)
did_attend = db.Column(db.Boolean())
did_rsvp = db.Column(db.Boolean())
title = db.Column(db.String())
event_host = db.Column(db.String())
rsvp_date = db.Column(db.DateTime())
date_joined_group = db.Column(db.DateTime())
def __init__(self, meetup_user_id, event_id, did_attend, did_rsvp, title,
event_host, rsvp_date, date_joined_group):
self.meetup_user_id = meetup_user_id
self.event_id = event_id
self.did_attend = did_attend
self.did_rsvp = did_rsvp
self.title = title
self.event_host = event_host
self.rsvp_date = rsvp_date
self.date_joined_group = date_joined_group
def __repr__(self):
return '<meetup_user_id {}>'.format(self.meetup_user_id)
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(100), nullable=False, unique=True)
email = db.Column(db.String(200), nullable=False, unique=True)
password = db.Column(db.String(200), nullable=False)
is_turkuamk = db.Column(db.Boolean(), default=False)
is_admin = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now())
reservations = db.relationship('Reservation', backref='user')
timeframes = db.relationship('Timeframes', backref='user')
@classmethod
def get_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def get_by_email(cls, email):
return cls.query.filter_by(email=email).first()
@classmethod
def get_by_id(cls, user_id):
return cls.query.filter_by(id=user_id).first()
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class distributionfigures_rrm(db.Model):
__tablename__ = 'distributionfigures_rrm'
id = db.Column(db.Integer, primary_key=True)
hh_reached = db.Column(db.Integer,
unique=False,
nullable=True,
primary_key=False)
distribution_point = db.Column(db.Integer,
db.ForeignKey('distribution_points2.id'),
nullable=False,
primary_key=False)
moomken = db.Column(db.Boolean())
wfp = db.Column(db.Boolean())
class distribution_points2(db.Model):
__tablename__ = 'distribution_points2'
id = db.Column(db.Integer, primary_key=True)
distributionpoint = db.Column(db.String(100))
partner = db.Column(db.String(80))
activity = db.Column(db.String(80))
idps = db.Column(db.Boolean())
returnees = db.Column(db.Boolean())
nondisplaced = db.Column(db.Boolean())
migrants = db.Column(db.Boolean())
comments = db.Column(db.String(100))
geom = db.Column(Geometry('POINT')) # PostGIS data type
mantika = db.Column(db.String(80))
baladiya = db.Column(db.String(80))
muhalla = db.Column(db.String(80))
class User(db.Model):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(100), nullable=False, unique=True)
email = db.Column(db.String(100), nullable=False, unique=True)
password = db.Column(db.String(200), nullable=False)
items = db.relationship("Item", backref="user")
rating = db.Column(db.Float())
profile_picture = db.Column(db.String(300), default=None)
is_admin = db.Column(db.Boolean(), default=False)
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())
#Funktio joka hakee käyttäjänimen mukaan
@classmethod
def get_by_username(cls, username):
return cls.query.filter_by(username=username).first()
#Funktio joka hakee sähköpostin mukaan
@classmethod
def get_by_email(cls, email):
return cls.query.filter_by(email=email).first()
# Funktio joka hakee käyttäjän id.n mukaan
@classmethod
def get_by_id(cls, id):
return cls.query.filter_by(id=id).first()
def save(self):
db.session.add(self)
db.session.commit()
class Workspace(db.Model):
__tablename__ = 'workspace'
id = db.Column(db.Integer, primary_key=True)
workspace_number = db.Column(db.String(30), nullable=False, unique=True)
turkuamk_only = db.Column(db.Boolean(), default=False)
available_space = db.Column(db.Integer)
def info(self):
return {
'id': self.id,
'workspace_number': self.workspace_number,
'turkuamk_only': self.turkuamk_only,
'available_space': self.available_space
}
@classmethod
def get_all(cls):
return cls.query.all()
@classmethod
def get_by_id(cls, workspace_id):
return cls.query.filter_by(id=workspace_id).first()
@classmethod
def get_by_number(cls, workspace_number):
return cls.query.filter_by(workspace_number=workspace_number).first()
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class User(BaseModelMixin):
"""User model to store user details"""
__tablename__ = 'users'
username = db.Column(db.String(100), default="")
email = db.Column(db.String(255), unique=True, nullable=False)
password_hash = db.Column(db.String(128), default="")
is_superuser = db.Column(db.Boolean(), default=False)
profile = db.relationship(
'Profile', backref="user", uselist=False, lazy=True
)
@property
def password(self):
raise AttributeError('password: write-only field')
@password.setter
def password(self, password):
self.password_hash = sha256.hash(password)
def check_password(self, password):
return sha256.verify(password, self.password_hash)
def __repr__(self):
return "<User '{}'>".format(self.email)
class Personel(db.Model):
__tablename__ = 'personel'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), nullable=False, unique=True)
firstname = db.Column(db.String(80))
lastname = db.Column(db.String(80))
email = db.Column(db.String(200), nullable=False, unique=True)
phone_number = db.Column(db.String(200))
role = db.Column(db.String(80))
password = db.Column(db.String(200))
is_active = db.Column(db.Boolean(), default=False)
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())
facilities = db.relationship('Facility', backref='personel')
animals = db.relationship('Animal', backref='personel')
@classmethod
def get_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def get_by_email(cls, email):
return cls.query.filter_by(email=email).first()
def save(self):
db.session.add(self)
db.session.commit()
class Equipment(db.Model):
mac_address = db.Column(db.String(), primary_key=True)
name = db.Column(db.StringField())
description = db.Column(db.StringField())
samppling_frequency = db.Column(db.IntField())
sensors = db.relationship('Sensor', backref='equipment', lazy=True)
available = db.Column(db.Boolean(True))
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), nullable=False, unique=True)
email = db.Column(db.String(200), nullable=False, unique=True)
password = db.Column(db.String(200))
is_active = db.Column(db.Boolean(), default=False)
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())
sheets = db.relationship('Sheet', backref='user')
@classmethod
def get_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def get_by_email(cls, email):
return cls.query.filter_by(email=email).first()
@classmethod
def get_by_id(cls, id):
return cls.query.filter_by(id=id).first()
def save(self):
db.session.add(self)
db.session.commit()
class Event(db.Model):
__table_name__ = "event"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
description = db.Column(db.String(200))
is_publish = db.Column(db.Boolean(), default=False)
event_date = db.Column(db.String(100))
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(),
)
user_id = db.Column(db.Integer(), db.ForeignKey("user.id"))
class Recipe(db.Model):
__tablename__ = 'recipe'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
description = db.Column(db.String(200))
num_of_servings = db.Column(db.Integer)
cook_time = db.Column(db.Integer)
directions = db.Column(db.String(1000))
is_publish = db.Column(db.Boolean(), default=False)
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())
user_id = db.Column(db.Integer(), db.ForeignKey("user.id"))
@classmethod
def get_all_published(cls):
return cls.query.filter_by(is_publish=True).all()
@classmethod
def get_by_id(cls, recipe_id):
return cls.query.filter_by(id=recipe_id).first()
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class User(db.Model):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), nullable=False)
email = db.Column(db.String(200), nullable=False)
password = db.Column(db.String(200))
is_active = db.Column(db.Boolean(), default=False)
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(),
)
recipes = db.relationship("Recipe", backref="user")
avatar_image = db.Column(db.String(100), default=None)
@classmethod
def get_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def get_by_email(cls, email):
return cls.query.filter_by(email=email).first()
def save(self):
db.session.add(self)
db.session.commit()
@classmethod
def get_by_id(cls, user_id):
return cls.query.get_or_404(user_id)
class BoothInfo(db.Model, CRUDMixin):
__tablename__ = 'corner_booth_info'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
booth_id = db.Column(db.String(255))
# Basic Info
booth_name = db.Column(db.String(255))
loc_text = db.Column(db.Text())
loc_lo = db.Column(db.String(255))
loc_la = db.Column(db.String(255))
city = db.Column(db.String(255))
district = db.Column(db.String(255))
business_district = db.Column(db.String(255))
phone_number = db.Column(db.String(255))
email = db.Column(db.String(255))
open_time = db.Column(db.String(255))
category = db.Column(db.String(255))
# About the owner
booth_owner = db.Column(db.String(255))
booth_story = db.Column(db.Text())
# Miscs
check_in_num = db.Column(db.Integer)
priority = db.Column(db.Integer)
create_time = db.Column(db.DateTime)
update_time = db.Column(db.DateTime)
create_by = db.Column(db.String(255))
disabled = db.Column(db.Boolean())
class Recipe(db.Model):
__tablename__ = 'recipe'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
description = db.Column(db.String(200))
num_of_servings = db.Column(db.Integer)
cook_time = db.Column(db.String(200))
directions = db.Column(db.String(100))
is_publish = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now())
update_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now(),
onupdate=db.func.now())
cover_image = db.Column(db.String(100), default=None)
ingredients = db.Column(db.String(1000))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
@classmethod
def get_all_published(cls, q, page, per_page, sort, order):
keyword = f'%{q}%'
if order == 'asc':
sort_logic = asc(getattr(cls, sort))
else:
sort_logic = desc(getattr(cls, sort))
return cls.query.filter(or_(
cls.name.ilike(keyword),
cls.description.ilike(keyword),
cls.ingredients.ilike(keyword)),
cls.is_publish.is_(True)). \
order_by(sort_logic).paginate(page=page, per_page=per_page, max_per_page=20)
@classmethod
def get_all_by_user(cls, user_id, page, per_page, visibility='public'):
query = cls.query.filter_by(user_id=user_id)
if visibility == 'public':
query = cls.query.filter_by(user_id=user_id, is_publish=True)
elif visibility == 'private':
query = cls.query.filter_by(user_id=user_id, is_publish=False)
return query.order_by(desc(cls.created_at)).paginate(page=page,
per_page=per_page,
max_per_page=20)
@classmethod
def get_by_id(cls, recipe_id):
return cls.query.filter_by(id=recipe_id).first()
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Product(db.Model):
__tablename__ = 'products'
productID = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(64), index=True)
description = db.Column(db.String(120))
price = db.Column(db.Numeric(scale=2))
is_available = db.Column(db.Boolean(), default=True)
supplier_ID = db.Column(db.Integer(), ForeignKey('suppliers.supplierID'))
class Event(db.Model):
__tablename__ = 'events'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
location = db.Column(db.String(100))
description = db.Column(db.String(1000), nullable=False)
start_time = db.Column(db.DateTime(), nullable=False)
end_time = db.Column(db.DateTime(), nullable=False)
is_publish = db.Column(db.Boolean(), default=False)
is_delete = db.Column(db.Boolean(), default=False)
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())
users = db.relationship(
'User',
secondary=EventSignup.__tablename__,
back_populates='events',
)
@classmethod
def active_list(cls, target_dt):
# TODO stop signup x minutes ahead of end_time
return cls.query \
.filter(Event.is_publish == True) \
.filter(Event.start_time < target_dt) \
.filter(Event.end_time > target_dt) \
.all()
@classmethod
def get_by_id(cls, event_id):
return cls.query \
.filter(Event.id == event_id) \
.filter(Event.is_delete == False) \
.filter(Event.is_publish == True) \
.first()
def save(self):
db.session.add(self)
db.session.commit()
class Order(db.Model):
__tablename__ = 'orders'
orderID = db.Column(db.Integer(), primary_key=True)
wasOrdered = db.Column(db.Boolean(), unique=False, default=False)
wasAccepted = db.Column(db.Boolean(), default=False)
dateOrdered = db.Column(db.DateTime(),
server_default=func.now(),
index=True)
wasFulfilled = db.Column(db.Boolean(), unique=False, default=False)
total = db.Column(db.Numeric(scale=2))
customer_ID = db.Column(db.Integer(),
db.ForeignKey('customers.customerID'))
payment_ID = db.Column(db.Integer(), db.ForeignKey('payments.paymentID'))
shipper_ID = db.Column(db.Integer(), db.ForeignKey('shippers.shipperID'))
supplier_ID = db.Column(db.Integer(),
db.ForeignKey('suppliers.supplierID'))
order_details = db.relationship('OrderDetails', backref='order')
class User(UserMixin, db.Model):
__tablename__ = 'users'
__searchable__ = ['name']
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(700), unique=True)
confirmed_email = db.Column(db.Boolean(), default=False)
join_date = db.Column(db.String(300), default='')
password = db.Column(db.String(100))
name = db.Column(db.String(1000))
admin = db.Column(db.Boolean(), default=False)
author = db.Column(db.Boolean(), default=False)
posts = relationship("BlogPost", back_populates="author")
comments = relationship("Comment", back_populates="author")
replies = relationship("Reply", back_populates="author")
api_key = relationship("ApiKey", back_populates="developer")
deletion_report = relationship('DeletionReport', back_populates='user')
notifications = relationship("Notification", back_populates='user')
logs = relationship("Log", back_populates='user')
class Workspace(db.Model):
__tablename__ = 'workspace'
id = db.Column(db.Integer, primary_key=True) # generoitu
name = db.Column(db.String(100), nullable=False) # huoneen nimi, esim. Alpha tai B1032
workspace_type = db.Column(db.String(100), nullable=False) # esim. luentosali, kaytava, luokka
size = db.Column(db.Integer) # työtilan arvioitu kantokyky
address = db.Column(db.String(100)) # esim. lemminkäisenkatu, ICT-talo, Joukahaisenkatu
is_publish = db.Column(db.Boolean(), default=False)
class ParkingSpot(db.Model):
__tablename__ = 'parking_spots'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(255), nullable=False)
city = db.Column(db.String(255), nullable=False)
address = db.Column(db.String(255), nullable=False)
available = db.Column(db.Boolean(), nullable=False, default=False)
idUser = db.Column(db.Integer(),
db.ForeignKey('users.id', ondelete='CASCADE'))
class BoothImages(db.Model, CRUDMixin):
__tablename__ = 'corner_booth_images'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
booth_id = db.Column(db.String(255))
image_path = db.Column(db.String(255))
flag = db.Column(db.String(255))
create_time = db.Column(db.DateTime)
disabled = db.Column(db.Boolean())
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
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'))
class Comment(db.Model):
__tablename__ = 'comment'
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.String(500), nullable=False)
# created = db.Column(db.DateTime(timezone=True), nullable=False)
# modified = db.Column(db.DateTime(timezone=True), nullable=False)
created = db.Column(ArrowType, nullable=False)
modified = db.Column(ArrowType, nullable=False)
# http://docs.sqlalchemy.org/en/rel_1_0/orm/basic_relationships.html
thread_id = db.Column(db.Integer,
db.ForeignKey('thread.id'),
nullable=False)
author_id = db.Column(db.Integer,
db.ForeignKey('author.id'),
nullable=False)
likes = db.Column(db.Integer, default=0)
dislikes = db.Column(db.Integer, default=0)
parent_id = db.Column(db.Integer,
db.ForeignKey('comment.id'),
nullable=True)
children = db.relationship('Comment',
backref=db.backref('parent', remote_side=[id]))
hidden = db.Column(db.Boolean(), default=False)
def set_vote(self, author_id, like):
vote = db.session.query(Vote).filter_by(comment_id=self.id,
author_id=author_id).first()
if vote:
if vote.like == like:
# Vote exists and is the same
return True
else:
# Vote exists but changed
vote.like = like
if like:
# changed to a like
self.likes += 1
self.dislikes -= 1
else:
# changed to a dislike
self.likes -= 1
self.dislikes += 1
else:
# New vote
vote = Vote(comment_id=self.id, author_id=author_id, like=like)
db.session.add(vote)
if like:
self.likes += 1
else:
self.dislikes += 1
db.session.commit()
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer(), primary_key=True)
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=UsersRoles,
backref=db.backref('users', lazy='dynamic'))
def __str__(self):
return self.email
class Recipe(db.Model):
__tablename__ = 'recipe'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
description = db.Column(db.String(200))
num_of_servings = db.Column(db.Integer)
cook_time = db.Column(db.Integer)
directions = db.Column(db.String(1000))
is_publish = db.Column(db.Boolean(), default=False)
cover_image = db.Column(db.String(100), default=None)
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())
user_id = db.Column(db.Integer(), db.ForeignKey("user.id"))
@classmethod
def get_all_published(cls, page, per_page):
return cls.query.filter_by(is_publish=True).order_by(
desc(cls.created_at)).paginate(page=page, per_page=per_page)
@classmethod
def get_all_by_user(cls, user_id, page, per_page, visibility='public'):
query = cls.query.filter_by(user_id=user_id)
if visibility == 'public':
query = cls.query.filter_by(user_id=user_id, is_publish=True)
elif visibility == 'private':
query = cls.query.filter_by(user_id=user_id, is_publish=False)
return query.order_by(desc(cls.created_at)).paginate(page=page,
per_page=per_page)
@classmethod
def get_by_id(cls, recipe_id):
return cls.query.filter_by(id=recipe_id).first()
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Reservation_A(db.Model):
__tablename__ = 'RoomA_Booking'
Room_A_id = db.Column(db.Integer, primary_key=True)
Room_A_name = db.Column(db.String(100), default='Room A')
Room_A_is_reserved = db.Column(db.Boolean(), default=False)
#Room_A_date = db.Column(db.DateTime(), nullable=False)
#ToDo : Check the type of the data in the following statement
Room_A_start_time = db.Column(db.String(20), nullable=False)
Room_A_end_time = db.Column(db.String(20), nullable=False)
Room_A_teacher_id = db.Column(db.Integer(), db.ForeignKey("teacher.teacher_id"))
Room_A_student_id = db.Column(db.Integer(), db.ForeignKey("student.student_id"))
def data(self):
return{
'Room_A_id': self.Room_A_id,
'Room_A_name': self.Room_A_name,
'Room_A_is_reserved': self.Room_A_is_reserved,
## TODO: CHeck if we can overcome date field serialization
#'Room_A_date': self.Room_A_date,
'Room_A_start_time': self.Room_A_start_time,
'Room_A_end_time': self.Room_A_end_time,
'Room_A_teacher_id': self.Room_A_teacher_id,
'Room_A_student_id': self.Room_A_student_id
}
@classmethod
### checking all the reservations of the rooms A done by the user
### checking all the reservations of the rooms A done by the user
def get_all_reserved(cls):
return cls.query.filter_by(Room_A_is_reserved=True).all()
@classmethod
##checking all the rooms with no reservation
def get_all_not_reserved(cls):
return cls.query.filter_by(Room_A_is_reserved=False).all()
@classmethod
### getting the reservations of the room by id
def get_by_id(cls, Room_A_id):
return cls.query.filter_by(Room_A_id=Room_A_id).first()
def save(self):
db.session.add(self)
db.session.commit()
class Vote(db.Model):
'''Association table for votes.'''
__tablename__ = 'votes'
comment_id = db.Column(db.Integer,
db.ForeignKey('comment.id'),
primary_key=True)
author_id = db.Column(db.Integer,
db.ForeignKey('author.id'),
primary_key=True)
like = db.Column(db.Boolean(), nullable=False)
author = db.relationship("Author", backref="votes")
comment = db.relationship("Comment",
backref=db.backref("votes",
single_parent=True,
cascade="all, delete-orphan"))
class NewsletterSubscription(db.Model):
__tablename__ = 'newsletter_subscriptions'
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(300), nullable=False)
last_name = db.Column(db.String(300), nullable=False)
email = db.Column(db.String(700), nullable=False, unique=True)
active = db.Column(db.Boolean(), default=False)
unsubscription_reason = db.Column(db.String(700), default='')
unsubscription_explanation = db.Column(db.String(3000), default='')
unsubscription_date = db.Column(db.String(300), default='')
date = db.Column(db.String(300), nullable=False)
__mapper_args__ = {
"order_by": id.desc()
}
