class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
index = db.Column(db.String(64))
default = db.Column(db.Boolean, default=False, index=True)
permissions = db.Column(db.Integer)
users = db.relationship('User', backref='role', lazy='dynamic')
@staticmethod
def insert_roles():
roles = {
'User': (Permission.GENERAL, 'main', True),
'Administrator': (
Permission.ADMINISTER,
'admin',
False # grants all permissions
)
}
for r in roles:
role = Role.query.filter_by(name=r).first()
if role is None:
role = Role(name=r)
role.permissions = roles[r][0]
role.index = roles[r][1]
role.default = roles[r][2]
db.session.add(role)
db.session.commit()
def __repr__(self):
return '<Role \'%s\'>' % self.name
class Article(db.Model):
__tablename__ = 'articles'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.Unicode(64))
topic = db.Column(db.Unicode(64))
body = db.Column(db.Unicode(1024))
timestamp = db.Column(db.DateTime, index=True)
class BaseModel(db.Model):
__abstract__ = True
id = db.Column(db.Integer(), primary_key=True)
is_deleted = db.Column(db.Boolean, default=False, nullable=False)
created_at = db.Column(db.DateTime(), default=datetime.now())
updated_at = db.Column(db.DateTime(), default=datetime.now(), onupdate=datetime.now())
def save(self):
try:
db.session.add(self)
db.session.commit()
except (exc.IntegrityError, exc.InvalidRequestError):
db.session().rollback()
def delete(self):
db.session.delete(self)
db.session.commit()
def serialize(self, excluded=[], with_timestamp=True):
excluded = excluded + ['created_at', 'updated_at', 'password', 'is_deleted', 'activation_code', 'auth_key']
s = {to_camel_case(column.name): getattr(self, column.name) for column in self.__table__.columns if column.name not in excluded}
if with_timestamp:
s['timestamps'] = {'createdAt': format_response_timestamp(self.created_at), 'updatedAt': format_response_timestamp(self.updated_at)}
return s
class MProductVariant(db.Model):
__tablename__ = 'marketplace_product_variants'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
variant_id = db.Column(db.Integer, db.ForeignKey('marketplace_variants.id', ondelete="CASCADE"))
product_id = db.Column(db.Integer, db.ForeignKey('marketplace_products.id', ondelete="CASCADE"))
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime, default=db.func.now(), onupdate=db.func.now())
class BaseModel(db.Model):
__abstract__ = True
id = db.Column(db.Integer(), primary_key=True)
is_deleted = db.Column(db.Boolean, default=False, nullable=False)
created_at = db.Column(db.DateTime(), default=datetime.now())
updated_at = db.Column(db.DateTime(),
default=datetime.now(),
onupdate=datetime.now())
def save(self):
try:
db.session.add(self)
db.session.commit()
except (exc.IntegrityError, exc.InvalidRequestError):
db.session().rollback()
def delete(self):
db.session.delete(self)
db.session.commit()
def serialize(self):
s = {
to_camel_case(column.name): getattr(self, column.name)
for column in self.__table__.columns
if column.name not in ['created_at', 'updated_at']
}
s['timestamps'] = {
'created_at': self.created_at,
'updated_at': self.updated_at
}
return s
class BlogNewsLetter(db.Model):
__tablename__ = 'blog_news_letters'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(64), default=None, nullable=True, unique=True)
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
class BlogTag(db.Model):
__tablename__ = 'blog_tags'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(), default=None, nullable=False)
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
class MVariant(db.Model):
__tablename__ = 'marketplace_variants'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String())
symbol = db.Column(db.String())
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime, default=db.func.now(), onupdate=db.func.now())
class MBrand(db.Model):
__tablename__ = 'marketplace_brands'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(), default=None, nullable=False)
image = db.Column(db.Text)
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime, default=db.func.now(), onupdate=db.func.now())
class Recipient(db.Model, SaveMixin):
id_email_received_model = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(256), nullable=False)
subject = db.Column(db.String(256), nullable=False)
body = db.Column(db.Text, nullable=False)
create_ts = db.Column(db.DateTime, nullable=False, default=datetime.now())
def __repr__(self):
return "<EmailReceiverModel: {} {}>".format(self.email, self.subject)
class MSellerOrder(db.Model):
__tablename__ = 'marketplace_seller_orders'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
order_id = db.Column(db.Integer, db.ForeignKey('marketplace_orders.id', ondelete="CASCADE"))
seller_id = db.Column(db.Integer, db.ForeignKey('users.id', ondelete="CASCADE"))
order_status = db.Column(db.Integer, default=0)
shipping_method_id = db.Column(db.Integer, db.ForeignKey('marketplace_shipping_methods.id', ondelete="CASCADE"),
nullable=True, default=None)
buyer_id = db.Column(db.Integer, db.ForeignKey('users.id', ondelete="CASCADE"))
current_currency_id = db.Column(db.Integer, db.ForeignKey('marketplace_currency.id', ondelete="CASCADE"))
shipping_cost = db.Column(db.Float, default=0)
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime, default=db.func.now(), onupdate=db.func.now())
order = db.relationship("MOrder", backref="order_seller_orders")
seller = db.relationship("User", backref="seller_orders_sold", primaryjoin="User.id == MSellerOrder.seller_id")
buyer = db.relationship("User", backref="seller_orders_bought", primaryjoin="User.id == MSellerOrder.buyer_id")
currency = db.relationship("MCurrency")
shipping_method = db.relationship("MShippingMethod", backref="seller_order_shipping")
@property
def order_status_explained(self):
if self.order_status == 0:
return 'Pending'
elif self.order_status == 1:
return 'Received'
elif self.order_status == 2:
return 'Processing'
elif self.order_status == 3:
return "Shipping"
elif self.order_status == 4:
return "Completed"
return self.order_status
@property
def next_action(self):
if self.order_status == 0:
return 1, 'Received'
elif self.order_status == 1:
return 2, "Processing"
elif self.order_status == 2:
return 3, "Shipping"
elif self.order_status == 3:
return 4, "Completed"
return False
@property
def product_total(self):
sum = 0
for item in self.order_items:
sum += item.current_total_price
return sum
@property
def total_price(self):
return self.product_total + self.shipping_cost
class BlogPostTag(db.Model):
__tablename__ = 'blog_post_tags'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
tag_id = db.Column(db.Integer,
db.ForeignKey('blog_tags.id', ondelete="CASCADE"))
post_id = db.Column(db.Integer,
db.ForeignKey('blog_posts.id', ondelete="CASCADE"))
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
class MReview(db.Model):
__tablename__ = 'product_reviews'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete="CASCADE"),
nullable=False)
product_id = db.Column(db.Integer,
db.ForeignKey('marketplace_products.id',
ondelete="CASCADE"),
nullable=True)
score = db.Column(db.Float)
message = db.Column(db.Text)
timestamp = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
user = db.relationship("User", backref="reviews")
product = db.relationship("MProduct",
cascade="all,delete",
backref="reviews")
class MShippingMethod(db.Model):
__tablename__ = 'marketplace_shipping_methods'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(), default=None, nullable=False)
seller_id = db.Column(db.Integer, db.ForeignKey('users.id', ondelete="CASCADE"), default=None, nullable=True)
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime, default=db.func.now(), onupdate=db.func.now())
seller = db.relationship("User", backref="shipping_methods")
def get_price(self, currency, seller):
price = None
shipping_method_price = MShippingMethodPrice.query.filter_by(shipping_method=self).filter_by(price_currency=currency).filter_by(seller=seller).first()
if shipping_method_price:
price = shipping_method_price.price
return price
class MCartItem(db.Model):
__tablename__ = 'marketplace_cart_items'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
cart_id = db.Column(db.Integer,
db.ForeignKey('marketplace_carts.id',
ondelete="CASCADE"),
nullable=True,
default=None)
seller_cart_id = db.Column(db.Integer,
db.ForeignKey('marketplace_seller_carts.id',
ondelete="CASCADE"),
nullable=True,
default=None)
product_id = db.Column(
db.Integer, db.ForeignKey('marketplace_products.id',
ondelete="CASCADE"))
seller_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete="CASCADE"))
buyer_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete="CASCADE"),
nullable=True,
default=None)
count = db.Column(db.Integer, default=1)
variant_id = db.Column(
db.Integer, db.ForeignKey('marketplace_variants.id',
ondelete="CASCADE"))
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
cart = db.relationship("MCart",
backref=backref("cart_items", lazy='joined'))
seller_cart = db.relationship("MSellerCart", backref="cart_items")
seller = db.relationship("User",
backref="items_in_cart",
primaryjoin="User.id == MCartItem.seller_id")
buyer = db.relationship("User",
backref="my_cart_items",
primaryjoin="User.id == MCartItem.buyer_id")
product = db.relationship("MProduct", backref="product_cart_items")
variant = db.relationship(
"MVariant",
backref="variant_cart_items",
primaryjoin="MVariant.id == MCartItem.variant_id")
class BlogPost(db.Model):
__tablename__ = 'blog_posts'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String())
image = db.Column(db.String(), default=None, nullable=False)
text = db.Column(db.Text(), default=None)
comments = db.relationship('BlogComment',
backref=backref('post'),
lazy='dynamic',
cascade="all, delete-orphan")
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete="CASCADE"))
creator = db.relationship('User')
categories = db.relationship(
"BlogCategory",
secondary='blog_post_categories',
backref=backref("posts"),
primaryjoin=(BlogPostCategory.post_id == id),
secondaryjoin=(BlogPostCategory.category_id == BlogCategory.id))
tags = db.relationship("BlogTag",
secondary='blog_post_tags',
backref=backref("posts"),
primaryjoin=(BlogPostTag.post_id == id),
secondaryjoin=(BlogPostTag.tag_id == BlogTag.id))
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
class MOrderStatusChange(db.Model):
__tablename__ = 'marketplace_order_status_changes'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
order_id = db.Column(db.Integer, db.ForeignKey('marketplace_orders.id', ondelete="CASCADE"), nullable=True,
default=None)
seller_order_id = db.Column(db.Integer, db.ForeignKey('marketplace_seller_orders.id', ondelete="CASCADE"), nullable=True,
default=None)
changed_from = db.Column(db.Integer, default=0)
changed_to = db.Column(db.Integer, default=0)
order = db.relationship("MOrder", backref="order_statuses")
seller_order = db.relationship("MSellerOrder", backref="order_status_changes")
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime, default=db.func.now(), onupdate=db.func.now())
@property
def order_status_explained(self):
if self.changed_to == 0:
return 'Pending', 'Your Order is still pending', ''
elif self.changed_to == 1:
return 'Received', 'The seller received your order', 'envelope open outline'
elif self.changed_to == 2:
return 'Processing', 'The seller is working on your order now', 'spinner'
elif self.changed_to == 3:
return "Shipping", 'Your Order is on the way to you', 'truck'
elif self.changed_to == 4:
return "Completed", 'Order Delivered', 'thumbs up'
return self.changed_to
class EditableHTML(db.Model):
id = db.Column(db.Integer, primary_key=True)
editor_name = db.Column(db.String(100), unique=True)
value = db.Column(db.Text)
@staticmethod
def get_editable_html(editor_name):
editable_html_obj = EditableHTML.query.filter_by(
editor_name=editor_name).first()
if editable_html_obj is None:
editable_html_obj = EditableHTML(editor_name=editor_name, value='')
return editable_html_obj
@property
def serialize(self):
return {
'id': self.id,
'editor_name': self.editor_name,
'value': self.value
}
class MSettings(db.Model):
__tablename__ = 'marketplace_settings'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String())
display_name = db.Column(db.String())
value = db.Column(db.String(), default=None)
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
@staticmethod
def insert_stripe():
settings = [['stripe_public', 'Stripe Public Key'],
['stripe_secret', 'Stripe Secret Key'],
['paystack_public', 'Paystack Public Key'],
['paystack_secret', 'Paystack Secret Key']]
for s in settings:
setting = MSettings.query.filter_by(name=s[0]).first()
print(setting)
if setting is None:
setting = MSettings(name=s[0], display_name=s[1])
db.session.add(setting)
db.session.commit()
class Notification(db.Model):
__tablename__ = 'notifications'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128), index=True)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete="CASCADE"))
related_id = db.Column(db.Integer, default=0)
timestamp = db.Column(db.Float, index=True, default=time)
payload_json = db.Column(db.Text)
read = db.Column(db.Boolean, default=False)
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
def get_data(self):
return json.loads(str(self.payload_json))
def parsed(self):
user = User.query.filter_by(id=self.related_id).first()
if 'unread_message' in self.name:
msg = Message.query.filter_by(
id=json.loads(self.payload_json)['message']).first()
if user and msg:
return {
"type":
self.name,
"link":
url_for('main.read_notification', notification_id=self.id),
"text":
"<p><b>{}</b> sent you a message <u>{} ...</u></strong></p>"
.format(user.full_name, msg.body[:40].replace("\n", " ")),
"timestamp":
datetime.fromtimestamp(self.timestamp).ctime(),
"time":
self.timestamp,
"user":
user,
"read":
self.read
}
else:
self.read = True
db.session.add(self)
db.session.commit()
class MCategory(db.Model):
__tablename__ = 'marketplace_categories'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
parent_id = db.Column(db.Integer, db.ForeignKey('marketplace_categories.id', ondelete="CASCADE"), nullable=True,
default=None)
name = db.Column(db.String(), default=None, nullable=False)
image = db.Column(db.String(), default=None, nullable=False)
order = db.Column(db.Integer, default=0)
is_featured = db.Column(db.Boolean, default=False)
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime, default=db.func.now(), onupdate=db.func.now())
parent = db.relationship("MCategory", remote_side=[id])
children = db.relationship("MCategory")
class MCategory(db.Model):
__tablename__ = 'marketplace_categories'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
parent_id = db.Column(db.Integer,
db.ForeignKey('marketplace_categories.id',
ondelete="CASCADE"),
nullable=True,
default=None)
name = db.Column(db.String(), default=None, nullable=False)
image = db.Column(db.String(), default=None, nullable=True)
order = db.Column(db.Integer, default=0)
is_featured = db.Column(db.Boolean, default=False)
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
parent = db.relationship("MCategory", remote_side=[id])
children = db.relationship("MCategory")
# products = db.relationship(
# 'MProduct',
# secondary=subscribers,
# backref=db.backref('user', passive_deletes=True, lazy='dynamic')
# )
# products = db.relationship("MProduct", backref="categories")
@staticmethod
def insert_data():
names = ('Animals & Pet Supplies', 'Apparel & Accessories',
'Arts & Entertainment', 'Baby & Toddler',
'Business & Industrial', 'Cameras & Optics', 'Electronics',
'Food, Beverages & Tobacco', 'Furniture', 'Hardware',
'Health & Beauty', 'Home & Garden', 'Luggage & Bags',
'Mature', 'Media', 'Office Supplies',
'Religious & Ceremonial', 'Software & Information Technology',
'Sporting Goods', 'Toys & Games', 'Vehicles & Parts',
'Housing', 'Hobbies', 'Classifieds')
for name in names:
name = MCategory(name=name)
db.session.add(name)
db.session.commit()
print('Added Marketplace Categories')
@property
def image_url(self):
return url_for('_uploads.uploaded_file',
setname='images',
filename=self.image,
external=True)
class MCurrency(db.Model):
__tablename__ = 'marketplace_currency'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(), default=None, nullable=False)
symbol = db.Column(db.String())
default = db.Column(db.Boolean())
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime, default=db.func.now(), onupdate=db.func.now())
class BaseModel(db.Model):
__abstract__ = True
id = db.Column(db.Integer(), primary_key=True)
created_at = db.Column(db.DateTime(), default=datetime.now())
updated_at = db.Column(db.DateTime(), default=datetime.now(), onupdate=datetime.now())
def save(self):
try:
db.session.add(self)
db.session.commit()
except (exc.IntegrityError, exc.InvalidRequestError):
db.session().rollback()
def delete(self):
db.session.delete(self)
db.session.commit()
def serialize(self):
s = {column.name: getattr(self, column.name) for column in self.__table__.columns if column.name not in ['created_at', 'updated_at']}
s['timestamps'] = {'created_at': self.created_at, 'updated_at': self.updated_at, 'date_pretty_short': self.created_at.strftime('%b %d, %Y'),
'date_pretty': self.created_at.strftime('%B %d, %Y')}
return s
class MShippingMethodPrice(db.Model):
__tablename__ = 'marketplace_shipping_method_prices'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
shipping_method_id = db.Column(db.Integer, db.ForeignKey('marketplace_shipping_methods.id', ondelete="CASCADE"))
seller_id = db.Column(db.Integer, db.ForeignKey('users.id', ondelete="CASCADE"), default=None, nullable=True)
price_currency_id = db.Column(db.Integer, db.ForeignKey('marketplace_currency.id', ondelete="CASCADE"))
price = db.Column(db.Float)
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime, default=db.func.now(), onupdate=db.func.now())
seller = db.relationship("User", backref="shipping_methods_prices")
shipping_method = db.relationship("MShippingMethod", backref="prices")
price_currency = db.relationship("MCurrency")
class BlogCategory(db.Model):
__tablename__ = 'blog_categories'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(), default=None, nullable=False)
order = db.Column(db.Integer, default=0)
is_featured = db.Column(db.Boolean, default=False)
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
class ContactMessage(db.Model):
__tablename__ = 'contact_messages'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete="CASCADE"),
nullable=True)
name = db.Column(db.String(), default=None, nullable=True)
email = db.Column(db.String(64), default=None, nullable=True)
text = db.Column(db.Text)
user = db.relationship("User")
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
class MOrderStatusChange(db.Model):
__tablename__ = 'marketplace_order_status_changes'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
order_id = db.Column(db.Integer, db.ForeignKey('marketplace_orders.id', ondelete="CASCADE"), nullable=True,
default=None)
order_item_id = db.Column(db.Integer, db.ForeignKey('marketplace_order_items.id', ondelete="CASCADE"), nullable=True,
default=None)
changed_from = db.Column(db.Integer, default=0)
changed_to = db.Column(db.Integer, default=0)
order = db.relationship("MOrder", backref="order_statuses")
order_item = db.relationship("MOrderItem", backref="order_item_statuses")
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime, default=db.func.now(), onupdate=db.func.now())
class MSellerCart(db.Model):
__tablename__ = 'marketplace_seller_carts'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
cart_id = db.Column(db.Integer, db.ForeignKey('marketplace_carts.id', ondelete="CASCADE"))
seller_id = db.Column(db.Integer, db.ForeignKey('users.id', ondelete="CASCADE"))
shipping_method_id = db.Column(db.Integer, db.ForeignKey('marketplace_shipping_methods.id', ondelete="CASCADE"),
nullable=True, default=None)
buyer_id = db.Column(db.Integer, db.ForeignKey('users.id', ondelete="CASCADE"), nullable=True, default=None)
current_currency_id = db.Column(db.Integer, db.ForeignKey('marketplace_currency.id', ondelete="CASCADE"))
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime, default=db.func.now(), onupdate=db.func.now())
cart = db.relationship("MCart", backref="seller_carts")
seller = db.relationship("User", backref="seller_carts_active", primaryjoin="User.id == MSellerCart.seller_id")
buyer = db.relationship("User", backref="my_seller_carts", primaryjoin="User.id == MSellerCart.buyer_id")
currency = db.relationship("MCurrency")
shipping_method = db.relationship("MShippingMethod", backref="seller_cart_shipping")
class Message(db.Model):
__tablename__ = 'messages'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete='cascade'))
recipient_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete="CASCADE"))
body = db.Column(db.Text)
timestamp = db.Column(db.DateTime, index=True, default=db.func.now())
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
read_at = db.Column(db.DateTime, default=None, nullable=True)
user = db.relationship('User', primaryjoin="Message.user_id==User.id")
def __repr__(self):
return '<Message {}>'.format(self.body)
