# coding=utf-8
# Created by OhBonsai at 2018/3/7
"""User model"""
from flask_bcrypt import (generate_password_hash, check_password_hash)
from flask_login import UserMixin
from app.models.patch import (TagMixin, StatusMixin)
from app.models import db
# User Group m2m db.relationship db.Table
user_group = db.Table(
'user_group', db.metadata,
db.Column('user_id', db.Integer(), db.ForeignKey('user.id')),
db.Column('group_id', db.Integer(), db.ForeignKey('group.id')),
db.PrimaryKeyConstraint('user_id', 'group_id'))
class User(UserMixin, db.Model):
"""Implements the User model."""
username = db.Column(db.String(32), unique=True)
password = db.Column(db.String(128))
chinese_name = db.Column(db.String(32))
email = db.Column(db.String(32))
is_admin = db.Column(db.Boolean, default=False)
active = db.Column(db.Boolean(), default=True)
my_groups = db.relationship('Group', backref='user', lazy='dynamic')
groups = db.relationship('Group',
secondary=user_group,
backref=db.backref('users', lazy='dynamic'))
from flask import current_app
from app.models import db
from werkzeug.security import generate_password_hash, check_password_hash
from itsdangerous import TimedJSONWebSignatureSerializer, SignatureExpired, BadSignature
from sqlalchemy import text
roles = db.Table('roles',
db.Column('user_id', db.Integer, db.ForeignKey('user.id'), primary_key=True),
db.Column('role_id', db.Integer, db.ForeignKey('role.id'), primary_key=True)
)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(40), unique=True, nullable=False)
hash_password = db.Column(db.String(128))
is_admin = db.Column(db.Boolean, nullable=False, server_default='0')
roles = db.relationship('Role', secondary=roles, lazy='dynamic', backref=db.backref('users', lazy=True))
create_time = db.Column(db.DateTime, nullable=False, server_default=text('CURRENT_TIMESTAMP'))
def set_hash_password(self, password: str):
self.hash_password = generate_password_hash(self.name + password)
def verify_password(self, password: str):
return check_password_hash(self.hash_password, self.name + password)
def __repr__(self):
return f'<User> [name]{self.name} [open_id]{self.user_open_id}'
def generate_auth_token(self, expiration=60 * 60):
s = TimedJSONWebSignatureSerializer(current_app.config['SECRET_KEY'], expires_in=expiration)
return s.dumps({'id': self.id})
import hashlib
from sqlalchemy import Column, Integer, String, Text, ForeignKey, Boolean
from sqlalchemy.ext.hybrid import hybrid_property
from sqlalchemy.orm import relationship, validates, backref
from werkzeug.security import generate_password_hash,check_password_hash
import datetime
import uuid
import app
import jwt
import re
from flask import current_app as app
from app.models import DogearMixin, db, News
followers = db.Table('followers',
db.Column('follower_id', db.Integer, db.ForeignKey('users.id')),
db.Column('followed_id', db.Integer, db.ForeignKey('users.id'))
)
class User( DogearMixin,db.Model):
__tablename__ = 'users'
id = Column(Integer, primary_key=True)
username = Column(String, unique=True)
password = Column(String)
email = Column(String, unique=True)
about = Column(Text)
geolocation = Column(String)
news = db.relationship('News', backref='user', lazy='dynamic')
groups = db.relationship('Group', backref='user', lazy='dynamic')
# 管理员
class User(db.Model):
__tablename__ = 'tbl_user'
id = Column(Integer, autoincrement=True, primary_key=True)
name = Column(String(32), default='', unique=True)
password = Column(String(128), nullable=False)
status = Column(SmallInteger, default=1)
roleid = Column(Integer, db.ForeignKey('tbl_role.id'))
addtime = Column(DateTime, default=getCurrentTime)
__table_args__ = {'mysql_charset': 'utf8'}
# 权限规则表
rule_role = db.Table(
'tbl_rule_role',
Column('id', Integer, autoincrement=True, primary_key=True),
Column('roleid', Integer, db.ForeignKey('tbl_role.id')),
Column('ruleid', Integer, db.ForeignKey('tbl_rule.id')),
)
# 角色
class Role(db.Model):
__tablename__ = 'tbl_role'
id = Column(Integer, autoincrement=True, primary_key=True)
name = Column(String(32), default='', unique=True)
status = Column(SmallInteger, default=1)
addtime = Column(DateTime, default=getCurrentTime)
users = db.relationship('User', backref=db.backref('roles'))
rules = db.relationship('Rule',
backref=db.backref('roles'),
secondary=rule_role)
from datetime import datetime
from time import time
import jwt
import os
from werkzeug.security import check_password_hash, generate_password_hash
from app.models import db, ma, cfg_db_schema
from app.models.RoleModel import RoleModel
from app import app
user_role = db.Table('users_role',
db.Column('user_id', db.Integer,
db.ForeignKey(cfg_db_schema + '.users.id')),
db.Column('role_id', db.Integer,
db.ForeignKey(cfg_db_schema + '.role.id')),
schema=cfg_db_schema)
class UserModel(db.Model):
__tablename__ = 'users'
__table_args__ = {"schema": cfg_db_schema}
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128), nullable=False)
email = db.Column(db.String(128), unique=True, nullable=False)
password = db.Column(db.String(128), nullable=False)
active = db.Column(db.Integer, default=0)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
modified_at = db.Column(db.DateTime, default=datetime.utcnow)
roles = db.relationship('RoleModel', secondary=user_role)
type = db.Column(db.Integer, nullable=False)
is_top = db.Column(db.Integer, nullable=False, default=0)
create_at = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.now)
delete_at = db.Column(db.DateTime, nullable=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=True)
# 关注关系
app_user_user = db.Table(
'app_user_user',
db.Column('app_user_id',
db.Integer,
db.ForeignKey('app_user.id'),
primary_key=True),
db.Column('user_id',
db.Integer,
db.ForeignKey('user.id'),
primary_key=True),
db.Column('create_at', db.DateTime, default=datetime.datetime.now))
# 用户点赞关系
thumb = db.Table(
'thumb',
db.Column('app_user_id',
db.Integer,
db.ForeignKey('app_user.id'),
primary_key=True),
db.Column('recommend_id',
db.Integer,
import pytz
from flask_jwt_extended import current_user
from sqlalchemy import event, func
from sqlalchemy.sql import func as sql_func
from sqlalchemy_utils import aggregated
from app.models import db
from app.models.base import SoftDeletionModel
from app.models.feedback import Feedback
from app.models.helpers.versioning import clean_html, clean_up_string
from app.models.user_favourite_session import UserFavouriteSession
speakers_sessions = db.Table(
'speakers_sessions',
db.Column('speaker_id', db.Integer, db.ForeignKey('speaker.id', ondelete='CASCADE')),
db.Column('session_id', db.Integer, db.ForeignKey('sessions.id', ondelete='CASCADE')),
db.PrimaryKeyConstraint('speaker_id', 'session_id'),
)
class Session(SoftDeletionModel):
"""Session model class"""
class State:
PENDING = 'pending'
ACCEPTED = 'accepted'
CONFIRMED = 'confirmed'
REJECTED = 'rejected'
__tablename__ = 'sessions'
__table_args__ = (
from __future__ import annotations
from app.models import db, ma, col
from marshmallow import fields
from datetime import datetime
from app.models.breed_model import BreedSchema
from app.models.photos_model import PhotoSchema
from app.models.interest_model import InterestSchema
dog_conversation = db.Table(
'dog_conversation', col('dog_id', db.Integer, db.ForeignKey('dog.id')),
col('conversation_id', db.Integer, db.ForeignKey('conversation.id')))
class Dog(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False)
details = db.Column(db.String(300), nullable=True)
owner_id = db.Column(db.Integer, db.ForeignKey('owner.id'))
breed_id = db.Column(db.Integer, db.ForeignKey('breed.id'))
gender = db.Column(db.Boolean, nullable=False)
breed = db.relationship("Breed", backref="dog")
photos = db.relationship("Photo", backref="dog")
interest = db.relationship("Interest", backref="dog")
conversations = db.relationship('Conversation',
secondary=dog_conversation,
back_populates='dogs')
messages = db.relationship('Message', back_populates='dogs')
from app.models import db
roles_users = db.Table(
'roles_users', db.Column('user_id', db.Integer(),
db.ForeignKey('users.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('roles.id')))
user_skills = db.Table(
"user_skills", db.Column("user_id", db.Integer, db.ForeignKey("users.id")),
db.Column("skills_id", db.Integer, db.ForeignKey("skills.id")))
from app.models import db, cfg_db_schema
from app.models import PermissionModel
role_permission = db.Table(
'role_permission',
db.Column('role_id', db.Integer,
db.ForeignKey(cfg_db_schema + '.role.id')),
db.Column('permission_id', db.Integer,
db.ForeignKey(cfg_db_schema + '.permission.id')),
schema=cfg_db_schema)
class RoleModel(db.Model):
__tablename__ = 'role'
__table_args__ = {'schema': cfg_db_schema}
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
permissions = db.relationship('PermissionModel', secondary=role_permission)
def __repr__(self):
return "<Role %r>" % (self.name)
from app.models import db
""" Смежная таблица многие-ко-многим (applications - cars) """
cars_applications = db.Table(
'cars_applications',
db.Column('car_id', db.Integer, db.ForeignKey('cars.car_id')),
db.Column('application_id', db.Integer,
db.ForeignKey('applications.application_id')),
db.Column('cars_applications_id', db.Integer, primary_key=True))
from app.models.order import OrderTicket, Order
from app.models import db
ticket_tags_table = db.Table(
'association', db.Model.metadata,
db.Column('ticket_id', db.Integer,
db.ForeignKey('ticket.id', ondelete='CASCADE')),
db.Column('ticket_tag_id', db.Integer,
db.ForeignKey('ticket_tag.id', ondelete='CASCADE')))
class Ticket(db.Model):
__tablename__ = 'ticket'
__table_args__ = (db.UniqueConstraint('name',
'event_id',
name='name_event_uc'), )
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
description = db.Column(db.String)
description_toggle = db.Column(db.Boolean)
type = db.Column(db.String)
quantity = db.Column(db.Integer)
price = db.Column(db.Float)
absorb_fees = db.Column(db.Boolean)
sales_start = db.Column(db.DateTime)
sales_end = db.Column(db.DateTime)
hide = db.Column(db.Boolean)
min_order = db.Column(db.Integer)
from app.models import db, UUID
from sqlalchemy import Column, ForeignKey
RolePermission = db.Table(
'auth_role_permission',
Column('uk_role_uid', UUID, ForeignKey('auth_role.uid'), primary_key=True),
Column('uk_permission_uid', UUID, ForeignKey('auth_permission.uid'), primary_key=True)
)
UserRole = db.Table(
'auth_user_role',
Column('uk_user_uid', UUID, ForeignKey("auth_user.uid"), primary_key=True),
Column('uk_role_uid', UUID, ForeignKey("auth_role.uid"), primary_key=True)
)
from app.models import db
category_product = db.Table(
'category_product',
db.Column('product_id',
db.Integer,
db.ForeignKey('product.id'),
primary_key=True),
db.Column('category_id',
db.Integer,
db.ForeignKey('category.id'),
primary_key=True))
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False, unique=True)
description = db.Column(db.String)
creation_date = db.Column(db.DateTime, default=datetime.now)
topics = db.relationship('ForumTopics', back_populates="section", lazy='dynamic', cascade='all')
def __str__(self):
return self.name
#=============================================================================
# Discussion topics and their tags
#=============================================================================
tags_rel = db.Table("forum_tags_rel", db.Model.metadata,
db.Column('id', db.Integer, primary_key=True),
db.Column('topic_id', db.Integer, db.ForeignKey('forum_topics.id')),
db.Column('topic_tags_id', db.Integer, db.ForeignKey('forum_tags.id'))
)
class ForumTopics(db.Model):
id = db.Column(db.Integer, primary_key=True)
# Forum to which this topic belongs
section_id = db.Column(db.Integer, db.ForeignKey('forum_sections.id'))
section = db.relationship("ForumSections", back_populates="topics")
# User who created this topic
user_id = db.Column(db.Integer, db.ForeignKey("users.id"), default=lambda: current_user.id)
user = db.relationship(Users)
# Topic headline, body, and metadata
from app.models import db, ma, col
from marshmallow import fields
from datetime import datetime
from app.models.breed_model import BreedSchema
from app.models.photos_model import PhotoSchema
from app.models.interest_model import InterestSchema
dog_conversation = db.Table(
'dog_conversation',
col('dog_id', db.Integer, db.ForeignKey('dog.id', ondelete="CASCADE")),
col('conversation_id', db.Integer,
db.ForeignKey('conversation.id', ondelete="CASCADE")))
class Dog(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False)
details = db.Column(db.String(300), nullable=True)
owner_id = db.Column(db.Integer,
db.ForeignKey('owner.id', ondelete="CASCADE"))
breed_id = db.Column(db.Integer, db.ForeignKey('breed.id'))
gender = db.Column(db.Boolean, nullable=False)
breed = db.relationship("Breed", backref="dog", cascade="all, delete")
photos = db.relationship("Photo",
backref="dog",
cascade="all, delete",
passive_deletes=True)
interest = db.relationship("Interest",
backref="dog",
cascade="all, delete")
from app.models import db
store_workingday = db.Table(
'store_workingday',
db.Column('store_id',
db.Integer,
db.ForeignKey('store.id'),
primary_key=True),
db.Column('workingday_id',
db.Integer,
db.ForeignKey('workingday.id'),
primary_key=True))
from app.models import db
company_skills = db.Table(
"company_skills",
db.Column("company_id", db.Integer, db.ForeignKey("companies.id")),
db.Column("skills_id", db.Integer, db.ForeignKey("skills.id")))
student_skills = db.Table(
"student_skills",
db.Column("student_id", db.Integer, db.ForeignKey("students.id")),
db.Column("skills_id", db.Integer, db.ForeignKey("skills.id")))
from app.models import db
roles_panels = db.Table(
'roles_panels',
db.Column('role_id', db.Integer,
db.ForeignKey('custom_sys_roles.id', ondelete='CASCADE')),
db.Column(
'panel_permission_id',
db.Integer,
db.ForeignKey('panel_permissions.id', ondelete='CASCADE'),
),
)
class PanelPermission(db.Model):
"""Super-Admin Panel Permissions
"""
__tablename__ = 'panel_permissions'
id = db.Column(db.Integer, primary_key=True)
# Super Admin panel name
panel_name = db.Column(db.String)
# Custom System Role
custom_system_roles = db.relationship(
'CustomSysRole',
secondary=roles_panels,
backref=db.backref('panel_permissions', lazy='dynamic'),
)
can_access = db.Column(db.Boolean, default=True)
from flask_login import LoginManager, current_user
from flask_security import RoleMixin, UserMixin, SQLAlchemyUserDatastore, Security
from sqlalchemy import event
from app.load_app import app
from app.models import db, BaseMixin
# login_manager = LoginManager()
# Define models
roles_users = db.Table(
'roles_users', db.Column('user_id', db.Integer(),
db.ForeignKey('users.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('roles.id')))
class Role(BaseMixin, RoleMixin, db.Model):
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
event.listen(Role, 'before_insert', Role.before_insert)
event.listen(Role, 'before_update', Role.before_update)
class User(BaseMixin, UserMixin, db.Model):
name = db.Column(db.String(255), unique=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role',
import datetime
from app.helpers.date_formatter import DateFormatter
from app.helpers.versioning import clean_up_string, clean_html
from app.models import db
speakers_sessions = db.Table('speakers_sessions', db.Column(
'speaker_id', db.Integer, db.ForeignKey('speaker.id', ondelete='CASCADE')), db.Column(
'session_id', db.Integer, db.ForeignKey('session.id', ondelete='CASCADE')))
class Session(db.Model):
"""Session model class"""
__tablename__ = 'session'
__versioned__ = {
'exclude': []
}
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String, nullable=False)
subtitle = db.Column(db.String)
short_abstract = db.Column(db.Text)
long_abstract = db.Column(db.Text)
comments = db.Column(db.Text)
start_time = db.Column(db.DateTime, nullable=False)
end_time = db.Column(db.DateTime, nullable=False)
track_id = db.Column(db.Integer, db.ForeignKey('tracks.id', ondelete='CASCADE'))
speakers = db.relationship(
'Speaker',
secondary=speakers_sessions,
backref=db.backref('sessions', lazy='dynamic'))
language = db.Column(db.String)
from app.models import db
from .products import Products
sector_product = db.Table(
'sector_product',
db.Column('products_id', db.Integer, db.ForeignKey('products.id')),
db.Column('sectors_id', db.Integer, db.ForeignKey('sectors.id')))
class Sectors(db.Model):
__tablename__ = 'sectors'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), nullable=False, unique=True)
slug = db.Column(db.String(30), unique=True)
products = db.relationship(Products,
secondary=sector_product,
backref=db.backref('sectors', lazy='dynamic'))
def __init__(self, name):
self.name = name
self.slug = name.replace(' ', '_').lower()
def __repr__(self):
return f'< Sector {self.name} >'
from app.api.helpers.errors import ConflictError
from app.models import db
from app.models.base import SoftDeletionModel
from app.models.order import Order, OrderTicket
from app.models.ticket_holder import TicketHolder
from sqlalchemy import or_
access_codes_tickets = db.Table(
'access_codes_tickets',
db.Column('access_code_id', db.Integer,
db.ForeignKey('access_codes.id', ondelete='CASCADE')),
db.Column('ticket_id', db.Integer,
db.ForeignKey('tickets.id', ondelete='CASCADE')),
db.PrimaryKeyConstraint('access_code_id', 'ticket_id'),
)
discount_codes_tickets = db.Table(
'discount_codes_tickets',
db.Column(
'discount_code_id',
db.Integer,
db.ForeignKey('discount_codes.id', ondelete='CASCADE'),
),
db.Column('ticket_id', db.Integer,
db.ForeignKey('tickets.id', ondelete='CASCADE')),
db.PrimaryKeyConstraint('discount_code_id', 'ticket_id'),
)
ticket_tags_table = db.Table(
'ticket_tagging',
db.Model.metadata,
from app.models import db
from datetime import datetime
import pytz
import time
import random
process_headers = db.Table(
'process_headers',
db.Column('process_id', db.Integer,
db.ForeignKey('processes.id', ondelete='CASCADE')),
db.Column('header_id', db.Integer,
db.ForeignKey('headers.id', ondelete='CASCADE')))
class Process(db.Model):
"""Request model class"""
__tablename__ = 'processes'
id = db.Column(db.Integer, primary_key=True)
time = db.Column(db.DateTime(timezone=True),
default=datetime.now(pytz.utc))
method = db.Column(db.String)
path = db.Column(db.String)
query = db.Column(db.String)
body = db.Column(db.String)
headers = db.relationship('Header',
secondary=process_headers,
backref=db.backref('processes', lazy='dynamic'))
duration = db.Column(db.String)
