class Role(BaseModel):
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
default = db.Column(db.Boolean, default=False, index=True)
permissions = db.Column(db.Integer)
users = db.relationship('User', backref='role', lazy='dynamic')
def __repr__(self):
return '<Role %s>' % self.name
def __init__(self, **kwargs):
super(Role, self).__init__(**kwargs)
if self.name and self.name in ["admin", "administrator"]:
self.permissions = Permission.ADMIN
else:
self.permissions = Permission.WRITE_POSTS
@staticmethod
def insert_roles():
# L.i('Inserting default roles.')
roles = {'User': Permission.user(), 'Admin': Permission.admin()}
for r in roles:
nm = r.lower()
role = Role.query.filter_by(name=nm).first()
if role is None:
role = Role(name=nm)
role.permissions = roles[r][0]
role.default = roles[r][1]
db.session.add(role)
db.session.commit()
class User(UserMixin, BaseModel):
__tablename__ = 'users'
name = db.Column(db.String(64))
email = db.Column(db.String(64), unique=True, index=True)
password_hash = db.Column(db.String(128))
role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))
status = db.Column(db.Boolean, default=False)
posts = db.relationship('Post', backref='author', lazy='dynamic')
def to_json(self):
json_data = {'id': self.id, 'name': self.name}
return json_data
def __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
if self.role is None:
if self.email == current_app.config['FLASKY_ADMIN']:
self.role = Role.query.filter_by(name="admin").first()
self.status = True
if self.role is None:
self.role = Role.query.filter_by(default=True).first()
@property
def password(self):
raise AttributeError(u'Password is not a readable attribute.')
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def get_id(self):
return self.id
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
def __repr__(self):
return '<User %s>' % self.email
def can(self, permissions):
return self.role is not None and \
(self.role.permissions & permissions) == permissions
def is_administrator(self):
return self.is_admin()
def is_admin(self):
return self.can(Permission.ADMIN)
def is_confirmed(self):
return self.status is not None and self.status is True
class Category(BaseModel):
__tablename__ = 'categories'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(100), unique=True, index=True)
def __repr__(self):
return '<Category %s>' % self.name
def to_json(self):
json_data = {
'id': self.id,
'name': self.name,
'created_at': str(self.created_at)
}
return json_data
class BaseModel(db.Model):
"""A base model that is inherited by all the other models.
It has common columns required by the models."""
__abstract__ = True
id = db.Column(db.Integer, primary_key=True)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
modified_at = db.Column(db.DateTime,
default=datetime.utcnow,
onupdate=datetime.utcnow)
@classmethod
@profile
def get(cls, mid):
L.d('Getting from Cache.')
obj = cache.get(cls.key(mid))
if obj:
L.d('Cache hit for - %s' % cls.key(mid))
return obj
L.d('Cache miss for - %s' % cls.key(mid))
obj = cls.query.get(mid)
if obj:
L.d('Saving in cache - %s' % cls.key(mid))
cache.set(cls.key(mid), obj)
else:
L.d('The object was None')
return obj
def to_json(self):
return {'id': self.id}
def save(self):
db.session.add(self)
db.session.commit()
cache.set(self.key(self.id), self)
def delete(self):
db.session.delete(self)
db.session.commit()
cache.delete(self.key(self.id))
@classmethod
def key(cls, mid):
return ':model_key:%s:%s' % (cls.__tablename__, str(mid))
@classmethod
def save_all(cls, items):
db.session.add_all(items)
db.session.commit()
class Post(BaseModel):
__tablename__ = 'posts'
author_id = db.Column(db.Integer, db.ForeignKey('users.id'))
title = db.Column(db.String(256))
slug = db.Column(db.String(500), unique=True)
description = db.Column(db.Text, default='')
body = db.Column(db.Text, default='')
status = db.Column(db.Boolean, default=True)
body_html = db.Column(db.Text, default='')
tags = db.relationship('Tag',
secondary=tags_posts,
backref=db.backref('posts', lazy='dynamic'))
categories = db.relationship('Category',
secondary=categories_posts,
backref=db.backref('posts', lazy='dynamic'))
def to_json(self):
json_data = {
'id':
self.id,
'title':
self.title,
'slug':
self.slug,
'description':
self.description,
'created_at':
str(self.created_at),
'modified_at':
str(self.modified_at),
'author':
self.author.to_json(),
'permalink':
url_for('blog.get_post_by_slug', slug=self.slug, _external=True)
}
return json_data
@classmethod
@profile
def get_by_slug(cls, slug):
L.d('Getting from Cache.')
obj = cache.get(cls.key(slug))
if obj:
L.d('Cache hit for - %s' % cls.key(slug))
return obj
L.d('Cache miss for - %s' % cls.key(slug))
obj = cls.query.filter_by(slug=slug).first()
if obj:
L.d('Saving in cache - %s' % cls.key(slug))
cache.set(cls.key(slug), obj)
else:
L.d('The object was None')
return obj
@property
def content(self):
return self.body
@content.setter
def content(self, body):
self.body = body
self.body_html = create_post_from_md(body)
@property
def html(self):
return self.body_html
@staticmethod
def on_change_body(target, value, oldvalue, initiator):
target.body_html = create_post_from_md(value)
@staticmethod
def generate_fake(count=10):
from random import seed
import forgery_py
seed()
for i in range(count):
author_id = 1
title = forgery_py.lorem_ipsum.sentence()
p = Post(content=forgery_py.lorem_ipsum.paragraphs(),
title=title,
slug=slugify.slugify(title),
description=forgery_py.lorem_ipsum.sentence(),
author_id=author_id)
db.session.add(p)
db.session.commit()
import slugify
from flask import url_for
from vomitter import LOGGER as L
from yapper import db
from yapper.lib.models import BaseModel
from yapper.lib.cache import cache
from yapper.lib.decorators import profile
from yapper.utilities.md import create_post_from_md
TYPE_POST = 1
TYPE_PAGE = 2
tags_posts = db.Table(
'tags_posts', db.Column('id', db.Integer, primary_key=True),
db.Column('tag_id', db.Integer, db.ForeignKey('tags.id')),
db.Column('post_id', db.Integer, db.ForeignKey('posts.id')))
categories_posts = db.Table(
'categories_posts', db.Column('id', db.Integer, primary_key=True),
db.Column('category_id', db.Integer, db.ForeignKey('categories.id')),
db.Column('post_id', db.Integer, db.ForeignKey('posts.id')))
class Tag(BaseModel):
__tablename__ = 'tags'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(100), unique=True, index=True)
def __repr__(self):
return '<Tag %s>' % self.name