@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
# ---- 密码哈希 ----
def __repr__(self):
return '<User {}>'.format(self.username)
post_tag = db.Table(
'post_tag',
db.Column('id', db.Integer, primary_key=True),
db.Column('post_id', db.Integer, db.ForeignKey('post.id')),
db.Column('tag_id', db.Integer, db.ForeignKey('tag.id'))
)
class Post(db.Model):
__tablename__ = 'post'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255))
text = db.Column(db.Text)
publish_date = db.Column(db.DateTime)
modified_date = db.Column(db.DateTime)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
tags = db.relationship(
from extensions import db, uploaded_images
from datetime import datetime
import humanize
# Create a table to support a many-to-many relationship between Users and Roles
tags_posts = db.Table(
'tags_posts', db.Column('post_id', db.Integer(), db.ForeignKey('post.id')),
db.Column('tag_id', db.Integer(), db.ForeignKey('tag.id')))
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
title = db.Column(db.String(80))
subtitle = db.Column(db.String(80))
body = db.Column(db.Text)
image = db.Column(db.String(125))
slug = db.Column(db.String(125), unique=True)
publish_date = db.Column(db.DateTime)
live = db.Column(db.Boolean)
# tags have been disabled
tags = db.relationship('Tag',
secondary=tags_posts,
backref=db.backref('posts', lazy='dynamic'))
# get the whole image path
@property
def imgsrc(self):
if self.image:
return uploaded_images.url(self.image)
else:
from extensions import db
from datetime import datetime
__all__ = ['Game']
game_genre = db.Table('game_genre',
db.Column('game_id',
db.Integer,
db.ForeignKey('games.id'),
primary_key=True),
db.Column('genre_id',
db.Integer,
db.ForeignKey('genres.id'),
primary_key=True),
extend_existing=True)
class Game(db.Model):
__tablename__ = 'games'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String, unique=True, nullable=False)
slug = db.Column(db.String, unique=True, nullable=False)
synopsis = db.Column(db.Text, nullable=False)
icon = db.Column(db.String, unique=True, nullable=False)
banner = db.Column(db.String, unique=True, nullable=False)
developer_id = db.Column(db.Integer,
db.ForeignKey('developers.id'),
nullable=False)
score = db.Column(db.Float, nullable=True)
import datetime
from uuid import uuid4
# Third-party imports
import jwt
# Local imports
from database import Config
from extensions import db
# Many to many relationship table
podcast_genre = db.Table(
'podcast_genre',
db.Column('podcastId',
db.Integer,
db.ForeignKey('podcast.id'),
primary_key=True),
db.Column('genreId',
db.Integer,
db.ForeignKey('genre.genreId'),
primary_key=True))
class Podcast(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
kind = db.Column(db.String(50))
copyright = db.Column(db.String(255), nullable=True)
releaseDate = db.Column(db.String(10))
contentAdvisoryRating = db.Column(db.String(50), nullable=True)
url = db.Column(db.String(1000))
artworkUrl100 = db.Column(db.String(1000))
from extensions import db
from flask import flash
from flask_admin.contrib import sqla
from flask_security import UserMixin, RoleMixin, current_user, utils
from wtforms import validators, StringField, PasswordField
from inni.models import Post
from datetime import datetime
import datetime
# Create a table to support a many-to-many relationship between Users and Roles
roles_users = db.Table(
'roles_users', db.Column('user_id', db.Integer(),
db.ForeignKey('user.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('role.id')))
# Role class
class Role(db.Model, RoleMixin):
# Our Role has three fields, ID, name and description
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
# __str__ is required by Flask-Admin, so we can have human-readable values for the Role when editing a User.
# If we were using Python 2.7, this would be __unicode__ instead.
def __str__(self):
return self.name
# __hash__ is required to avoid the exception TypeError: unhashable type: 'Role' when saving a User
def __hash__(self):
from sqlalchemy_utils import aggregated
from extensions import db
import datetime
#----------------------------------------------------------------------------#
# Models.
#----------------------------------------------------------------------------#
venue_genres = db.Table('venue_genres',
db.Column('venue_id', db.Integer, db.ForeignKey('Venue.id'), primary_key=True),
db.Column('genre_id', db.Integer, db.ForeignKey('Genre.id'), primary_key=True)
)
artist_genres = db.Table('artist_genres',
db.Column('artist_id', db.Integer, db.ForeignKey('Artist.id'), primary_key=True),
db.Column('genre_id', db.Integer, db.ForeignKey('Genre.id'), primary_key=True)
)
class Venue(db.Model):
__tablename__ = 'Venue'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False, unique=True)
city_id = db.Column(db.Integer, db.ForeignKey('City.id'), nullable=False)
address = db.Column(db.String(120), nullable=False)
phone = db.Column(db.String(120), nullable=False)
image_link = db.Column(db.String(500), nullable=True)
facebook_link = db.Column(db.String(120), nullable=True)
website = db.Column(db.String(120), nullable=True)
seeking_talent = db.Column(db.Boolean, nullable=True)
from extensions import db
from builtins import classmethod
## helper table many to many
rolePerms = db.Table(
'roles_perms',
db.Column('role_id',
db.Integer,
db.ForeignKey('role.id'),
primary_key=True),
db.Column('perm_id',
db.Integer,
db.ForeignKey('perms.id'),
primary_key=True))
class Role(db.Model):
__tablename__ = 'role'
id = db.Column(db.Integer, primary_key=True)
# Is exactly a value from RoleNames TODO relation
name = db.Column(db.String(80), nullable=False, unique=True)
permissions = db.relationship('Permission',
secondary=rolePerms,
lazy='subquery',
backref=db.backref('roles', lazy=False))
created_at = db.Column(db.DateTime(),
nullable=False,
from extensions import db
user_viewed_offer = db.Table('user_viewed_offer',
db.Column('user_address', db.String(50), db.ForeignKey('user.email'), primary_key=True),
db.Column('offer_id', db.Integer, db.ForeignKey('offer.id'), primary_key=True)
)
from extensions import db
offer_interest = db.Table(
'offer_interest',
db.Column('offer_id',
db.Integer,
db.ForeignKey('offer.id'),
primary_key=True),
db.Column('interest_id',
db.Integer,
db.ForeignKey('interest.id'),
primary_key=True))
#文章
#标签
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50))
email = db.Column(db.String(50))
article_tag_table = db.Table(
'article_tag',
db.Column('article_id',
db.Integer,
db.ForeignKey('article.id'),
primary_key=True),
db.Column('tag_id', db.Integer, db.ForeignKey('tags.id'),
primary_key=True),
)
class Article(db.Model):
__tablename__ = 'article'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100))
content = db.Column(db.Text)
author_id = db.Column(db.Integer, db.ForeignKey('user.id'))
author = db.relationship('User', backref='articles')
tags = db.relationship('Tag', secondary=article_tag_table, backref='tag')
from extensions import db
user_interest = db.Table(
'user_interest',
db.Column('user_address',
db.String(50),
db.ForeignKey('user.email'),
primary_key=True),
db.Column('interest_id',
db.Integer,
db.ForeignKey('interest.id'),
primary_key=True))
"lastName": self.last_name,
"genre": self.genre,
"status": self.status,
"dateBirth": self.date_birth,
"email": self.email,
"aboutMe": self.about_me,
"avatar": self.avatar,
"phone": self.phone,
"lastAcess": self.last_access,
}
kindness_tags_association = db.Table(
'Kindness_Tags',
db.Column('id_kindness',
db.Integer,
db.ForeignKey('Kindness.id_kindness'),
primary_key=True),
db.Column('id_tag', db.Integer, db.ForeignKey('Tags.id'),
primary_key=True))
class Kindness(db.Model):
__tablename__ = "Kindness"
id_kindness = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(50))
identifier = db.Column(db.String(40), unique=True, nullable=False)
body = db.Column(db.Text, nullable=False)
latitude = db.Column(db.Float, nullable=False)
longitude = db.Column(db.Float, nullable=False)
post_date = db.Column(db.DateTime, default=datetime.datetime.now)
# coding:utf-8
from extensions import db
ratings = db.Table(
'ratings', db.Column('rating_id', db.Integer, primary_key=True),
db.Column('user_id',
db.Integer,
db.ForeignKey('users.user_id'),
index=True),
db.Column('m_id', db.Integer, db.ForeignKey('movies.m_id'), index=True),
db.Column('rating', db.Integer))
class Users(db.Model):
user_id = db.Column(db.Integer, primary_key=True)
nickname = db.Column(db.String(128))
user_md5 = db.Column(db.String(64))
my_movies = db.relationship('Movies',
secondary=ratings,
back_populates='users')
__table_arg__ = {'mysql_charset': 'utf8mb4'}
class Movies(db.Model):
m_id = db.Column(db.Integer, primary_key=True)
m_title = db.Column(db.String(255))
m_img = db.Column(db.String(255))
m_url = db.Column(db.String(255))
users = db.relationship('Users',
secondary=ratings,
back_populates='my_movies')
from extensions import db
want_to_read = db.Table('want_to_read',
db.Column('owner_id', db.Integer, db.ForeignKey('users.user_id')),
db.Column('book_id', db.Integer, db.ForeignKey('books.book_id')))
reading_now = db.Table('reading_now',
db.Column('reader_id', db.Integer, db.ForeignKey('users.user_id')),
db.Column('book_id', db.Integer, db.ForeignKey('books.book_id')))
# -*- coding: utf-8 -*-
from extensions import db
from sqlalchemy.ext.hybrid import hybrid_property
cardsarchetypes = db.Table('cardsarchetypes',
db.Column('card_id', db.Integer, db.ForeignKey('cards.id')),
db.Column('archetype_id', db.Integer, db.ForeignKey('archetypes.id'))
)
class Card(db.Model):
__tablename__ = 'cards'
id = db.Column(db.Integer, primary_key=True)
codepass = db.Column(db.String, nullable=False)
name = db.Column(db.String, nullable=False)
text = db.Column(db.String, nullable=False)
illegal = db.Column(db.Boolean, nullable=False)
has_name_condition = db.Column(db.Boolean, nullable=False)
type = db.Column(db.Enum('monster', 'spell', 'trap'), nullable=False)
rarities = db.relationship('Rarity', backref='cards', lazy=True)
archetypes = db.relationship("Archetype", secondary=cardsarchetypes, back_populates="cards")
__mapper_args__ = {'polymorphic_on': type}
class Archetype(db.Model):
__tablename__ = 'archetypes'
id = db.Column(db.Integer, primary_key=True)
last_name = db.Column(db.String(100))
password = db.Column(db.String(100))
posts = db.relationship('Blogpost', backref='user', lazy='dynamic')
def __init__(self, username, password, fname, lname):
self.username = username
self.first_name = fname
self.last_name = lname
self.password = password
def __repr__(self):
return '<User - {}>'.format(self.username)
replies = db.Table(
'replies',
db.Column('original_id', db.Integer, db.ForeignKey('blogpost.id')),
db.Column('reply_id', db.Integer, db.ForeignKey('blogpost.id')))
class Blogpost(db.Model):
id = db.Column(db.Integer, primary_key=True)
parentId = db.Column(db.Integer, default=-1)
title = db.Column(db.String(100))
text = db.Column(db.Text())
date = db.Column(db.DateTime())
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
replies = db.relationship('Blogpost',
secondary=replies,
primaryjoin='Blogpost.id==replies.c.original_id',
secondaryjoin='Blogpost.id==replies.c.reply_id',
backref=db.backref('posts', lazy='dynamic'),
from extensions import db
from sqlalchemy.ext.hybrid import hybrid_property
from sqlalchemy.sql.expression import join, union_all
import random
game_family_assoc = db.Table('game_family_assoc',
db.Column('game_id', db.Integer, db.ForeignKey('game.id'), primary_key=True),
db.Column('family_id', db.Integer, db.ForeignKey('family.id'), primary_key=True)
)
game_genre_assoc = db.Table('game_genre_assoc',
db.Column('game_id', db.Integer, db.ForeignKey('game.id'), primary_key=True),
db.Column('genre_id', db.Integer, db.ForeignKey('genre.id'), primary_key=True)
)
game_publisher_assoc = db.Table('game_publisher_assoc',
db.Column('game_id', db.Integer, db.ForeignKey('game.id'), primary_key=True),
db.Column('publisher_id', db.Integer, db.ForeignKey('publisher.id'), primary_key=True)
)
game_artist_assoc = db.Table('game_artist_assoc',
db.Column('game_id', db.Integer, db.ForeignKey('game.id'), primary_key=True),
db.Column('artist_id', db.Integer, db.ForeignKey('artist.id'), primary_key=True)
)
game_developer_assoc = db.Table('game_developer_assoc',
db.Column('game_id', db.Integer, db.ForeignKey('game.id'), primary_key=True),
db.Column('developer_id', db.Integer, db.ForeignKey('developer.id'), primary_key=True)
)
# -*- coding: utf-8 -*-
from extensions import db
from datetime import datetime
from flask_login import UserMixin, LoginManager, current_user
login_manager = LoginManager()
# 关联【用户】和【权限】
user_permission = db.Table(
'user_permission',
db.Column('user_id',
db.Integer,
db.ForeignKey('user.u_id'),
primary_key=True),
db.Column('permission_id',
db.Integer,
db.ForeignKey('permission.p_id'),
primary_key=True))
@login_manager.user_loader
def load_user(u_id):
return User.query.get(int(u_id))
# 用户模型
class User(UserMixin, db.Model):
__tablename__ = 'user'
u_id = db.Column(db.Integer,
primary_key=True,
autoincrement=True,
from datetime import datetime
from extensions import db
historic = db.Table(
'Historic',
db.Column('id_client',
db.Integer,
db.ForeignKey('Client.id'),
primary_key=True),
db.Column('id_book',
db.Integer,
db.ForeignKey('Book.id'),
primary_key=True),
db.Column('reading_date', db.DateTime, default=datetime.utcnow))
class Client(db.Model):
__tablename__ = "Client"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(30), unique=True, nullable=False)
email = db.Column(db.String(100), unique=True, nullable=False)
password = db.Column(db.String(70), nullable=False)
def __init__(self, username, email, password):
self.username = username
self.email = email
self.password = password
def __repr__(self):
return "Client <{}>".format(self.username)
from extensions import db
from datetime import datetime
__all__ = ['User']
user_role = db.Table('user_role',
db.Column('role_id', db.Integer, db.ForeignKey('roles.id'), primary_key=True),
db.Column('user_id', db.Integer, db.ForeignKey('users.id'), primary_key=True),
extend_existing=True
)
user_following = db.Table('followers',
db.Column('follower_id', db.Integer, db.ForeignKey('users.id'), primary_key=True),
db.Column('leader_id', db.Integer, db.ForeignKey('users.id'), primary_key=True),
extend_existing=True
)
class User(db.Model):
__tablename__ = 'users'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String, unique=True, nullable=False)
email = db.Column(db.String, unique=True, nullable=False)
password = db.Column(db.Text, nullable=False)
is_verified = db.Column(db.Integer, default=0)
roles = db.relationship('Role', secondary=user_role,
backref=db.backref('users'))
about_me = db.Column(db.Text, unique=False, nullable=True)
avatar = db.Column(db.String, unique=False, nullable=True)
banner = db.Column(db.String, unique=False, nullable=True)
import os
from datetime import datetime
from flask import current_app
from flask_avatars import Identicon
from flask_login import UserMixin
from werkzeug.security import generate_password_hash, check_password_hash
from extensions import db, whooshee
roles_permissions = db.Table(
'roles_permissions',
db.Column('role_id', db.Integer, db.ForeignKey('role.id')),
db.Column('permission_id', db.Integer, db.ForeignKey('permission.id')))
class Permission(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), unique=True)
roles = db.relationship('Role',
secondary=roles_permissions,
back_populates='permissions')
class Role(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), unique=True)
users = db.relationship('User', back_populates='role')
permissions = db.relationship('Permission',
secondary=roles_permissions,
back_populates='roles')
from flask_login import UserMixin
from extensions import db
from sqlalchemy.orm import relationship
log_food = db.Table('log_food',
db.Column('date_id', db.Integer, db.ForeignKey('date.id'), primary_key=True),
db.Column('food_id', db.Integer, db.ForeignKey('food.id'), primary_key=True)
)
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
public_id = db.Column(db.String, nullable=False)
name = db.Column(db.String, nullable=False)
email = db.Column(db.String, nullable=False)
password = db.Column(db.String, nullable=False)
confirmed_email = db.Column(db.Boolean, default=False)
join_date = db.Column(db.String)
dates = relationship('Date', back_populates='user')
foods = relationship('Food', back_populates='user')
class Food(db.Model):
id = db.Column(db.Integer, primary_key=True)
public_id = db.Column(db.String, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = relationship('User', back_populates='foods')
name = db.Column(db.String, unique=True, nullable=False)
proteins = db.Column(db.Integer, nullable=False)
if is_accepting_new_patients:
matching_users = matching_users.filter(
ProviderModel.addresses.any(
AddressModel.is_accepting_new_patients == True))
matching_users = matching_users.paginate(page, 6, False)
return matching_users
# An association table (many-to-many) for
# mapping care providers to the designations they have.
provider_to_designation_association_table = db.Table(
'providers_to_designations',
db.Column('provider_id', db.Integer, db.ForeignKey('providers.user_id')),
db.Column('designation_id', db.Integer, db.ForeignKey('designations.id')),
)
# An association table (many-to-many) for
# mapping care providers to the languages they speak.
provider_to_language_association_table = db.Table(
'providers_to_languages',
db.Column('provider_id', db.Integer, db.ForeignKey('providers.user_id')),
db.Column('language_id', db.Integer, db.ForeignKey('languages.id')),
)
def append_to_association_table(self, child_model_obj,
parent_model_obj_with_attribute):
parent_model_obj_with_attribute.append(child_model_obj)
from extensions import db
from datetime import datetime
from models.tag import TagModel
tags_events = db.Table(
'tags_events',
db.Column('tag_id', db.Integer, db.ForeignKey('tags.id'),
primary_key=True),
db.Column('event_id',
db.Integer,
db.ForeignKey('events.id'),
primary_key=True))
class EventModel(db.Model):
__tablename__ = "events"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
description = db.Column(db.String(255))
capacity = db.Column(db.Integer)
organizer_id = db.Column(db.Integer, db.ForeignKey("organizers.id"))
start_time = db.Column(db.DateTime)
end_time = db.Column(db.DateTime)
location_id = db.Column(db.Integer, db.ForeignKey("locations.id"))
is_published = db.Column(db.Boolean, default=0)
pub_date = db.Column(db.DateTime, default=datetime.utcnow)
organizer = db.relationship("OrganizerModel", backref="events")
location = db.relationship("LocationModel", backref="events")
tags = db.relationship('TagModel',
from extensions import db
from datetime import datetime
from sqlalchemy.sql.expression import func
from sqlalchemy import event
categories = db.Table(
'recipes_categories',
db.Column('category_id', db.Integer, db.ForeignKey('categories.id')),
db.Column('recipe_id', db.Integer, db.ForeignKey('recipes.id')))
class Recipe(db.Model):
__tablename__ = 'recipes'
"""
Model for the Recipe created by the users.
"""
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(150), index=True)
quantity = db.Column(db.String(15))
directions = db.relationship('Direction', backref='Recipe', lazy='dynamic')
ingredients = db.relationship('Ingredient',
backref='Recipe',
lazy='dynamic')
categories = db.relationship('Category',
secondary=categories,
backref=db.backref('recipes', lazy='dynamic'))
created_at = db.Column(db.DateTime, default=datetime.utcnow())
def __repr__(self):
return '<%s>' % (self.title)
