def create_relation_table(db: SQLAlchemy,
table_args: RelateTableArgs) -> Table:
return db.Table(
table_args.tablename,
db.Column(table_args.related_key, db.Integer(), nullable=False),
db.Column(table_args.the_ohter_related_key,
db.Integer(),
nullable=False),
UniqueConstraint(table_args.related_key,
table_args.the_ohter_related_key),
)
def sqlalchemy_setup(request, app, tmpdir, realdburl):
from flask_sqlalchemy import SQLAlchemy
if realdburl:
db_url, db_info = _setup_realdb(realdburl)
app.config["SQLALCHEMY_DATABASE_URI"] = db_url
else:
f, path = tempfile.mkstemp(prefix="flask-security-test-db",
suffix=".db",
dir=str(tmpdir))
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///" + path
db = SQLAlchemy(app)
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)
security_number = db.Column(db.Integer, unique=True)
username = db.Column(db.String(255))
password = db.Column(db.String(255))
last_login_at = db.Column(db.DateTime())
tf_primary_method = db.Column(db.String(255), nullable=True)
tf_totp_secret = db.Column(db.String(255), nullable=True)
tf_phone_number = db.Column(db.String(255), nullable=True)
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(100))
current_login_ip = db.Column(db.String(100))
login_count = db.Column(db.Integer)
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship("Role",
secondary=roles_users,
backref=db.backref("users", lazy="dynamic"))
with app.app_context():
db.create_all()
def tear_down():
if realdburl:
db.drop_all()
_teardown_realdb(db_info)
else:
os.close(f)
os.remove(path)
request.addfinalizer(tear_down)
return SQLAlchemyUserDatastore(db, User, Role)
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
db.init_app(app)
from main import main as main_blueprint
app.register_blueprint(main_blueprint)
# ############################## flask-security ##########################
# create database connection
db1 = SQLAlchemy(app)
# define models
roles_users = db1.Table('roles_users',
db1.Column('user_id', db1.Integer(), db1.ForeignKey('user.id')),
db1.Column('role_id', db1.Integer(), db1.ForeignKey('role.id')))
class Role(db1.Model, RoleMixin):
id = db1.Column(db1.Integer, primary_key=True)
name = db1.Column(db1.String(80), unique=True)
description = db1.Column(db1.String(225))
class User(db1.Model, UserMixin):
id = db1.Column(db.Integer, primary_key=True)
email = db1.Column(db1.String(255), unique=True)
password = db1.Column(db1.String(255))
active = db1.Column(db1.Boolean())
confirmed_at = db1.Column(db1.DateTime())
roles = db1.relationship('Role', secondary=roles_users,
backref=db1.backref('users', lazy='dynamic'))
# Setup Flask-Security
user_datastore = SQLAlchemyUserDatastore(db1, User, Role)
security = Security(app, user_datastore)
# Create a user to test with
# @app.before_first_request
# def create_user():
# file = pd.read_csv('logins.csv')
# for i,r in file.iterrows():
# print r.email
# db1.create_all()
# user_datastore.create_user(email=r.email, password=r.extension)
# db1.session.commit()
# ############################## end flask-security #######################
return app
def sqlalchemy_datastore(request, app, tmpdir):
from flask_sqlalchemy import SQLAlchemy
f, path = tempfile.mkstemp(prefix='flask-security-test-db',
suffix='.db',
dir=str(tmpdir))
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + path
db = SQLAlchemy(app)
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)
username = db.Column(db.String(255))
password = db.Column(db.String(255))
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(100))
current_login_ip = db.Column(db.String(100))
login_count = db.Column(db.Integer)
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
with app.app_context():
db.create_all()
def tear_down():
os.close(f)
os.remove(path)
request.addfinalizer(tear_down)
return SQLAlchemyUserDatastore(db, User, Role)
class Base(db.Model):
"""Base class for all the tables.
Consists of two default columns `created_at` and `modified_at` .
"""
__abstract__ = True
id = db.Column(db.Integer, primary_key=True)
created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
modified_at = db.Column(db.DateTime,
default=db.func.current_timestamp(),
onupdate=db.func.current_timestamp())
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 Coin(db.Model):
__tablename__ = 'coin'
id = db.Column(db.Integer, primary_key=True)
id_name = db.Column(db.String(200))
name = db.Column(db.String(200))
symbol = db.Column(db.String(10))
rank = db.Column(db.Integer)
price_usd = db.Column(db.Float) # zavislost na te tabulce
total_supply = db.Column(db.Integer)
from mysession.flask_session import Session
from mysecurity.flask_security import login_required
from mysecurity.flask_security import Security, SQLAlchemyUserDatastore, \
UserMixin, RoleMixin, login_required, current_user
from mysecurity.flask_security.utils import encrypt_password
from flask_mail import Mail
db = SQLAlchemy()
CONF_FILE = os.path.join(os.path.dirname(os.path.realpath(__file__)),
"loginconf.py")
# Define models
roles_users = db.Table(
't_admin_roles_users',
db.Column('user_id', db.Integer(), db.ForeignKey('t_admin_user.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('t_admin_role.id')))
class Role(db.Model, RoleMixin):
__tablename__ = "t_admin_role"
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
def __str__(self):
return self.name
class User(db.Model, UserMixin):
__tablename__ = "t_admin_user"
class Config(db.Model):
__tablename__ = "config"
id = db.Column(db.Integer, primary_key=True)
app_name = db.Column(db.String(255), default=None)
app_description = db.Column(db.Text)
user_quota = db.Column(db.BigInteger,
default=Reel2bitsDefaults.user_quotas_default)
announcement = db.Column(db.Text, nullable=True)
# #### User ####
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,
nullable=False,
info={"label": "Name"})
description = db.Column(db.String(255), info={"label": "Description"})
__mapper_args__ = {"order_by": name}
# flask-mail
from flask_mail import Mail
mail = Mail()
# database setup
from flask_sqlalchemy import SQLAlchemy
db = SQLAlchemy()
##################
# database models
##################
from sqlalchemy.sql import func
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)
date_created = db.Column(db.DateTime, server_default=func.now())
date_modified = db.Column(db.DateTime, onupdate=func.now())
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)
date_created = db.Column(db.DateTime, server_default=func.now())
id = db.Column(db.Integer, primary_key=True)
test_id = db.Column(db.ForeignKey('test.id', ondelete='CASCADE'),
nullable=True,
index=True)
session_id = db.Column(db.ForeignKey('session.id', ondelete='CASCADE'),
nullable=True,
index=True)
message = db.Column(db.Text, nullable=False)
filename = db.Column(db.String(2048), nullable=True)
lineno = db.Column(db.Integer, nullable=True)
timestamp = db.Column(db.Float, nullable=False)
roles_users = db.Table(
'roles_users',
db.Column('user_id', db.Integer(),
db.ForeignKey('user.id', ondelete='CASCADE')),
db.Column('role_id', db.Integer(),
db.ForeignKey('role.id', ondelete='CASCADE')),
db.Index('ix_roles_users_user_id', 'user_id'),
UniqueConstraint('user_id', '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, TypenameMixin):
# Configure application to route to the Flask-Admin index view upon logout
secureApp.config['SECURITY_POST_LOGOUT_VIEW'] = '/admin/'
# Configure application to route to the Flask-Admin index view upon registering
secureApp.config['SECURITY_POST_REGISTER_VIEW'] = '/admin/'
secureApp.config['SECURITY_REGISTERABLE'] = True
# Configure application to not send an email upon registration
secureApp.config['SECURITY_SEND_REGISTER_EMAIL'] = False
secureApp.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
secureApp.config['SQLALCHEMY_DATABASE_URI'] = 'postgres://localhost/flask-admin-flask-security-db'
# Instantiate the database
db = SQLAlchemy(secureApp)
# Create a table of users and user roles
roles_users_table = db.Table('roles_users',
db.Column('users_id', db.Integer(), db.ForeignKey('users.id')),
db.Column('roles_id', db.Integer(), db.ForeignKey('roles.id')))
# Define models for the users and user roles
class Roles(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
class Users(db.Model, UserMixin):
id = db.Column(db.Integer(), primary_key=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(80))
active = db.Column(db.Boolean())
roles = db.relationship('Roles', secondary=roles_users_table, backref='user', lazy=True)
# also from mysecrets.py
# (username and sender will probably be the same unless we're forwarding)
app.config['MAIL_USERNAME'] = mysecrets.mail_username
app.config['MAIL_PASSWORD'] = mysecrets.mail_password
app.config['MAIL_DEFAULT_SENDER'] = mysecrets.mail_sender
app.config['SECURITY_EMAIL_SENDER'] = mysecrets.mail_sender
mail = Mail(app)
logging.debug('configured mail')
############################################################
# COPIED FROM FLASK-SECURITY QUICKSTART GUIDE
# define models
col_user_id = db.Column('user_id', db.Integer(), db.ForeignKey('user.id'))
col_role_id = db.Column('role_id', db.Integer(), db.ForeignKey('role.id'))
roles_users = db.Table('roles_users', col_user_id, col_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())
from sqlalchemy.exc import OperationalError
from wtforms import IntegerField
from wtforms.validators import NoneOf
from wtforms.validators import Regexp
from opwen_email_client.util.wtforms import SuffixedStringField
from opwen_email_client.webapp import app
from opwen_email_client.webapp.config import AppConfig
from opwen_email_client.webapp.config import i8n
_db = SQLAlchemy(app)
# noinspection PyUnresolvedReferences
_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')),
)
# noinspection PyUnresolvedReferences
class User(_db.Model, UserMixin):
id = _db.Column(_db.Integer(), primary_key=True)
email = _db.Column(_db.String(255), unique=True, index=True)
password = _db.Column(_db.String(255), nullable=False)
active = _db.Column(_db.Boolean(), default=True)
last_login_at = _db.Column(_db.DateTime())
current_login_at = _db.Column(_db.DateTime())
last_login_ip = _db.Column(_db.String(128))
current_login_ip = _db.Column(_db.String(128))
login_count = _db.Column(_db.Integer())
from flask_sqlalchemy import SQLAlchemy
from flask_security import UserMixin, RoleMixin, SQLAlchemyUserDatastore
db = SQLAlchemy()
audience_respondent = db.Table(
'audience_respondent',
db.Column('id_audience', db.Integer(), db.ForeignKey('audience.id')),
db.Column('id_respondent', db.Integer(), db.ForeignKey('respondent.id')))
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 Respondent(db.Model):
"""
ORM Model for the decision makers data.
"""
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(128))
phone = db.Column(db.String(32))
email = db.Column(db.String(64))
url = db.Column(db.String(256))
nation = db.Column(db.String(128))
group = db.Column(db.String(128))
party = db.Column(db.String(128))
license = db.Column(db.String(128))
image = db.Column(db.String(64))
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///manytomany.sqlite3'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)
stud_adr_mapping = db.Table(
'stud_adr_mapping', db.Column('mp_id', db.Integer(), primary_key=True),
db.Column('st_id', db.ForeignKey("student.stud_id"), unique=False),
db.Column('ad_id', db.ForeignKey("address.adr_id"), unique=False))
class Student(db.Model
): #class level fields - init --> makes instance level fields
id = db.Column('stud_id', db.Integer(), primary_key=True)
fname = db.Column('stud_fname', db.String(100))
lname = db.Column('stud_lname', db.String(100))
fees = db.Column('stud_fees', db.Float())
class Address(db.Model):
id = db.Column('adr_id', db.Integer, primary_key=True)
city = db.Column('adr_city', db.String(50))
state = db.Column('adr_state', db.String(200))
pin = db.Column('adr_pin', db.Integer())
studrefs = db.relationship(Student,
secondary=stud_adr_mapping,
backref=db.backref('adrrefs', lazy=True))
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_security import UserMixin
import time
# db
app = Flask(__name__, instance_relative_config=True)
app.config.from_object('config')
app.config.from_pyfile('localConfig.py')
db = SQLAlchemy(app)
role_teacher = db.Table(
'role_teacher',
db.Column('teacher_id', db.Integer(), db.ForeignKey('teachers.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('role.id')))
class Students(db.Model):
id = db.Column(db.Integer, primary_key=True)
chinese_name = db.Column(db.String(80))
alias_name = db.Column(db.String(80))
gender = db.Column(db.Integer)
birthday = db.Column(db.String(120))
grade = db.Column(db.String(120))
school = db.Column(db.String(120))
adress = db.Column(db.String(120))
photo = db.Column(db.String(120))
former_courses = db.Column(db.String(120))
create_time = db.Column(db.String(120))
from datetime import datetime
import string
import random
from flask_sqlalchemy import SQLAlchemy
import common.constants as constants
db = SQLAlchemy()
# Association of users to permissions
permissions = db.Table('permissions',
db.Column('permission_id', db.Integer(), db.ForeignKey('user_permission.id')),
db.Column('user_id', db.BigInteger(), db.ForeignKey('user.id')))
class User(db.Model):
"""A user representation in the database, linked to a Steam ID.
Attributes:
id: Unique Steam Id (as 64 bits).
nickname: Unique nickname of the user, None when not setup.
avatar: URL of the user avatar in steam, updated at each login (small).
avatar_medium: URL of the user avatar in steam, updated at each login (medium).
avatar_full: URL of the user avatar in steam, updated at each login (full).
verified: Boolean True if the user is known in the community with this username.
ban_date: Date the user is ban to.
current_match: match_id of the match the user is currently in.
solo_mmr: player solo mmr updated after a scan.
return data, errors
def delete(self, item):
"""
DELETE method to drop product
"""
db.session.delete(item)
db.session.commit()
# https://pythonhosted.org/Flask-Security/quickstart.html
# Association Table for Roles and Users
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):
__tablename__ = 'role'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
'url': self.url,
'path': self.detail_url,
'mediatype': "application/vnd.datapackage+json",
'format': helper.media_name('datapackage.json'),
}
if self.category:
d['category'] = self.category
if self.organisation:
d['organisation'] = self.organisation.name
return d
# Many-to-many relationship
projects_users = db.Table(
'projects_users',
db.Column('user_id', db.Integer(), db.ForeignKey('user.id')),
db.Column('project_id', db.Integer(), db.ForeignKey('project.id')))
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.Unicode(16), nullable=False)
fullname = db.Column(db.Unicode(128))
email = db.Column(db.Unicode(128))
phone = db.Column(db.Unicode(32))
notes = db.Column(db.UnicodeText)
biography = db.Column(db.UnicodeText)
organisation_id = db.Column(db.Integer, db.ForeignKey(Organisation.id))
organisation = db.relationship(Organisation,
backref=db.backref('user',
single_parent=True))
from flask_sqlalchemy import SQLAlchemy
from app import app
from flask_security import RoleMixin, UserMixin
db = SQLAlchemy(app)
user_have_roles = db.Table(
'user_have_role',
db.Column("user_id", db.Integer(), db.ForeignKey('orm_user.id')),
db.Column("role_id", db.Integer(), db.ForeignKey('orm_role.id')))
Orm_Friend = db.Table(
'orm_friend',
db.Column('id_o',
db.Integer(),
db.ForeignKey('orm_user.id'),
primary_key=True),
db.Column('id_f',
db.Integer(),
db.ForeignKey('orm_user.id'),
primary_key=True))
# class OrmParticipant(db.Model):
# __tablename__ = 'orm_participant'
# person_id = db.Column(db.Integer(), db.ForeignKey('orm_user.id'), primary_key=True)
# event_id = db.Column(db.Integer(), db.ForeignKey('orm_event.id'), primary_key=True)
OrmParticipant = db.Table(
'orm_participant',
db.Column('person_id',
db.Integer(),
profile_db = {
"success": True,
"data": {
"last_updated": "2/3/2021, 8:48:51 PM",
"username": "******",
"role": "Electronics Engineer",
"color": "Burgundy"
class Tank(db.model):
__tablename__ = "tanks"
id = db.Column(db.Integer, primary_key = True)
location = db.Column(db.String(), nullable=False)
lat = db.Column(db.Float(), nullable=False)
long = db.Column(db.Float(), nullable=False)
percent_full = db.Column(db.Integer(), nullable=False)
class TankSchema(ma.SQLAlchemySchema):
class Meta:
model = Tank
fields = ("id", "location", "lat", "long", "percent_full")
db.init_app(app)
migrate = Migrate(app, db)
@app.route("/data", methods=["GET", "POST"])
def data():
if request.method == "POST":
newTank = Tank(
location = request.json["location"],
lat = request.json["lat"],
app.config['DEBUG'] = True
app.config['SECRET_KEY'] = 'Wheresoever you go, go with all your heart.'
app.config['SECURITY_REGISTERABLE'] = True
app.config['SECURITY_PASSWORD_SALT'] = 'Pain breeds weakness.'
app.config['SECURITY_USER_IDENTITY_ATTRIBUTES'] = 'username'
app.config['SECURITY_SEND_REGISTER_EMAIL'] = False
app.config['SECURITY_REGISTER_USER_TEMPLATE'] = 'security/register_user.html'
app.config['SECURITY_LOGIN_USER_TEMPLATE'] = 'security/login_user.html'
# For more useful resources: https://flask-security-too.readthedocs.io/_/downloads/en/stable/pdf/
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')))
groups_users = db.Table(
'groups_users', db.Column('user_id', db.Integer(),
db.ForeignKey('user.id')),
db.Column('group_id', db.Integer(), db.ForeignKey('group.id')))
events_to_posts = db.Table(
'events_to_posts',
db.Column('event_id', db.Integer(), db.ForeignKey('event.id')),
db.Column('post_id', db.Integer(), db.ForeignKey('post.id')))
class Role(db.Model, RoleMixin):
app = Flask(__name__)
app.config['DEBUG'] = True
b = Borg()
app.config['SECRET_KEY'] = b.secretKey
app.config['SECURITY_PASSWORD_SALT'] = 'None'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config[
'SQLALCHEMY_DATABASE_URI'] = 'mysql://*****:*****@' + b.dbHost + '/cairis_user'
app.app_context().push()
db = SQLAlchemy(app)
cors = CORS(app)
roles_users = db.Table(
'roles_users',
db.Column('user_id', db.Integer(), db.ForeignKey('auth_user.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('auth_role.id')))
class Role(db.Model, RoleMixin):
__tablename__ = 'auth_role'
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):
__tablename__ = 'auth_user'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
account = db.Column(db.String(32), unique=True)
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'] = os.urandom(300)
APP.config['SECURITY_REGISTERABLE'] = True
APP.config['SECURITY_PASSWORD_SALT'] = 'ThisShouldBeAProperRandomString'
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)
app = Flask(__name__)
app.config.from_object(DevConfig)
db = SQLAlchemy(app)
if __name__ == '__main__':
app.run()
class CommentForm(Form):
name = StringField(
'Name',
validators=[DataRequired(), Length(max=255)]
)
text = TextAreaField(u'Comment', validators=[DataRequired()])
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 User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer(), primary_key=True)
#username = db.Column('user_name', db.String(255))
username = db.Column(db.String(255))
password = db.Column(db.String(255))
posts = db.relationship(
'Post',
backref='user',
lazy='dynamic'
)
#create file directory
file_path = op.join(op.dirname(__file__), 'files')
try:
os.mkdir(file_path)
except OSError:
pass
# Create Flask application
app = Flask(__name__)
app.config.from_pyfile('config.py')
db = SQLAlchemy(app)
# 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')))
categories_files = db.Table(
'categories_files',
db.Column('file_id', db.Integer(), db.ForeignKey('file.id')),
db.Column('category_id', db.Integer(), db.ForeignKey('category.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))
import os
database = SQLAlchemy(current_app)
login = LoginManager(current_app)
login.login_view = '/login'
login.session_protection = None
login.refresh_view = '/login'
login.needs_refresh_message = (u"Session timedout, please re-login")
login.needs_refresh_message_category = "info"
@login.user_loader
def get_id(userid):
return Customer.query.get(int(userid))
passbook_user = database.Table('passbook_user',database.Column('passbookid',database.Integer,database.ForeignKey('passbook.passbookid'),primary_key=True),database.Column('userid',database.Integer(),database.ForeignKey('users.userid'),primary_key=True))
class passbook_users(database.Model):
__tablename__ = 'passbook_user'
__table_args__ = {'extend_existing': True}
passbookid = database.Column(database.Integer,database.ForeignKey('passbook.passbookid'),primary_key=True)
userid = database.Column(database.Integer,database.ForeignKey('users.userid'),primary_key=True)
def __init__(self,passbookid,userid):
self.passbookid = passbookid
self.userid = userid
def __repr__(self):
return "<passbook_user %r>" % self.passbookid
class Customer(database.Model, UserMixin):
from flask_admin.contrib.sqla import ModelView
from flask_security import Security, SQLAlchemyUserDatastore, \
UserMixin, RoleMixin, login_required, current_user
app = Flask(__name__)
app.config[
'SQLALCHEMY_DATABASE_URI'] = 'postgres://*****:*****@ec2-54-247-177-33.eu-west-1.compute.amazonaws.com:5432/debauug427oq59'
app.config['SECRET_KEY'] = "JE_MOEDER"
app.config['SECURITY_PASSWORD_SALT'] = "jemoeder"
app.config['SECURITY_REGISTERABLE'] = True
db = SQLAlchemy(app)
admin = Admin(app, name="Zoengraaf", template_mode="bootstrap3")
roles_users = db.Table(
'roles_users',
db.Column('visitor_id', db.Integer(), db.ForeignKey('visitor.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 Interaction(db.Model):
__tablename__ = "interactions"
id = db.Column(db.Integer, primary_key=True)
interaction_type = db.Column(db.String(100))
party1id = db.Column(db.Integer, db.ForeignKey("users.id"))
party2id = db.Column(db.Integer, db.ForeignKey("users.id"))
def create_app(database):
''' create_app
Following the factory pattern, this function creates an Flask
web application that allows a user to both register and login
to a calculator page where by inputing the height (m) and
weight (Kg), the BMI factor and category are generated.
Args:
database -- database definition to be used
Returns:
app (object)-- flask web application instance
Setup web interface with Bootstrap framework
'''
app = Flask(__name__)
# Configuration
app.config['DEBUG'] = True
app.config['SECRET_KEY'] = \
'*id4)fbbiyd*57oa18da3^t0$)m%ti#9ua+t^ihd4z9t*x%&sx'
app.config['SQLALCHEMY_DATABASE_URI'] = database
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['SECURITY_PASSWORD_SALT'] = os.urandom(32)
app.config['SECURITY_REGISTERABLE'] = True
app.config['SECURITY_LOGIN_WITHOUT_CONFIRMATION'] = True
app.config['SECURITY_SEND_REGISTER_EMAIL'] = False
app.config['SECURITY_POST_LOGIN_VIEW'] = '/bmi'
app.config['SECURITY_POST_LOGOUT_VIEW'] = '/'
app.config['SECURITY_POST_REGISTER_VIEW'] = '/bmi'
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False
# Create database connection object
db = SQLAlchemy(app)
# Define models
''' Roles-Users Table
Flask-Security model, contains the many-to-many relationship between
the User and Role tables.
'''
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):
''' Role Table
Flask-Security model, contains the allowed user roles and their
description.
'''
__tablename__ = 'role'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
def __repr__(self):
return '<Role> {}'.format(self.name)
class User(db.Model, UserMixin):
''' User Table
Flask-Security model, contains the user details to allow
registration and login, as well as authorization.
It works in conjunction with the Roles table though the
many-to-may roles_users table.
'''
__tablename__ = 'user'
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())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
def __repr__(self):
return '<User> {} {}'.format(self.id, self.email)
# Setup Flask-Security
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security = Security(app, user_datastore)
@app.before_first_request
def before_first_request():
''''Create any database tables that don't exist yet '''
db.create_all()
# Initialize bootstrap
Bootstrap(app)
# Debug = True to enable the toolbar
toolbar = DebugToolbarExtension(app)
# Views
@app.route('/', methods=['GET'])
def index():
''' Application entry '''
return render_template('index.html')
@app.route('/bmi', methods=['GET', 'POST'])
@login_required
def bmi():
''' BMI Calculator '''
return render_template('bmi.html')
return app, db
Bootstrap(app)
babel = Babel(app)
@babel.localeselector
def get_locale():
if request.args.get('lang'):
session['lang'] = request.args.get('lang')
return session.get('lang', app.config.get('LANGUAGE'))
# 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))
def __str__(self):
return self.name
def __hash__(self):
return hash(self.name)
db = SQLAlchemy()
class BaseModel(db.Model):
__abstract__ = True
id = db.Column(db.Integer, primary_key=True)
date_created = db.Column(db.DATETIME, default=func.current_timestamp())
date_modified = db.Column(db.DATETIME,
default=func.current_timestamp(),
onupdate=func.current_timestamp())
roles_users = db.Table(
'roles_users',
db.Column('final_user_id', db.Integer(), db.ForeignKey('final_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 FinalUser(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
social_id = db.Column(db.String(64), nullable=True, unique=True)
email = db.Column(db.String(255), unique=True)
username = db.Column(db.String(80), unique=True)
password = db.Column(db.String(255))
