class Account(Base):
__base_tablename__ = 'account'
userId = db.Column(db.String(144), nullable=False, unique=True)
fullName = db.Column(db.String(144), nullable=False)
email = db.Column(db.String(144), nullable=False)
observatory = db.Column(db.String(144), nullable=True)
Observation = db.relationship("Observation", backref="account", lazy=True)
def __init__(self, userId, fullName, email):
self.userId = userId
self.fullName = fullName
self.email = email
self.observatory = None
def get_id(self):
return self.id
def get_userId(self):
return self.userId
def is_active(self):
return True
def is_anonymous(self):
return False
def is_authenticated(self):
return True
def getRole(self):
return self.role
class Observatoryday(Base):
__base_tablename__ = 'observatoryday'
day = db.Column(db.DateTime, nullable=False)
comment = db.Column(db.String(1000), nullable=True)
observers = db.Column(db.String(200), nullable=False)
selectedactions = db.Column(db.String(500), nullable=False)
observatory_id = db.Column(db.Integer,
db.ForeignKey(Base.the_prefix +
'observatory.id'),
nullable=False)
Observationperiod = db.relationship("Observationperiod",
backref="observatoryday",
lazy=True)
Catch = db.relationship("Catch", backref="observatoryday", lazy=True)
def __init__(self, day, comment, observers, selectedactions,
observatory_id):
self.day = day
self.comment = comment
self.observers = observers
self.selectedactions = selectedactions
self.observatory_id = observatory_id
class Permission(db.Model):
__tablename__ = 'permissions'
PERMISSIONS = [
('post_comment', 'Писать комментарии'),
('write_articles', 'Писать новости'),
('manage_comments', 'Управлять комментариями'),
('manage_users', 'Управлять пользователями'),
('set_permissions', 'Выдавать разрешения'),
('change_company_structure', 'Изменять структуру компании'),
('manage_communities', 'Управлять группами пользователей'),
('manage_articles', 'Управлять новостями'),
]
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
title = db.Column(db.String(64))
def __repr__(self):
return "<Permission {name}>".format(name=self.name)
@classmethod
def get_by_id(cls, uid):
return cls.query.filter_by(id=uid).first()
@classmethod
def get_all(cls):
return cls.query.order_by(cls.title).all()
class LocationModel(db.Model):
__tablename__ = 'locations'
# id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), primary_key=True)
latitude = db.Column(db.Float(precision=2))
longtitude = db.Column(db.Float(precision=2))
def __init__(self, name, longtitude, latitude):
self.name = name
self.longtitude = longtitude
self.latitude = latitude
def json(self):
return {'name': self.name, 'latitude': self.latitude, 'longtitude': self.longtitude}
@classmethod
def find_by_name(cls, name):
return cls.query.filter_by(name=name).first()
@staticmethod
def get_location_by_name(name):
geo_position = geo.GetGeoPosition("application").get_geo_position(name)
location = LocationModel(name, geo_position.longitude, geo_position.latitude)
return location
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
class Catch(Base):
__base_tablename__ = 'catch'
observatoryday_id = db.Column(db.Integer,
db.ForeignKey(Base.the_prefix +
'observatoryday.id'),
nullable=False)
catchType = db.Column(db.String(144), nullable=False)
location = db.Column(db.String(144), nullable=False)
netCode = db.Column(db.String(144), nullable=True)
amount = db.Column(db.Integer, nullable=False)
length = db.Column(db.Integer, nullable=False)
openedAt = db.Column(db.String(144), nullable=False)
closedAt = db.Column(db.String(144), nullable=False)
dayRowNumber = db.Column(db.Integer, nullable=False)
def __init__(self, observatoryday_id, catchType, location, netCode, amount,
length, openedAt, closedAt, dayRowNumber):
self.observatoryday_id = observatoryday_id
self.catchType = catchType
self.location = location
self.netCode = netCode
self.amount = amount
self.length = length
self.openedAt = openedAt
self.closedAt = closedAt
self.dayRowNumber = dayRowNumber
class NewsTag(db.Model, Mixin):
__tablename__ = 'news_tag'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
@classmethod
def get_tags(cls, tags=None):
if tags is not None:
return cls.query.filter(NewsTag.name.in_(tags)).all()
else:
return cls.query.all()
class Location(Base):
__base_tablename__ = 'location'
name = db.Column(db.String(144), nullable = False)
observatory_id = db.Column(db.Integer, db.ForeignKey(Base.the_prefix + 'observatory.id'), nullable=False)
Observationperiod = db.relationship("Observationperiod", backref="location", lazy=True)
def __init__ (self, name, observatory_id):
self.name = name
self.observatory_id = observatory_id
class Shorthand(Base):
__base_tablename__ = 'shorthand'
shorthandblock = db.Column(db.String(4000), nullable=False)
observationperiod_id=db.Column(db.Integer, db.ForeignKey(Base.the_prefix + 'observationperiod.id'), nullable=False)
Observation = db.relationship("Observation", backref="shorthand", lazy=True)
def __init__ (self, shorthandblock, observationperiod_id):
self.shorthandblock=shorthandblock
self.observationperiod_id=observationperiod_id
class RevokedToken(db.Model):
__tablename__ = 'revoked_tokens'
id = db.Column(db.Integer, primary_key=True)
jti = db.Column(db.String(120))
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def is_jti_blacklisted(cls, jti):
return bool(cls.query.filter_by(jti=jti).first())
class Observatory(Base):
__base_tablename__ = 'observatory'
name = db.Column(db.String(144), nullable=False)
actions = db.Column(db.String(500), nullable=False)
Observatoryday = db.relationship("Observatoryday",
backref="observatory",
lazy=True)
Location = db.relationship("Location", backref="observatory", lazy=True)
Type = db.relationship("Type", backref="observatory", lazy=True)
def __init__(self, name, actions):
self.name = name
self.actions = actions
class Base(db.Model):
__abstract__ = True
the_prefix = prefix
@declared_attr
def __tablename__(cls):
return cls.the_prefix + cls.__base_tablename__
id = db.Column(db.Integer, Sequence('id'), primary_key=True)
date_created = db.Column(db.DateTime, default=db.func.current_timestamp())
date_modified = db.Column(db.DateTime,
default=db.func.current_timestamp(),
onupdate=db.func.current_timestamp())
is_deleted = db.Column(db.Integer, default=0)
class Observationperiod(Base):
__base_tablename__ = 'observationperiod'
start_time = db.Column(db.DateTime, nullable=False)
end_time = db.Column(db.DateTime, nullable=False)
type_id = db.Column(db.Integer, db.ForeignKey(Base.the_prefix + 'type.id'), nullable=False)
location_id = db.Column(db.Integer, db.ForeignKey(Base.the_prefix + 'location.id'), nullable=False)
observatoryday_id = db.Column(db.Integer, db.ForeignKey(Base.the_prefix + 'observatoryday.id'), nullable=False)
Shorthand = db.relationship("Shorthand", backref="observationperiod", lazy=True)
def __init__ (self, start_time, end_time, type_id, location_id, observatoryday_id):
self.start_time = start_time
self.end_time = end_time
self.type_id = type_id
self.location_id = location_id
self.observatoryday_id = observatoryday_id
class UserModel(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
password = db.Column(db.String(80), nullable=False)
def to_json(self):
return {
'id': self.id,
'username': self.username,
'password': self.password,
}
def save_to_db(self):
db.session.add(self)
db.session.commit()
@staticmethod
def generate_hash(password):
return sha256.hash(password)
@staticmethod
def verify_hash(password, pw_hash):
return sha256.verify(password, pw_hash)
@classmethod
def find_by_username(cls, **kwargs):
return cls.query.filter_by(username=kwargs.get('username')).first()
@classmethod
def return_all(cls):
return {'users': [u.to_json() for u in cls.query.all()]}
@classmethod
def delete_all(cls):
try:
n_rows_deleted = db.session.query(cls).delete()
db.session.commit()
return {'message': '{} row(s) deleted'.format(n_rows_deleted)}
except:
return {'message': 'something went wrong...'}, 500
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
permissions = db.relationship("Permission",
secondary=role_permission_associate,
backref="roles")
def __repr__(self):
return "<Role {name}>".format(name=self.name)
@classmethod
def get_by_id(cls, uid):
return cls.query.filter_by(id=uid).first()
@classmethod
def get_all(cls):
return cls.query.order_by(cls.name.desc()).all()
class User(Base):
__tablename__ = "account"
username = db.Column(db.String(144), nullable=False)
password = db.Column(db.String(144), nullable=False)
orders = db.relationship('StoreOrder', backref='account', lazy=True)
active = db.Column(db.Boolean())
roles = db.relationship('Role', secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
def get_id(self):
return self.id
def is_active(self):
return True
def is_anonymous(self):
return False
def is_authenticated(self):
return True
def has_role(self, role):
return role in self.roles
@staticmethod
def find_the_sum_of_spent_money_by_user(user_id):
stmt = text("SELECT Store_Order.user_id, SUM(Product.price) FROM Store_Order"
" JOIN store_order_has_product ON Store_Order.id = store_order_has_product.store_order_id "
" JOIN product ON store_order_has_product.product_id = product.id "
" GROUP BY Store_Order.user_id "
" HAVING store_order.user_id = :user_id").params(user_id = user_id)
res = db.engine.execute(stmt)
response = 0
for row in res:
response = row[1]
return response
class UserModel(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80))
password = db.Column(db.String(80))
def __init__(self, username, password):
self.username = username
self.password = password
@classmethod
def find_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def find_by_id(cls, _id):
return cls.query.filter_by(id=_id).first()
def save_to_db(self):
db.session.add(self)
db.session.commit()
class NewsCategory(db.Model, Mixin):
__tablename__ = 'news_category'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
parent_id = db. Column(db.Integer, db.ForeignKey('news_category.id'), nullable=True)
parent = db.relationship('NewsCategory', remote_side=[id], backref="subcategories", lazy='joined')
@classmethod
def get_root(cls):
return cls.query.filter(cls.parent_id == None).all()
@classmethod
def add(cls, name):
cat = NewsCategory(name=name)
db.session.add(cat)
db.session.commit()
@classmethod
def get_by_id(cls, uid):
return cls.query.filter_by(id=uid).first()
@classmethod
def rename(cls, uid, new_name):
cat = cls.query.filter_by(id=uid).first()
cat.name = new_name
db.session.add(cat)
db.session.commit()
@classmethod
def delete(cls, uid):
cls.query.filter_by(id=uid).delete()
db.session.commit()
@classmethod
def get_all(cls):
return cls.query.order_by(NewsCategory.name).all()
class PasswordRestore(db.Model):
__tablename__ = 'password_restore'
id = db.Column(db.Integer, primary_key=True)
author_id = db.Column(db.Integer, db.ForeignKey('users.id'))
token = db.Column(db.String(64))
is_active = db.Column(db.Boolean, default=True)
datetime = db.Column(db.DateTime, default=datetime.now)
author = db.relationship("User", backref="password_restore")
def __repr__(self):
return "<PasswordRestore {token}>".format(token=self.token)
@classmethod
def add_token(cls, user):
token = ''.join(str(uuid1()).split('-'))
pass_restore = PasswordRestore(author_id=user.id, token=token)
db.session.add(pass_restore)
db.session.commit()
return token
@classmethod
def is_valid_token(cls, token):
expiration = datetime.now() - timedelta(days=1)
restore_pass = cls.query.filter(
PasswordRestore.token == token, PasswordRestore.is_active == True,
PasswordRestore.datetime >= expiration).first()
return restore_pass
@classmethod
def deactivation_token(cls, token_obj):
tokens = cls.query.filter(
PasswordRestore.author_id == token_obj.author_id).all()
for token in tokens:
token.is_active = False
db.session.commit()
class ViewNews(db.Model):
__tablename__ = 'view_news'
news_id = db.Column(db.Integer, primary_key=True)
news_title = db.Column(db.String(255))
users_id = db.Column(db.Integer)
user_full_name = db.Column(db.String(64))
news_category_id = db.Column(db.Integer)
news_category_name = db.Column(db.String(255))
def __repr__(self):
return "<ViewNews {name}>".format(name=self.news_title)
class ViewNewsCategory(db.Model):
__tablename__ = 'view_news_category'
news_category_id = db.Column(db.Integer, primary_key=True)
news_category_name = db.Column(db.String(255))
count_news = db.Column(db.Integer)
count_views = db.Column(db.Integer)
count_votes = db.Column(db.Integer)
count_comments = db.Column(db.Integer)
def __repr__(self):
return "<ViewNewsCategory {name}>".format(name=self.news_category_name)
class Vote(db.Model, Mixin):
class Type:
(
LIKE,
VOTE
) = range(2)
TITLES = dict([(LIKE, 'like'), (VOTE, 'vote')])
class Value:
POSITIVE = 1
NEGATIVE = -1
NEUTRAL = 0
TITLES = dict([(POSITIVE, 'positive'), (NEGATIVE, 'negative'), (NEUTRAL, 'neutral')])
__tablename__ = 'vote'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
datetime = db.Column(db.DateTime, default=_datetime.now)
value = db.Column(db.Integer, default=Value.NEUTRAL)
entity = db.Column(db.String(255))
entity_id = db.Column(db.Integer)
type = db.Column(db.Integer, default=Type.VOTE)
votes_count = db.Column(db.Integer, default=0)
user = db.relationship("User", backref="votes",)
@staticmethod
def get_for(entity, entity_id, user=None):
query = Vote.query.filter(Vote.entity == entity, Vote.entity_id == entity_id)
if user: query = query.filter(Vote.user == user)
return query.first() if user else query.all()
def get_entity(self):
return Vote.get_entities().get(self.entity, {}).get(self.entity_id)
@staticmethod
def get_entities():
return HasVotes.__entities__
class Post(db.Model, Mixin, HasComments, HasVotes):
__tablename__ = 'post'
class STATUS:
(
ACTIVE,
DELETED,
BLOCKED,
) = range(3)
TITLE = [(ACTIVE, 'active'), (DELETED, 'deleted'),
(BLOCKED, 'blocked')]
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255))
text = db.Column(db.Text())
status = db.Column(db.Integer, default=STATUS.ACTIVE)
author_id = db.Column(db.Integer, db.ForeignKey('users.id'))
community_id = db.Column(db.Integer, db.ForeignKey('community.id'))
datetime = db.Column(db.DateTime, default=datetime.now)
comments_count = db.Column(db.Integer, default=0)
votes_count = db.Column(db.Integer, default=0)
views_count = db.Column(db.Integer, default=0)
author = db.relationship("User", backref="posts", lazy="joined")
@classmethod
def all(cls):
return cls.query.filter().order_by(cls.datetime.desc()).all()
@property
def announcement(self):
parts = self.text.split('<!-- page break -->')
return parts[0]
def increment_views(self):
self.views_count = (self.views_count or 0) + 1
db.session.commit()
def after_delete_comment(self, comment=None):
self.__recount_comments()
def after_add_comment(self, comment=None):
self.__recount_comments()
def __recount_comments(self):
self.comments_count = len([
c for c in self.comments_all if c.status != Comment.Status.DELETED
])
def after_delete_vote(self, vote=None):
self.votes_count = (self.votes_count or 0) - 1
def after_add_vote(self, vote=None):
self.votes_count = (self.votes_count or 0) + 1
def after_update_vote(self, value):
self.votes_count = (self.votes_count or 0) + value
def to_json(self):
return news_schema.dump(self)
class User(db.Model, AuthUser, Mixin):
'''
при добавлении полей не забыть их добавить в
application/models/serializers/users.py для корректной валидации данных
'''
__tablename__ = 'users'
(
STATUS_ACTIVE,
STATUS_DELETED,
) = range(2)
STATUSES = [(STATUS_ACTIVE, 'Active'), (STATUS_DELETED, 'Deleted')]
id = db.Column(db.Integer, primary_key=True)
email = db.Column(
db.String
) # TODO Add constraint on length; can't be nullable in future
full_name = db.Column(db.String(64))
login = db.Column(db.String(64), unique=True)
status = db.Column(db.Integer, default=STATUS_ACTIVE)
mobile_phone = db.Column(
db.String, nullable=True) # TODO Add constraint on length and format
inner_phone = db.Column(
db.String, nullable=True) # TODO Add constraint on length and format
birth_date = db.Column(db.DateTime,
nullable=True) # TODO Add default value
skype = db.Column(db.String(64), nullable=True)
department_id = db.Column(db.Integer, db.ForeignKey('department.id'))
position = db.Column(db.String(255))
photo_id = db.Column(db.Integer, db.ForeignKey('file.id'))
is_admin = db.Column(db.Boolean, default=False)
news_notification = db.Column(db.Boolean, default=False)
reg_date = db.Column(db.DateTime, default=datetime.now)
permissions = db.relationship("Permission",
secondary=user_permission_associate,
backref="users",
lazy='dynamic')
roles = db.relationship("Role",
secondary=user_role_associate,
backref="users",
lazy='dynamic')
department = db.relationship("Department",
backref="users",
foreign_keys=[department_id])
photo = db.relationship("File", lazy="joined")
def __repr__(self):
return "<User {login}>".format(login=self.login)
@classmethod
def get_by_id(cls, uid):
return cls.query.filter_by(id=uid).first()
@classmethod
def get_by_email(cls, email):
return cls.query.filter_by(email=email).first()
@classmethod
def get_by_login(cls, login):
return cls.query.filter_by(login=login).first()
@classmethod
def count_users_in_department(cls, department):
return cls.query.filter_by(department_id=department).count()
@classmethod
def find_user(cls, dep_id, name):
return cls.query.filter(
or_(User.department_id == None,
User.department_id != dep_id)).filter(
User.full_name.ilike('%' + name + '%')).limit(5).all()
@classmethod
def get_new(cls):
today = date.today()
delta = today - timedelta(days=30)
return cls.query.filter(
User.reg_date > delta,
or_(User.status != User.STATUS_DELETED,
User.status == None)).order_by(User.reg_date.desc(),
User.full_name).all()
@classmethod
def get_birthday(cls):
today = date.today()
tomorrow = today + timedelta(days=1)
return cls.query.filter(
or_(
and_(
extract('month', User.birth_date) == today.month,
extract('day', User.birth_date) == today.day),
and_(
extract('month', User.birth_date) == tomorrow.month,
extract('day', User.birth_date) == tomorrow.day)),
or_(User.status != User.STATUS_DELETED,
User.status == None)).order_by(User.birth_date.desc(),
User.full_name).all()
@classmethod
def set_user_is_admin(cls, user_id):
u = cls.query.filter_by(id=user_id).first()
u.is_admin = True
u.roles = []
db.session.add(u)
db.session.commit()
@classmethod
def set_user_role(cls, user_id, role_id):
u = cls.query.filter_by(id=user_id).first()
r = Role.get_by_id(role_id)
u.roles = []
u.roles.append(r)
u.is_admin = False
db.session.add(u)
db.session.commit()
@classmethod
def get_user_role_id(cls, user_id):
u = cls.query.filter_by(id=user_id).first()
if u.is_admin:
return 0
elif u.roles and len(u.roles.all()):
return u.roles[0].id
return ''
@classmethod
def set_user_per(cls, user_id, per_string):
if per_string == "None":
per_list = []
else:
per_list = per_string.split(',')
u = cls.query.filter_by(id=user_id).first()
u.permissions = []
for per_id in per_list:
p = Permission.get_by_id(per_id)
u.permissions.append(p)
db.session.add(u)
db.session.commit()
@classmethod
def get_user_permissions_id(cls, user_id):
u = cls.query.filter_by(id=user_id).first()
permissions_list = []
for per in u.permissions:
permissions_list.append(per.id)
return permissions_list
@classmethod
def add_user2dep(cls, dep_id, user_id):
u = cls.query.filter_by(id=user_id).first()
if dep_id == 0:
dep_id = None
u.department_id = dep_id
db.session.add(u)
@classmethod
def edit_user(cls,
uid,
full_name=full_name,
position=position,
mobile_phone=mobile_phone,
inner_phone=inner_phone,
email=email,
birth_date=birth_date,
skype=skype,
photo=photo):
u = cls.query.filter_by(id=uid).first()
if u:
u.full_name = full_name
u.position = position
u.mobile_phone = mobile_phone
u.inner_phone = inner_phone
u.email = email
if birth_date:
u.birth_date = birth_date
else:
u.birth_date = None
u.skype = skype
db.session.add(u)
if photo:
p = u.photo = u.photo or File.create(
name='photo.png', module='users', entity=u)
p.makedir()
p.update_hash()
image.thumbnail(photo, width=100, height=100,
fill=image.COVER).save(
p.get_path(sufix="thumbnail"))
image.resize(photo).save(p.get_path())
return u
def get_permissions(self):
return set([permission.name for permission in self.permissions]).union(
set([
permission.name for role in self.roles
for permission in role.permissions
]))
def has_role(self, role):
return role in self.roles
@property
def age(self):
today, born = date.today(), self.birth_date
return today.year - born.year - ((today.month, today.day) <
(born.month, born.day))
def to_json(self):
return user_schema.dump(self)
class NewsTagAssociation(db.Model):
__tablename__ = 'news_tag_association'
id = db.Column(db.Integer, primary_key=True)
news_id = db.Column(db.Integer, db.ForeignKey('news.id'))
tag_id = db.Column(db.Integer, db.ForeignKey('news_tag.id'))
from application.db import db
from application.models import Base
from flask_security import RoleMixin
from sqlalchemy.sql import text
from flask_security.core import UserMixin
roles_users = db.Table('roles_users',
db.Column('user_id', db.Integer(), db.ForeignKey('account.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('role.id')))
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
class User(Base):
__tablename__ = "account"
username = db.Column(db.String(144), nullable=False)
password = db.Column(db.String(144), nullable=False)
orders = db.relationship('StoreOrder', backref='account', lazy=True)
active = db.Column(db.Boolean())
roles = db.relationship('Role', secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
def get_id(self):
return self.id
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
class News(db.Model, Mixin, HasComments, HasVotes):
__tablename__ = 'news'
(
STATUS_ACTIVE,
STATUS_DELETED,
STATUS_BLOCKED,
) = range(3)
STATUSES = [(STATUS_ACTIVE, 'Active'), (STATUS_DELETED, 'Deleted'),
(STATUS_BLOCKED, 'Blocked')]
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255))
text = db.Column(db.Text())
status = db.Column(db.Integer, default=STATUS_ACTIVE)
author_id = db.Column(db.Integer, db.ForeignKey('users.id'))
category_id = db.Column(db.Integer, db.ForeignKey('news_category.id'))
datetime = db.Column(db.DateTime, default=datetime.now)
comments_count = db.Column(db.Integer, default=0)
votes_count = db.Column(db.Integer, default=0)
views_count = db.Column(db.Integer, default=0)
author = db.relationship("User", backref="news", lazy="joined")
category = db.relationship("NewsCategory",
backref=db.backref(
'news', order_by=desc('News.datetime')),
lazy="joined")
tags = db.relationship("NewsTag",
secondary="news_tag_association",
backref=db.backref('news',
order_by=desc('News.datetime')),
lazy="joined")
@classmethod
def all(cls):
news = cls.query.filter().order_by(cls.datetime.desc()).all()
return news
@classmethod
def all_by_category(cls, id):
news = cls.query.filter(News.category_id == id).order_by(
cls.datetime.desc()).all()
return news
@classmethod
def all_by_tag(cls, tag):
return cls.query.join((NewsTag, cls.tags))\
.filter(NewsTag.name.ilike(tag.name))\
.order_by(cls.datetime.desc()).all()
@property
def announcement(self):
parts = self.text.split('<!-- page break -->')
return parts[0]
def increment_views(self):
self.views_count = (self.views_count or 0) + 1
db.session.commit()
def after_delete_comment(self, comment=None):
self.__recount_comments()
def after_add_comment(self, comment=None):
self.__recount_comments()
def __recount_comments(self):
self.comments_count = len([
c for c in self.comments_all if c.status != Comment.Status.DELETED
])
def after_delete_vote(self, vote=None):
self.votes_count = (self.votes_count or 0) - 1
def after_add_vote(self, vote=None):
self.votes_count = (self.votes_count or 0) + 1
def after_update_vote(self, value):
self.votes_count = (self.votes_count or 0) + value
def to_json(self):
return news_schema.dump(self)
# -*- coding: utf-8 -*-
from datetime import datetime, timedelta, date
from sqlalchemy import or_, and_, extract
from uuid import uuid1
from application.models.mixin import Mixin
from application.models.file import File
from application.utils import image
from application.db import db
from application.models.serializers.user import user_schema
from application.utils.auth.user import User as AuthUser
role_permission_associate = db.Table(
'role_permission', db.Model.metadata,
db.Column('role_id', db.Integer, db.ForeignKey('roles.id')),
db.Column('permission_id', db.Integer, db.ForeignKey('permissions.id')))
user_permission_associate = db.Table(
'user_permission', db.Model.metadata,
db.Column('user_id', db.Integer, db.ForeignKey('users.id')),
db.Column('permission_id', db.Integer, db.ForeignKey('permissions.id')))
user_role_associate = db.Table(
'user_role', db.Model.metadata,
db.Column('user_id', db.Integer, db.ForeignKey('users.id')),
db.Column('role_id', db.Integer, db.ForeignKey('roles.id')))
class Permission(db.Model):
__tablename__ = 'permissions'
class ViewUsers4Search(db.Model):
__tablename__ = 'view_users4search'
users_id = db.Column(db.Integer, primary_key=True)
users_full_name = db.Column(db.String(64))
users_login = db.Column(db.String(64))
users_email = db.Column(db.String)
users_status = db.Column(db.Integer)
users_mobile_phone = db.Column(db.String, nullable=True)
users_inner_phone = db.Column(db.String, nullable=True)
users_birth_date = db.Column(db.DateTime, nullable=True)
users_skype = db.Column(db.String(64), nullable=True)
users_position = db.Column(db.String(255))
department_name = db.Column(db.String(255))
photo_url = db.Column(db.String(255))
def __repr__(self):
return "<ViewUsers4Search {name}>".format(name=self.users_login)
class Observation(Base):
__base_tablename__ = 'observation'
species = db.Column(db.String(144), nullable = False)
adultUnknownCount = db.Column(db.Integer, nullable = False)
adultFemaleCount = db.Column(db.Integer, nullable = False)
adultMaleCount = db.Column(db.Integer, nullable = False)
juvenileUnknownCount = db.Column(db.Integer, nullable = False)
juvenileFemaleCount = db.Column(db.Integer, nullable = False)
juvenileMaleCount = db.Column(db.Integer, nullable = False)
subadultUnknownCount = db.Column(db.Integer, nullable = False)
subadultFemaleCount = db.Column(db.Integer, nullable = False)
subadultMaleCount = db.Column(db.Integer, nullable = False)
unknownUnknownCount = db.Column(db.Integer, nullable = False)
unknownFemaleCount = db.Column(db.Integer, nullable = False)
unknownMaleCount = db.Column(db.Integer, nullable = False)
total_count = db.Column(db.Integer, nullable = False)
direction = db.Column(db.String(144), nullable = True)
bypassSide = db.Column(db.String(144), nullable = True)
notes = db.Column(db.String(1000), nullable = True)
observationperiod_id = db.Column(db.Integer, db.ForeignKey(Base.the_prefix + 'observationperiod.id'), nullable=False)
shorthand_id = db.Column(db.Integer, db.ForeignKey(Base.the_prefix + 'shorthand.id'), nullable=True)
account_id = db.Column(db.String(144), db.ForeignKey(Base.the_prefix + 'account.userId'), nullable=False)
def __init__ (self, species, adultUnknownCount,
adultFemaleCount, adultMaleCount, juvenileUnknownCount, juvenileFemaleCount,
juvenileMaleCount, subadultUnknownCount, subadultFemaleCount, subadultMaleCount,
unknownUnknownCount, unknownFemaleCount, unknownMaleCount, total_count, direction,
bypassSide, notes, observationperiod_id, shorthand_id, account_id):
self.species = species
self.adultUnknownCount = adultUnknownCount
self.adultFemaleCount = adultFemaleCount
self.adultMaleCount = adultMaleCount
self.juvenileUnknownCount = juvenileUnknownCount
self.juvenileFemaleCount = juvenileFemaleCount
self.juvenileMaleCount = juvenileMaleCount
self.subadultUnknownCount = subadultUnknownCount
self.subadultFemaleCount = subadultFemaleCount
self.subadultMaleCount = subadultMaleCount
self.unknownUnknownCount = unknownUnknownCount
self.unknownFemaleCount = unknownFemaleCount
self.unknownMaleCount = unknownMaleCount
self.total_count = total_count
self.direction = direction
self.bypassSide = bypassSide
self.notes = notes
self.observationperiod_id = observationperiod_id
self.shorthand_id = shorthand_id
self.account_id = account_id
@staticmethod
def summaryOfBirdsPerDay():
stmt = text("SELECT Observation.species FROM Observation")
res = db.engine.execute(stmt)
response = []
for row in res:
response.append({"species": row[0]})
return response
