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