def has_bills(self):
"""return if the user do have bills or not"""
bills_as_ower_number = db.session.query(billowers)\
.filter(billowers.columns.get("person_id") == self.id)\
.count()
return bills_as_ower_number != 0 or len(self.bills) != 0
def __str__(self):
return self.name
def __repr__(self):
return "<Person %s for project %s>" % (self.name, self.project.name)
# We need to manually define a join table for m2m relations
billowers = db.Table('billowers',
db.Column('bill_id', db.Integer, db.ForeignKey('bill.id')),
db.Column('person_id', db.Integer, db.ForeignKey('person.id')),
)
class Bill(db.Model):
class BillQuery(BaseQuery):
def get(self, project, id):
try:
return self.join(Person, Project)\
.filter(Bill.payer_id == Person.id)\
.filter(Person.project_id == Project.id)\
.filter(Project.id == project.id)\
.filter(Bill.id == id).one()
app.config.update({
'OIDC_CLIENT_SECRETS': './client_secrets.json',
'OIDC_RESOURCE_SERVER_ONLY': True
})
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + \
os.path.join(basedir, 'db.sqlite')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)
ma = Marshmallow(app)
oidc = OpenIDConnect(app)
CORS(app)
# Models
favorites = db.Table('favorites',
db.Column('user_id', db.Integer, db.ForeignKey(
'user.id'), primary_key=True),
db.Column('house_id', db.Integer, db.ForeignKey(
'house.id'), primary_key=True)
)
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(200), unique=True, nullable=False)
favorites = db.relationship(
'House', secondary=favorites, lazy='subquery', backref=db.backref('followers', lazy=True)
)
def __init__(self, email):
username = db.Column(db.String(16), unique=True)
password = db.Column(db.String(250))
u_create_time = db.Column(db.DateTime, default=datetime.now())
role_id = db.Column(db.Integer, db.ForeignKey('role.r_id'))
class Role(db.Model):
r_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
r_name = db.Column(db.String(10), unique=True)
users = db.relationship('User', backref='role')
r_p = db.Table(
'r_p',
db.Column('role_id',
db.Integer,
db.ForeignKey('role.r_id'),
primary_key=True),
db.Column('permission_id',
db.Integer,
db.ForeignKey('permission.p_id'),
primary_key=True))
class Permission(db.Model):
p_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
p_name = db.Column(db.String(16), unique=True)
p_er = db.Column(db.String(16), unique=True)
roles = db.relationship('Role',
secondary=r_p,
backref=db.backref('permission'))
db.ForeignKey("posts.id"),
nullable=False,
primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=False,
primary_key=True)
order = db.Column(db.Integer)
post = db.relationship('Post', lazy='joined')
author = db.relationship('User', lazy='joined')
assoc_post_tag = db.Table(
'assoc_post_tag', db.Model.metadata,
db.Column('post_id', db.Integer, db.ForeignKey('posts.id')),
db.Column('tag_id', db.Integer, db.ForeignKey('tags.id')))
assoc_post_group = db.Table(
'assoc_post_group', db.Model.metadata,
db.Column('post_id', db.Integer, db.ForeignKey('posts.id')),
db.Column('group_id', db.Integer, db.ForeignKey('groups.id')))
assoc_group_user = db.Table(
'assoc_group_user', db.Model.metadata,
db.Column('group_id', db.Integer, db.ForeignKey('groups.id')),
db.Column('user_id', db.Integer, db.ForeignKey('users.id')))
class Comment(db.Model):
__tablename__ = 'comments'
) # using the async email to make sure the email sending doesn't take up all the "app energy" -- the main thread -- at once
thr.start()
return thr
#########
######### Everything above this line is important/useful setup, not problem-solving.
#########
#########
##### Set up Models #####
# Association table - Tweets and Hashtags
tweet_hashtags = db.Table(
'tweet_hashtags',
db.Column('tweet_id', db.Integer, db.ForeignKey('tweets.id')),
db.Column('hashtag_id', db.Integer, db.ForeignKey('hashtags.id')))
# Tweet model
class Tweet(db.Model):
__tablename__ = "tweets"
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.String(285))
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
hashtags = db.relationship('Hashtag',
secondary=tweet_hashtags,
backref=db.backref('tweets', lazy='dynamic'),
lazy='dynamic')
def __repr__(self):
from sqlalchemy import func
from flask_sqlalchemy import SQLAlchemy
from flask_marshmallow import Marshmallow
from marshmallow import fields
from sqlalchemy import create_engine
from werkzeug.security import generate_password_hash, check_password_hash
import uuid
db = SQLAlchemy()
ma = Marshmallow()
TrackCatalogTable = db.Table(
'track_catalog_table',
db.Column('track_id', db.Integer, db.ForeignKey('track.id')),
db.Column('catalog_id', db.Integer, db.ForeignKey('catalog.id')))
BundleVersionTable = db.Table(
'bundle_version_table',
db.Column('bundle_id', db.Integer, db.ForeignKey('bundle.id')),
db.Column('version_id', db.Integer, db.ForeignKey('version.id')))
class Bundle(db.Model):
"""Bundle, containing multiple versions."""
__tablename__ = 'bundle'
id = db.Column(db.Integer, primary_key=True)
bundle_number = db.Column(db.String(50), unique=True)
bundle_name = db.Column(db.String(30))
from flask_sqlalchemy import SQLAlchemy
from flask import Flask
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///many.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)
association = db.Table(
'association', db.Column('user_id', db.Integer, db.ForeignKey('users.id')),
db.Column('channel_id', db.Integer, db.ForeignKey('channels.channel_id')))
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
subscriptions = db.relationship('Channel',
secondary=association,
backref=db.backref('subscribers',
lazy='dynamic'))
class Channel(db.Model):
__tablename__ = 'channels'
channel_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
db.create_all()
actor_fee=500.00)
new_actor.insert()
new_movie.insert()
db.session.execute(new_performance)
db.session.commit()
#----------------------------------------------------------------------------#
# Performance Junction Object N:N
#----------------------------------------------------------------------------#
# Instead of creating a new Table, the documentation recommends to create a association table
Performance = db.Table(
'Performance', db.Model.metadata,
db.Column('Movie_id', db.Integer, db.ForeignKey('movies.id')),
db.Column('Actor_id', db.Integer, db.ForeignKey('actors.id')),
db.Column('actor_fee', db.Float))
#----------------------------------------------------------------------------#
# Actors Model
#----------------------------------------------------------------------------#
class Actor(db.Model):
__tablename__ = 'actors'
id = Column(Integer, primary_key=True)
name = Column(String)
gender = Column(String)
age = Column(Integer)
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = (os.environ.get('DATABASE_URL')
or FALLBACK_DB)
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
db = SQLAlchemy(app)
manager = Manager(app)
SQL_MAXINT = int(2**63 - 1)
# Database Models
user_groups = db.Table(
'user_groups',
db.Column('user_id', db.Integer, db.ForeignKey('users.id')),
db.Column('group_id', db.Integer, db.ForeignKey('groups.id')),
)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
email = db.Column(db.String, nullable=False)
groups = db.relationship('Group',
secondary=user_groups,
backref=db.backref('users', lazy='dynamic'),
lazy='dynamic')
def __repr__(self):
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///forum.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['DEBUG'] = True
app.config['SECRET_KEY'] = 'mysecret'
app.config['SECURITY_REGISTERABLE'] = True
app.config['SECURITY_PASSWORD_SALT'] = 'somesaltfortheforum'
app.config['SECURITY_SEND_REGISTER_EMAIL'] = False
db = SQLAlchemy(app)
migrate = Migrate(app, db)
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')))
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(250))
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
name = db.Column(db.String(255))
username = db.Column(db.String(255), unique=True)
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
class Author(db.Model):
id = db.Column(db.Integer, primary_key=True)
names = db.Column(db.String(100), unique=True)
def __init__(self, names):
self.names = names
def __repr__(self):
return "<Author %r>" % (self.names)
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")),
)
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
def __init__(self, name):
self.name = name
def __repr__(self):
return "<Role %r>" % (self.name)
@login_manager.user_loader
def load_user(user_id):
return User.query.get(int(user_id))
########################
## Association tables ##
########################
# Set up association Table between list and articles
#on_list = db.Table('on_list',db.Column('item_id',db.Integer, db.ForeignKey('items.id')),db.Column('list_id',db.Integer, db.ForeignKey('lists.id')))
#########################
## Searches + Articles ##
#########################
searches = db.Table('searches', db.Column('term', db.Integer, db.ForeignKey('searchterms.id')), db.Column('results', db.Integer, db.ForeignKey('items.id')))
#########################
## Users + Articles ##
#########################
user_collection = db.Table('user_collection', db.Column('user_id', db.Integer, db.ForeignKey('personallists.id')), db.Column('article_id', db.Integer, db.ForeignKey('items.id')))
class ArticleOnList(db.Model):
__tablename__ = "items"
id = db.Column(db.Integer, primary_key=True)
headline = db.Column(db.String(225))
author = db.Column(db.String(225))
summary = db.Column(db.String())
date = db.Column(db.String())
app.config["SQLALCHEMY_DATABASE_URI"] = database_path
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
db.app = app
db.init_app(app)
migrate.init_app(app, db)
# db.create_all()
'''
Movies Actors M2M table
'''
movies_actors = db.Table(
'movies_actors',
db.Column('movie_id',
db.Integer,
db.ForeignKey('Movie.id'),
primary_key=True),
db.Column('actor_id',
db.Integer,
db.ForeignKey('Actor.id'),
primary_key=True))
'''
Movie
'''
class Movie(db.Model):
__tablename__ = 'Movie'
id = db.Column(db.Integer, primary_key=True)
from flask_sqlalchemy import SQLAlchemy
db = SQLAlchemy()
class AppModel(db.Model):
__abstract__ = 1
id = db.Column(db.Integer, primary_key=1)
create_datetime = db.Column(db.DateTime, default=func.now())
update_datetime = db.Column(db.DateTime, default=func.now())
def save(self):
db.session.add(self)
db.session.commit()
def to_dict(self):
pass
roles_users = db.Table(
"roles_users", db.Column("role_id", db.Integer, db.ForeignKey("role.id")),
db.Column("user_id", db.Integer, db.ForeignKey("user.id")))
from .role import Role
from .user import User
from flask_sqlalchemy import SQLAlchemy
from flask_login import AnonymousUserMixin
from .extensions import bcrypt
db = SQLAlchemy()
roles = db.Table('role_users',
db.Column('user_id', db.Integer, db.ForeignKey('user.id')),
db.Column('role_id', db.Integer, db.ForeignKey('role.id')))
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(255))
password = db.Column(db.String(255))
posts = db.relationship('Post', backref='user', lazy='dynamic')
roles = db.relationship('Role',
secondary=roles,
backref=db.backref('users', lazy='dynamic'))
def __init__(self, username):
self.username = username
def __repr__(self):
return "<User '{}'>".format(self.username)
def set_password(self, password):
self.password = bcrypt.generate_password_hash(password)
def check_password(self, password):
from flask_sqlalchemy import SQLAlchemy
from flask import Flask, request, jsonify, url_for
db = SQLAlchemy()
fav_char = db.Table(
'fav_chars', db.metadata,
db.Column("user_id", db.Integer, db.ForeignKey("users.id")),
db.Column("char_id", db.Integer, db.ForeignKey("characters.id")))
fav_planet = db.Table(
'fav_planets', db.metadata,
db.Column("user_id", db.Integer, db.ForeignKey("users.id")),
db.Column("plan_id", db.Integer, db.ForeignKey("planets.id")))
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(250), nullable=False)
lastname = db.Column(db.String(250), nullable=False)
username = db.Column(db.String(250), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(80), unique=False, nullable=False)
is_active = db.Column(db.Boolean(),
unique=False,
nullable=False,
default=True)
characters = db.relationship("Character",
secondary=fav_char,
back_populates="users")
msg.html = render_template(template + '.html', **kwargs)
thr = Thread(target=send_email, args=[app, msg]) # using the async email to make sure the email sending doesn't take up all the "app energy" -- the main thread -- at once
thr.start()
return thr # The thread being returned
# However, if your app sends a LOT of email, it'll be better to set up some additional "queuing" software libraries to handle it. But we don't need to do that yet. Not quite enough users!
#########
######### Everything above this line is important/useful setup, not problem-solving.
#########
#########
##### Set up Models #####
# Association table - Tweets and Hashtags
tweet_hashtags = db.Table('tweet_hashtags', db.Column('tweet_id', db.Integer, db.ForeignKey('tweets.id')), db.Column('hashtag_id', db.Integer, db.ForeignKey('hashtags.id')))
# Tweet model
class Tweet(db.Model):
__tablename__ = "tweets"
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.String(285))
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
hashtags = db.relationship('Hashtag', secondary=tweet_hashtags, backref=db.backref('tweets', lazy='dynamic'),lazy='dynamic')
def __repr__(self):
return "{}, (ID: {})".format(self.text,self.id)
# TODO: Add and run a migration so that each twitter username also saves an associated email.
# User model
class User(db.Model):
# class User(db.Model):
# id = db.Column(db.Integer, primary_key=True)
# username = db.Column(db.String(255))
# email = db.Column(db.String(255), unique=True)
# def __init__(self, username, email):
# self.username = username
# self.email = email
# def __repr__(self):
# return '<User %r>' % self.username
# Define models
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')))
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=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())
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate
db = SQLAlchemy()
migrate = Migrate(db)
project_owner_assoc = db.Table(
'project_owner',
db.Column('project_id',
db.Integer,
db.ForeignKey('project.id'),
primary_key=True),
db.Column('owner_id',
db.Integer,
db.ForeignKey('owner.id'),
primary_key=True))
class Address(db.Model):
id = db.Column(db.Integer, primary_key=True)
address = db.Column(db.String(100))
city = db.Column(db.String(50))
state = db.Column(db.String(50))
zip = db.Column(db.Integer)
owner_id = db.Column(db.Integer, db.ForeignKey('owner.id'))
coordinate = db.relationship("Coordinate",
uselist=False,
backref="address")
def __repr__(self):
return f'Address(address={self.address}, zip={self.zip})'
'category_id': self.category_id,
'post_num': self.post_num,
'board_image': self.board_image
}
# ----------------------------------------------------------------------------------------------------------------
# 유저와 게시글을 한 쌍으로 갖는 post_like 테이블 객체를 생성하였다.
# 유저와 게시글이 모두 프라이머리키이므로 ManyToMany 관계가 성립되는 테이블
# 중복을 막을수 있는 이유는 둘다 프라이머리키이기 때문에 (1,1) (1,1) 이들어오면 데이터베이스 차원에서 오류가 난다.
# secondary 속성은 like가 ManyToMany 관계이며 post_like 테이블을 참조한다는 사실을 알려주는 역할
# ----------------------------------------------------------------------------------------------------------------
post_like = db.Table(
'post_like',
db.Column('user_id',
db.Integer,
db.ForeignKey('user.id', ondelete='CASCADE'),
primary_key=True),
db.Column('post_id',
db.Integer,
db.ForeignKey('post.id', ondelete='CASCADE'),
primary_key=True))
post_report = db.Table(
'post_report',
db.Column('user_id',
db.Integer,
db.ForeignKey('user.id', ondelete='CASCADE'),
primary_key=True),
db.Column('post_id',
db.Integer,
db.ForeignKey('post.id', ondelete='CASCADE'),
primary_key=True))
db = SQLAlchemy(app)
migrate = Migrate(app, db)
@app.template_filter('markdown')
def markdown_filter(s):
return Markup(
markdown.markdown(s,
extensions=['sane_lists', 'smarty'],
output_format='html5'))
# Description linking tables
register_description = db.Table(
'register_description',
db.Column('register_id', db.ForeignKey('register.id'), nullable=False),
db.Column('revision_id',
db.ForeignKey('description_revision.id'),
nullable=False))
field_description = db.Table(
'field_description',
db.Column('field_id', db.ForeignKey('field.id'), nullable=False),
db.Column('revision_id',
db.ForeignKey('description_revision.id'),
nullable=False))
table_description = db.Table(
'table_description',
db.Column('register_id', db.ForeignKey('table.id'), nullable=False),
db.Column('revision_id',
db.ForeignKey('description_revision.id'),
nullable=False))
import logging
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy.sql.schema import Column
from video_upload.app import app
logger = logging.getLogger(__name__)
__all__ = ["db"]
class NotNullableColumn(Column):
def __init__(self, *args, **kwargs):
kwargs.setdefault("nullable", False)
super().__init__(*args, **kwargs)
db = SQLAlchemy(app)
db.Column = NotNullableColumn
db.Model.get_default = lambda self, column_name: getattr(
self.__class__, column_name).default.execute(db.session.bind)
db.Model.__repr__ = lambda self: "<%s id=%s>" % (self.__class__.__name__, self.
id or "0x%x" % id(self))
DATABASE_URI = 'postgres://*****:*****@ec2-52-44-46-66.compute-1.amazonaws.com:5432/dep76g3od832hk'
db = SQLAlchemy()
def setup_db(app, database_path=DATABASE_URI):
app.config["SQLALCHEMY_DATABASE_URI"] = DATABASE_URI
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
db.app = app
db.init_app(app)
db.create_all()
actors_movies = db.Table(
'ActorsMovies',
db.Column('id', db.Integer, primary_key=True),
db.Column('actor_id', db.Integer, db.ForeignKey('Actor.id')),
db.Column('movie_id', db.Integer, db.ForeignKey('Movie.id')),
)
# Movies with attributes title and release date
class Movie(db.Model):
__tablename__ = 'Movie'
id = Column(Integer, primary_key=True)
title = Column(String)
release_date = Column(Date)
actors = db.relationship('Actor', secondary=actors_movies, backref='Movie')
from config import *
from flask_sqlalchemy import SQLAlchemy
from datetime import timezone
db = SQLAlchemy()
# Many-to-many table used to associate frontend users access to channels
channels = db.Table(FE_TBL_UID2CID,
db.Column('uid',
db.Integer,
db.ForeignKey(f'{FE_TBL_USERS}.id'),
primary_key=True),
db.Column('cid',
db.Integer,
db.ForeignKey(f'{FE_TBL_CHANNELS}.id'),
primary_key=True),
info={'bind_key': FRONTEND_BINDKEY})
class User(db.Model):
__bind_key__ = FRONTEND_BINDKEY
__tablename__ = FE_TBL_USERS
id = db.Column(db.Integer, primary_key=True)
# Twitch-specific (for the API/login integration)
user_id = db.Column(db.Integer, index=True, nullable=False)
preferred_name = db.Column(db.String(255), index=True, nullable=False)
access_token = db.Column(db.String(255))
refresh_token = db.Column(db.String(255))
expiry_date = db.Column(db.DateTime(timezone.utc))
# PurpleWhale-specific
id = db.Column(db.Text, primary_key=True)
description = db.Column(db.Text)
class CrimeHourClass(db.Model):
__tablename__ = 'crime_hour_class'
__table_args__ = {'schema': 'crimemgr'}
lower_bound = db.Column(db.Integer)
upper_bound = db.Column(db.Integer)
classification = db.Column('class', db.Integer, primary_key=True)
description = db.Column(db.Text)
CrimeIncidentSimple = db.Table(
'crime_incident_simple',
db.Column('dc_key', db.Text),
db.Column('crime_type', db.Text),
db.Column('dc_dist', db.Text),
db.Column('neighborhood_id', db.Integer),
db.Column('neighborhood_name', db.String(20)),
db.Column('dispatch_month', db.Float(53)),
db.Column('dispatch_weekday', db.Float(53)),
db.Column('dispatch_time', db.Integer),
db.Column('geom', Geometry),
db.Column('dispatch_date_time', db.DateTime),
schema='crimemgr'
)
class CrimeModel(db.Model):
__tablename__ = 'crime_model'
password="******",
hostname="sql12.freemysqlhosting.net",
databasename="sql12231151",
)
app.config["SQLALCHEMY_DATABASE_URI"] = SQLALCHEMY_DATABASE_URI
app.config["SQLALCHEMY_POOL_RECYCLE"] = 299
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
bootstrap = Bootstrap(app)
db = SQLAlchemy(app)
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'login'
currentRoom = None
RoomUsers = db.Table("roomUsers", db.Column("roomId",db.Integer,db.ForeignKey("room.roomID"), primary_key=True),
db.Column("userID",db.Integer,db.ForeignKey("user.id"), primary_key=True))
#this is friends middle table
Friend = db.Table("friend",
db.Column("username1",db.Integer,db.ForeignKey("user.id"),primary_key=True),
db.Column("username2",db.Integer,db.ForeignKey("user.id"),primary_key=True))
class User(UserMixin, db.Model):
id = db.Column(db.Integer,primary_key = True)
username = db.Column(db.String(80), unique=True, nullable=False)
password = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
firstName = db.Column(db.String(80),nullable=False)
lastName = db.Column(db.String(80),nullable=False)
def update(self, name, profile_pic):
self.name = name
self.profile_pic = profile_pic
def __repr__(self):
return f"<Investor {self.id} {self.name}>"
def report_lists(self):
print("investment lists:")
for list in self.investment_lists:
print(list.list_name)
# many to many
association_table = db.Table('association',
db.Column('investment_lists_id', db.Integer, db.ForeignKey(
'investment_lists.id'), primary_key=True),
db.Column('investment_properties_id', db.Integer, db.ForeignKey(
'investment_properties.id'), primary_key=True)
)
class InvestmentList(db.Model):
__tablename__ = 'investment_lists'
id = db.Column(db.Integer, primary_key=True)
list_name = db.Column(db.Text)
investor_id = db.Column(db.Text, db.ForeignKey('investors.id'))
investment_properties = db.relationship("InvestmentProperty",
secondary=association_table,
backref=db.backref("investment_lists", lazy='dynamic'))
from eBookClub import settings
app = Flask(__name__)
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['SQLALCHEMY_DATABASE_URI'] = settings.MYSQL_URI
app.config['SECRET_KEY'] = settings.SECRETKEY
db = SQLAlchemy(app)
engine = create_engine(settings.MYSQL_URI)
Session = sessionmaker(bind=engine)
Base = declarative_base()
role_users = db.Table('role_users',
db.Column('user_id', db.Integer(),
db.ForeignKey('user.id')),
db.Column('role_id', db.Integer(),
db.ForeignKey('role.id')),
extend_existing=True)
Posts = db.Table(
'Posts', db.Column('user_id', db.Integer(), db.ForeignKey('user.id')),
db.Column('book_isbn', db.String(30), db.ForeignKey('Book.ISBN')))
class Role(db.Model, RoleMixin):
__tablename__ = 'Role'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer,
db.ForeignKey('role_users.role_id'),
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# Set up Flask debug stuff
manager = Manager(app)
# moment = Moment(app) # For time # Later
db = SQLAlchemy(app) # For database use
#########
######### Everything above this line is important/useful setup, not problem-solving.
#########
##### Set up Models #####
# Set up association Table between artists and albums for many-many relationship
collections = db.Table('collections',db.Column('album_id',db.Integer, db.ForeignKey('albums.id')),db.Column('artist_id',db.Integer, db.ForeignKey('artists.id')))
class Album(db.Model):
__tablename__ = "albums"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64))
artists = db.relationship('Artist',secondary=collections,backref=db.backref('albums',lazy='dynamic'),lazy='dynamic')
songs = db.relationship('Song',backref='Album')
class Artist(db.Model):
__tablename__ = "artists"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64))
songs = db.relationship('Song',backref='Artist')
def __repr__(self):
from flask.ext.uploads import configure_uploads, patch_request_class
from flask_thumbnails_s3 import Thumbnail
from library.admin_utils import ProtectedAdminIndexView
app = Flask(__name__,
template_folder=path.abspath(
path.join(path.dirname(__file__), '../templates')),
static_folder=path.abspath(
path.join(path.dirname(__file__), '../static')))
app.config.from_object('project.settings')
db = SQLAlchemy(app)
db.Column = sqlalchemy_defaults.Column
sqlalchemy_defaults.make_lazy_configured(db.mapper)
migrate = Migrate(app, db, path.join(app.config['PROJECT_ROOT'], 'migrations'))
from accounts.models import Role, User
security = Security(app, SQLAlchemyUserDatastore(db, User, Role))
Bootstrap(app)
thumb = Thumbnail(app)
from foo.uploads import upload_sets
configure_uploads(app, upload_sets)
patch_request_class(app)
class Category(db.Model):
__tablename__ = 'categories'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(255), nullable=False)
slug = db.Column(db.String(255), nullable=False)
created_on = db.Column(db.DateTime(), default=datetime.utcnow)
created_on = db.Column(db.DateTime(), default=datetime.utcnow)
posts = db.relationship('Post', backref='category')
def __repr__(self):
return "<{}:{}>".format(id, self.name)
post_tags = db.Table(
'post_tags', db.Column('post_id', db.Integer, db.ForeignKey('posts.id')),
db.Column('tag_id', db.Integer, db.ForeignKey('tags.id')))
class Post(db.Model):
__tablename__ = 'posts'
id = db.Column(db.Integer(), primary_key=True)
title = db.Column(db.String(255), nullable=False)
slug = db.Column(db.String(255), nullable=False)
content = db.Column(db.Text(), nullable=False)
created_on = db.Column(db.DateTime(), default=datetime.utcnow)
updated_on = db.Column(db.DateTime(),
default=datetime.utcnow,
onupdate=datetime.utcnow)
def __repr__(self):
