class Class(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(250), nullable=False)
photo = db.Column(db.String(250), nullable=True)
institution_id = db.Column(db.Integer,
db.ForeignKey('institution.id'),
nullable=False)
students = db.relationship(Student,
secondary=relation_student_class,
backref='classes')
grades = db.relationship('Grade',
backref='class',
lazy=True,
cascade="all, delete-orphan")
attendances = db.relationship('Attendance',
backref='class',
lazy=True,
cascade="all, delete-orphan")
events = db.relationship('Event',
backref='class',
lazy=True,
cascade="all, delete-orphan")
class SpaceAccessGroup(db.Model):
__tablename__ = 'spaceaccess_groups'
id = db.Column(db.Integer, primary_key=True)
users = db.relationship(
"User",
backref=db.backref("spaceaccess_accessgroup", uselist=False, lazy=True),
secondary=AccessgroupUserMap.__tablename__,
lazy='subquery',
)
spaces = db.relationship(
"SpaceAccessSpace",
backref=db.backref("spaceaccess_accessgroup", lazy=True),
secondary=AccessgroupSpaceMap.__tablename__,
lazy='subquery',
)
name = db.Column(db.String(120), default="")
note = db.Column(db.String(120), default="")
access_type = db.Column(db.Enum(SpaceAccessType), default=SpaceAccessType.NO_ACCESS)
entry_accounting_type = db.Column(db.Enum(SpaceAccessEntryAccounting), default=SpaceAccessEntryAccounting.DAYS)
access_need_budget = db.Column(db.Boolean, default=False)
access_gets_recharged = db.Column(db.Boolean, default=False)
access_recharge_budget_amount = db.Column(db.Integer, default=15)
access_recharge_budget_period = db.Column(db.Enum(SpaceAccessRechargePeriod),
default=SpaceAccessRechargePeriod.MONTHS)
access_recharge_budget_every_periods = db.Column(db.Integer, default=4)
access_recharge_budget_get_cutoff = db.Column(db.Boolean, default=True)
access_recharge_budget_cutoff_max = db.Column(db.Integer, default=15)
access_expires_as_default = db.Column(db.Boolean, default=False)
access_expires_default_days = db.Column(db.Integer, default=365)
access_use_group_budget = db.Column(db.Boolean, default=False)
last_access_at = db.Column(ArrowType, default=None)
group_budget = db.Column(db.Integer, default=0)
day_access_mask = db.Column(db.Integer, default=127)
daily_access_start_time = db.Column(ArrowType, default=arrow.get('00:00', 'HH:mm'))
daily_access_end_time = db.Column(ArrowType, default=arrow.get('23:59', 'HH:mm'))
class Student(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(250), nullable=False)
cpf = db.Column(db.String(50), nullable=False)
phone = db.Column(db.String(50), nullable=False)
email = db.Column(db.String(250), unique=True, nullable=False)
photo = db.Column(db.String(250), nullable=True)
grades = db.relationship('Grade',
backref='student',
lazy=True,
cascade="all, delete-orphan")
attendances = db.relationship('Attendance',
backref='student',
lazy=True,
cascade="all, delete-orphan")
def __repr__(self):
return self.email
class Vendor(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20), nullable=False)
password = db.Column(db.String(15), nullable=False)
location = db.Column(db.String(20), nullable=False)
Email = db.Column(db.String(20), nullable=False, unique=True)
company_number = db.Column(db.Integer, unique=True, nullable=False)
product = db.relationship("Product", backref="vendor", lazy=True)
sales = db.relationship("Sales", backref="sales", lazy=True)
class Order(db.Model, SearchMixin):
"""Represents a transfer of inventory from one entity to another."""
id = db.Column(db.Integer, primary_key=True)
source_id = db.Column(db.Integer,
db.ForeignKey('entity.id', ondelete='RESTRICT'),
nullable=False)
dest_id = db.Column(db.Integer,
db.ForeignKey('entity.id', ondelete='RESTRICT'))
date = db.Column(db.DateTime, default=db.func.now())
order_number = db.Column(db.String(64))
source = db.relationship(
'Entity',
primaryjoin='Order.source_id == Entity.id',
back_populates='orders_from',
)
destination = db.relationship('Entity',
primaryjoin='Order.dest_id == Entity.id',
back_populates='orders_to')
items = db.relationship('OrderItem',
back_populates='order',
passive_deletes=True)
shipments = db.relationship('Shipment', back_populates='order')
financials = db.relationship('OrderEvent', back_populates='order')
def __repr__(self):
src_name = self.source.name if self.source else None
dest_name = self.destination.name if self.destination else None
return f'<{type(self).__name__} ({self.id}) {self.order_number} {src_name} -> {dest_name}>'
def send_inventory(self):
for item in self.items:
item.send_inventory()
def receive_inventory(self):
for item in self.items:
item.receive_inventory()
def charge_account(self, account):
for item in self.items:
item.charge_account(account)
def charge_transfer(self, account):
for item in self.items:
item.charge_transfer(account)
@property
def total(self):
order_cost = sum(e.net for e in self.financials)
item_cost = sum(sum(e.net for e in i.financials) for i in self.items)
return order_cost + item_cost
def profit(self):
profits = [i.profit() for i in self.items]
profits = [p for p in profits if p is not None]
return sum(profits)
class Relationship(db.Model, PolymorphicMixin):
"""Describes a many-to-one relationship between listings."""
id = db.Column(db.Integer, primary_key=True)
listing_id = db.Column(db.Integer,
db.ForeignKey('listing.id', ondelete='CASCADE'),
nullable=False)
listing = db.relationship('Listing')
sources = db.relationship('RelationshipSource',
back_populates='relationship')
class GameModel(db.Model):
__tablename__ = 'games'
id = db.Column(db.String(), primary_key=True)
home_team = db.Column(db.String())
away_team = db.Column(db.String())
game_status = db.Column(db.String())
winning_team = db.Column(db.String())
home_team_score = db.Column(db.Integer, nullable=False)
away_team_score = db.Column(db.Integer, nullable=False)
drive = db.relationship('DriveModel')
series = db.relationship('SeriesModel')
plays = db.relationship('PlayModel')
def __init__(self, id, home_team, away_team, game_status, home_team_score=0, away_team_score=0, winning_team=None):
self.id = id
self.home_team = home_team
self.away_team = away_team
self.game_status = game_status
self.winning_team = winning_team
self.home_team_score = home_team_score
self.away_team_score = away_team_score
def get_description(self):
desc = ''
if (self.game_status == 'pending'):
desc = desc + 'Game in progress. '
if (self.home_team_score > self.away_team_score):
desc = desc + f'{self.home_team} is winning against {self.away_team}, {self.home_team_score} to {self.away_team_score}.'
else:
desc = desc + f'{self.away_team} is winning against {self.home_team}, {self.away_team_score} to {self.home_team_score}.'
else:
desc = desc + 'Game complete. '
if (self.home_team_score > self.away_team_score):
desc = desc + f'{self.home_team} beat {self.away_team}, {self.home_team_score} to {self.away_team_score}.'
else:
desc = desc + f'{self.away_team} beat {self.home_team}, {self.away_team_score} to {self.home_team_score}.'
return desc
def toJSON(self):
return {
'type': 'game',
'id': self.id,
'home_team': self.home_team,
'away_team': self.away_team,
'game_status': self.game_status,
'winning_team': self.winning_team,
'home_team_score': self.home_team_score,
'away_team_score': self.away_team_score,
'desc': self.get_description()
}
class Customer(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(20), nullable=False)
last_name = db.Column(db.String(20), nullable=False)
password = db.Column(db.String(15), nullable=False)
Address = db.Column(db.String(50))
Email = db.Column(db.String(50), nullable=False, unique=True)
phone_number = db.Column(db.Integer, unique=True, nullable=False)
order = db.relationship("Order", backref="customer", lazy=True)
reviewer = db.relationship("Review", backref="customer", lazy=True)
def __repr__():
pass
class Tweet(db.Model):
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.Text)
# One to many relationship
author_id = db.Column(db.Integer,
db.ForeignKey("user.id", ondelete="cascade"),
nullable=False)
author = db.relationship('User',
foreign_keys=[author_id],
backref='user_tweets')
# many to many relationship to users
users_who_like_this_tweet = db.relationship('User', secondary=likes_table)
class FinancialEvent(db.Model, PolymorphicMixin, SearchMixin):
"""Represents a financial event, like a debit or credit."""
id = db.Column(db.Integer, primary_key=True)
account_id = db.Column(db.Integer, db.ForeignKey('financial_account.id', ondelete='CASCADE'), nullable=False)
originator_id = db.Column(db.Integer, db.ForeignKey('entity.id'))
date = db.Column(db.DateTime, default=lambda: datetime.utcnow())
net = db.Column(CURRENCY)
description = db.Column(db.Text)
account = db.relationship('FinancialAccount', back_populates='events')
originator = db.relationship('Entity', back_populates='financials')
def __repr__(self):
return f'<{type(self).__name__} {self.net} {self.description}>'
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)
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}')"
return "User('{}', '{}', '{}')".format({self.username}, {self.email},
{self.image_file})
class Menu(db.Model):
__tablename__ = 'menu'
menu_id = db.Column(db.Integer, primary_key=True)
category_id = db.Column(db.Integer, db.ForeignKey('category.category_id'))
item_name = db.Column(db.String)
description = db.Column(db.String)
price = db.Column(db.Integer)
visibility = db.Column(db.Boolean)
position_in_menu = db.Column(db.Integer)
date_added = db.Column(db.DateTime)
total_calories = db.Column(db.Integer)
discount = db.Column(db.Integer)
category = db.relationship('Category')
imgfile = db.Column(db.String)
def __init__(self, category_id, item_name, description, price,
position_in_menu, imgfile):
self.category_id = category_id
self.item_name = item_name
self.description = description
self.price = price
self.visibility = True
self.position_in_menu = position_in_menu
self.total_calories = 0
self.discount = 0
self.imgfile = imgfile
class FinancialAccount(db.Model, SearchMixin):
"""A collection of FinancialEvenets."""
id = db.Column(db.Integer, primary_key=True)
owner_id = db.Column(db.Integer, db.ForeignKey('entity.id', ondelete='CASCADE'), nullable=False)
name = db.Column(db.String(64))
owner = db.relationship('Entity', back_populates='accounts')
events = db.relationship('FinancialEvent', back_populates='account', passive_deletes=True)
def __repr__(self):
owner_name = self.owner.name if self.owner else None
return f'<{type(self).__name__} {owner_name} {self.name}>'
@property
def balance(self):
return sum(e.net for e in self.events)
class Order(db.Model):
id = db.Column(db.Integer, primary_key=True)
sales = db.relationship("Sales", backref="orders", lazy=True)
consumer_id = db.Column(db.Integer, db.ForeignKey("customer.id"))
quantity = db.Column(db.Integer, nullable=False)
vendor_id = db.Column(db.Integer, db.ForeignKey("vendor.id"))
product_id = db.Column(db.Integer, db.ForeignKey("product.id"))
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
role = db.Column(db.String(20), nullable=False, default='user')
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(255))
cash = db.Column(db.Numeric, nullable=False, default=10000.00)
posts = db.relationship('Post', backref='author', lazy=True)
# Methods used to change password via email. Token will expire after 1800s (30mins)
# s is a Serializer object within the method
# Returns a token
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):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(45))
last_name = db.Column(db.String(45))
email = db.Column(db.String(45))
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime, server_default=func.now(), onupdate=func.now())
# c stands for column
right_users = db.relationship("User",
secondary="user_to_user",
primaryjoin="User.id==user_to_user.c.left_user_id",
secondaryjoin="User.id==user_to_user.c.right_user_id",
backref="left_users")
tweets_this_user_likes = db.relationship('Tweet', secondary=likes_table)
class Paciente(db.Model):
__tablename__ = "pacientes"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
dataNascimento = db.Column(db.String)
sexo = db.Column(db.String(1))
cidade = db.Column(db.String(50))
profissao = db.Column(db.String(50))
objetivo = db.Column(db.String(50))
user = db.relationship('User', foreign_keys=user_id)
def __init__(self, username, password, name, email, celular, dataNascimento, sexo, cidade, profissao, objetivo):
u = User(username, password, name, email, celular, "P")
db.session.add(u)
db.session.commit()
self.user_id = u.id
self.dataNascimento = dataNascimento
self.sexo = sexo
self.cidade = cidade
self.profissao = profissao
self.objetivo = objetivo
def __repr__(self):
return "<Paciente {0}>".format(self.user.username)
class Country(db.Model):
"""
A location where humans are listed, using geoid for primary key.
"""
__tablename__ = 'countries'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30))
code = db.Column(db.String(5))
phone = db.Column(db.String(10))
slug = db.Column(db.String(120))
icon = db.Column(db.String(120))
users = db.relationship('Profile', backref='countries', lazy='dynamic')
def __init__(self, id, code, name, phone):
self.id = id
self.code = code
self.name = name
self.phone = phone
self.slug = slugify(self.name)
def __repr__(self):
return '<Country %r>' % (self.name)
def count_cities(self):
rs = self.city
return rs.count()
class Actor(Model, db.Model):
__tablename__ = 'actors'
__name__ = 'Actor'
# id -> integer, primary key
id = db.Column(db.Integer, primary_key=True)
# name -> string, size 50, unique, not nullable
name = db.Column(db.String(50), unique=True)
# gender -> string, size 11
gender = db.Column(db.String(11))
# date_of_birth -> date
date_of_birth = db.Column(db.Date)
# Use `db.relationship` method to define the Actor's relationship with Movie.
# Set `backref` as 'cast', uselist=True
# Set `secondary` as 'association'
movies = db.relationship(
'Movie',
secondary=association,
backref='cast',
uselist=True,
)
def __repr__(self):
return '<Actor {}>'.format(self.name)
class Photo(db.Model):
id = db.Column(db.Integer, primary_key=True)
albumId = db.Column(db.Integer, db.ForeignKey('album.id'))
album = db.relationship('Album', backref='photos')
title = db.Column(db.String(40), nullable=False)
url = db.Column(db.String(40), nullable=False)
thumbnailUrl = db.Column(db.String(40), nullable=False)
@staticmethod
def save(**kwargs):
photo = Photo(**kwargs)
db.session.add(photo)
db.session.commit()
return photo
@staticmethod
def update(id, **kwargs):
photo = Photo.query.filter_by(id=id).update(kwargs)
db.session.commit()
return Photo.query.get(id)
@staticmethod
def delete(photo):
db.session.delete(photo)
db.session.commit()
return True
class Todo(db.Model):
id = db.Column(db.Integer, primary_key=True)
userId = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User', backref='todos')
title = db.Column(db.String(40), nullable=False)
completed = db.Column(db.Boolean(), default=False)
@staticmethod
def save(user_id, **kwargs):
todo = Todo(userId=user_id, **kwargs)
db.session.add(todo)
db.session.commit()
return todo
@staticmethod
def update(id, **kwargs):
todo = Todo.query.filter_by(id=id).update(kwargs)
db.session.commit()
return Todo.query.get(id)
@staticmethod
def delete(todo):
db.session.delete(todo)
db.session.commit()
return True
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
userId = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User', backref='posts')
title = db.Column(db.String(40), nullable=False)
body = db.Column(db.Text(), nullable=False)
@staticmethod
def save(user_id, **kwargs):
post = Post(userId=user_id, **kwargs)
db.session.add(post)
db.session.commit()
return post
@staticmethod
def update(id, **kwargs):
post = Post.query.filter_by(id=id).update(kwargs)
if post:
db.session.commit()
return Post.query.filter_by(id=id).first()
@staticmethod
def delete(post):
db.session.delete(post)
db.session.commit()
return True
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
postId = db.Column(db.Integer, db.ForeignKey('post.id'))
post = db.relationship('Post', backref='comments')
name = db.Column(db.String(40), nullable=False)
email = db.Column(db.String(20), nullable=False)
body = db.Column(db.Text(), nullable=False)
@staticmethod
def save(**kwargs):
comment = Comment(**kwargs)
db.session.add(comment)
db.session.commit()
return comment
@staticmethod
def update(id, **kwargs):
comment = Comment.query.filter_by(id=id).update(kwargs)
db.session.commit()
return Comment.query.get(id)
@staticmethod
def delete(comment):
db.session.delete(comment)
db.session.commit()
return True
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(128), index=True, unique=True)
password_hash = db.Column(db.String(128))
posts = db.relationship("Post", backref="author", lazy="dynamic")
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
def __repr__(self):
return "<User {}>".format(self.username)
#end __repr__
def set_password(self, password):
self.password_hash = generate_password_hash(password)
#end set_password
def check_password(self, password):
return check_password_hash(self.password_hash, password)
#end check_password
def avatar(self, size):
digest = md5(self.email.lower().encode("utf-8")).hexdigest()
return "https://www.gravatar.com/avatar/{hash}?d=retro&s={size}".format(
hash=digest, size=size)
class RelationshipSource(db.Model, PolymorphicMixin):
"""A listing on the 'many' side of the relationship."""
id = db.Column(db.Integer, primary_key=True)
relationship_id = db.Column(db.Integer,
db.ForeignKey('relationship.id',
ondelete='CASCADE'),
nullable=False)
listing_id = db.Column(db.Integer,
db.ForeignKey('listing.id', ondelete='CASCADE'),
nullable=False)
units = db.Column(CURRENCY, nullable=False, default=1)
relationship = db.relationship('Relationship', back_populates='sources')
listing = db.relationship('Listing')
__table_args__ = (UniqueConstraint('relationship_id', 'listing_id'), )
class CTI(db.Model):
__tablename__ = 'cti'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(100))
timestamp = db.Column(db.DateTime, default=db.func.current_timestamp())
status = db.Column(db.Integer)
events = db.relationship("Event", lazy=True)
features = db.relationship("Feature",
secondary=mtm_cti_feature,
backref=db.backref('cti', lazy=True))
classifications = db.relationship("Classification")
def __init__(self, name=None):
self.name = name
self.status = CTI_STATUS['NEW']
def get_status_name(self):
for key in CTI_STATUS:
if self.status == CTI_STATUS[key]:
return key
return None
def get_top_classification(self):
max_prob = 0
top_class = None
for classification in self.classifications:
if max_prob < classification.probability:
max_prob = classification.probability
top_class = classification
return top_class
def get_chart_data(self):
targets = []
probs = []
for classification in self.classifications:
targets.append(classification.actor.name)
probs.append(round(classification.probability * 100, 1))
return json.dumps({"labels": targets, "data": probs})
def __repr__(self):
return '<CTI {}>'.format(self.id)
class Shipment(db.Model, SearchMixin):
"""An shipment of products."""
id = db.Column(db.Integer, primary_key=True)
order_id = db.Column(db.Integer,
db.ForeignKey('order.id', ondelete='CASCADE'),
nullable=False)
created_on = db.Column(db.DateTime, default=db.func.now())
updated_on = db.Column(db.DateTime,
default=db.func.now(),
onupdate=lambda: datetime.utcnow())
carrier = db.Column(db.String(64))
tracking_number = db.Column(db.String(128))
delivered_on = db.Column(db.DateTime)
status = db.Column(db.String(32))
order = db.relationship('Order', back_populates='shipments')
items = db.relationship('OrderItem', back_populates='shipment')
class Product(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
price = db.Column(db.Integer, nullable=False)
quantity = db.Column(db.Integer, nullable=False)
description = db.Column(db.String(100), default="No description")
image_url = db.Column(db.String(50), default="default.jpg")
restaurant_id = db.Column(db.Integer, db.ForeignKey("vendor.id"))
orders = db.relationship("Order", backref="products", lazy=True)
category = db.relationship("Category",
secondary="categories",
lazy="subquery",
backref=db.backref("items", lazy=True))
rating = db.relationship("Review",
secondary="ratings",
lazy="subquery",
backref=db.backref("product", lazy=True))
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')
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 = ['']
def delete(self):
db.session.delete(self)
db.session.commit()
@staticmethod
def find(access_token=None, refresh_token=None):
if access_token:
return Token.query.filter_by(access_token=access_token).first()
elif refresh_token:
return Token.query.filter_by(refresh_token=refresh_token).first()
@staticmethod
def save(token, request, *args, **kwargs):
toks = Token.query.filter_by(client_id=request.client.client_id,
user_id=request.user.id)
[db.session.delete(t) for t in toks]
expires_in = token.pop('expires_in')
expires = datetime.utcnow() + timedelta(seconds=expires_in)
tok = Token(
access_token=token['access_token'],
refresh_token=token['refresh_token'],
token_type=token['token_type'],
expires=expires,
client_id=request.client.client_id,
user_id=request.user.id,
)
db.session.add(tok)
db.session.commit()
class Author(db.Model):
__tablename__ = 'author'
# primary key
author_id = db.Column(db.Integer, primary_key=True)
# relations
books = db.relationship('Book', backref='author',
lazy='dynamic')
# foreign keys
user_id = db.Column(db.String, db.ForeignKey('app_users.user_id'))
# other columns
name = db.Column(db.String, nullable=False, unique=True)
bio = db.Column(db.String, nullable=False)
picture = db.Column(db.String, nullable=False)
website = db.Column(db.String, nullable=False)
blog = db.Column(db.String, nullable=False)
twitter_id = db.Column(db.String, nullable=False)
slug = db.Column(db.String, nullable=False, unique=True)
def __init__(self, name, bio, picture, website, blog, twitter_id):
self.name = name
self.bio = bio
self.picture = picture
self.website = website
self.blog = blog
self.twitter_id = twitter_id
self.slug = slugify(name)
@staticmethod
def author_from_dict(**kwargs):
return Author(kwargs.get('name', ""),
kwargs.get('bio', ""),
kwargs.get('picture', ""),
kwargs.get('website', ""),
kwargs.get('blog', ""),
kwargs.get('twitter_id', ""))
def update_name(self, name):
self.name = name
self.slug = slugify(name)
try:
db.session.commit()
except:
# TODO flash error message
db.session.rollback()
def __repr__(self):
return '<author {}>'.format(self.name)
def as_dict(self):
return { 'author_id': self.author_id,
'uri': url_for('author_routes.authorpage', author_slug=self.slug, _external=True),
'name': self.name,
'slug': self.slug }
