def create_app(config=None, debug=True):
app = create_base_app(config, debug)
app.config[
'SQLALCHEMY_DATABASE_URI'] = 'mysql://root@localhost/flask_social_test'
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)
password = db.Column(db.String(120))
active = db.Column(db.Boolean())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
connections = db.relationship('Connection',
backref=db.backref('user',
lazy='joined'))
class Connection(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
provider_id = db.Column(db.String(255))
provider_user_id = db.Column(db.String(255))
access_token = db.Column(db.String(255))
secret = db.Column(db.String(255))
display_name = db.Column(db.String(255))
profile_url = db.Column(db.String(512))
image_url = db.Column(db.String(512))
rank = db.Column(db.Integer)
app.security = Security(app, SQLAlchemyUserDatastore(db, User, Role))
app.social = Social(app, SQLAlchemyConnectionDatastore(db, Connection))
@app.before_first_request
def before_first_request():
db.drop_all()
db.create_all()
populate_data()
pass
return app
def create_app(config, **kwargs):
app = create_base_app(config)
#app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://root@localhost/flask_security_test'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
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)
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'))
@app.before_first_request
def before_first_request():
db.drop_all()
db.create_all()
populate_data(app.config.get('USER_COUNT', None))
app.security = Security(app,
datastore=SQLAlchemyUserDatastore(db, User, Role),
**kwargs)
add_context_processors(app.security)
return app
from sqlalchemy import and_, or_
from sqlalchemy.ext.hybrid import hybrid_property
def _date_to_datetime(date):
'''Convert a date object to a datetime object
The time is set to 00:00:00
'''
midnight = datetime.time(0, 0, 0)
return datetime.datetime.combine(date, midnight)
db = SQLAlchemy(app)
roles_users = db.Table('members_roles_users',
db.Column('user_id', db.Integer(), db.ForeignKey('members.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('members_roles.id')))
class Role(db.Model, RoleMixin):
"""Define the Role database table"""
__tablename__ = 'members_roles'
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 self.name
class User(db.Model, UserMixin):
import hashlib
from sqlalchemy import event
from scan.log import logging
from datetime import datetime
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.security import UserMixin, RoleMixin
from scan import settings
log = logging.getLogger(__name__)
db = SQLAlchemy()
STRING_MAX = 255
roles_users = db.Table(
'roles_users', db.Model.metadata,
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(STRING_MAX), unique=True)
description = db.Column(db.String(STRING_MAX))
def __repr__(self):
return "<Role(name='%s')>" % (self.name)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(STRING_MAX))
def create_app(test_config=None): # For automated tests
# Setup Flask and read config from ConfigClass defined above
app = Flask(__name__)
app.config.from_object(__name__ + '.ConfigClass')
# Load local_settings.py if file exists # For automated tests
try:
app.config.from_object('local_settings')
except:
pass
# Load optional test_config # For automated tests
if test_config:
app.config.update(test_config)
# Initialize Flask extensions
db = SQLAlchemy(app) # Initialize Flask-SQLAlchemy
mail = Mail(app) # Initialize Flask-Mail
# Define the User-Roles pivot table
user_roles = db.Table(
'user_roles', db.Column('id', db.Integer(), primary_key=True),
db.Column('user_id', db.Integer(),
db.ForeignKey('user.id', ondelete='CASCADE')),
db.Column('role_id', db.Integer(),
db.ForeignKey('role.id', ondelete='CASCADE')))
# Define Role model
class Role(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50), unique=True)
# Define User model. Make sure to add flask.ext.user UserMixin!!
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
active = db.Column(db.Boolean(), nullable=False, default=False)
username = db.Column(db.String(50), nullable=True, unique=True)
email = db.Column(db.String(255), nullable=True, unique=True)
confirmed_at = db.Column(db.DateTime())
password = db.Column(db.String(255), nullable=False, default='')
reset_password_token = db.Column(db.String(100),
nullable=False,
default='')
# Relationships
roles = db.relationship('Role',
secondary=user_roles,
backref=db.backref('users', lazy='dynamic'))
# Reset all the database tables
db.create_all()
# Setup Flask-User
db_adapter = SQLAlchemyAdapter(db, User)
user_manager = UserManager(db_adapter, app)
# Create 'user007' user with 'secret' and 'agent' roles
if not User.query.filter(User.username == 'user007').first():
user1 = User(username='******',
email='*****@*****.**',
active=True,
password=user_manager.hash_password('Password1'))
user1.roles.append(Role(name='secret'))
user1.roles.append(Role(name='agent'))
db.session.add(user1)
db.session.commit()
# The '/' page is accessible to anyone
@app.route('/')
def home_page():
# if current_user.is_authenticated():
# return profile_page()
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<h2>{%trans%}Home Page{%endtrans%}</h2>
<p><a href="{{ url_for('user.login') }}">{%trans%}Sign in{%endtrans%}</a></p>
{% endblock %}
""")
# The '/profile' page requires a logged-in user
@app.route('/profile')
@login_required # Use of @login_required decorator
def profile_page():
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<h2>{%trans%}Profile Page{%endtrans%}</h2>
<p> {%trans%}Hello{%endtrans%}
{{ current_user.username or current_user.email }},</p>
<p> <a href="{{ url_for('user.change_username') }}">
{%trans%}Change username{%endtrans%}</a></p>
<p> <a href="{{ url_for('user.change_password') }}">
{%trans%}Change password{%endtrans%}</a></p>
<p> <a href="{{ url_for('user.logout') }}?next={{ url_for('user.login') }}">
{%trans%}Sign out{%endtrans%}</a></p>
{% endblock %}
""")
# The '/special' page requires a user that has the 'special' AND ('sauce' OR 'agent') role.
@app.route('/special')
@roles_required('secret',
['sauce', 'agent']) # Use of @roles_required decorator
def special_page():
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<h2>{%trans%}Special Page{%endtrans%}</h2>
{% endblock %}
""")
return app
import json
from sqlalchemy import MetaData, Table, Column, String, Integer
from flask import Flask, render_template
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.security import Security, SQLAlchemyUserDatastore, \
UserMixin, RoleMixin, login_required
DB = SQLAlchemy()
## User and roles
roles_users = DB.Table(
'roles_users',
DB.Column('users_id', DB.Integer(), DB.ForeignKey('users.id')),
DB.Column('roles_id', DB.Integer(), DB.ForeignKey('roles.id')))
class Roles(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 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(255))
active = DB.Column(DB.Boolean())
confirmed_at = DB.Column(DB.DateTime())
app.config['VENMO_CLIENT_ID'] = 1454
app.config['VENMO_SECRET'] = "CFELT3xea29gtWFk7ujfTcDh8bMTzJZ8"
COLUMN_BLACKLIST = ["password", "venmo_key"]
# Create database connection object
db = SQLAlchemy(app)
def asdict(obj):
return dict((col.name, getattr(obj, col.name))
for col in class_mapper(obj.__class__).mapped_table.c
if col.name not in COLUMN_BLACKLIST)
# 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 SpecialRegisterForm(RegisterForm):
name = TextField('Full Name')
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))
admin_role = None
friends = db.Table('friends',
db.Column('f1_id', db.Integer(), db.ForeignKey('user.id')),
db.Column('f2_id', db.Integer(), db.ForeignKey('user.id')))
import json
from datetime import datetime, time
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.security import UserMixin, RoleMixin
from sqlalchemy.orm import backref
import flux
db = SQLAlchemy()
### Add models here
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')))
class Pin(db.Model):
__table_args__ = (db.UniqueConstraint('beam_id', 'user_id', name='uix_pin'), )
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
beam_id = db.Column(db.Integer, db.ForeignKey('beam.id'), index=True)
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):
import json
from flask import current_app
from flask.ext.security import UserMixin, RoleMixin
import os
import werkzeug
from flask.ext.sqlalchemy import SQLAlchemy
from datetime import datetime
from marion_biblio.wos_reader import open_wos_tab, make_pytable
from marion_biblio.wos_reader_query import run_query
from marion_biblio import csv_queries, progressivegenerators
import csv
db = SQLAlchemy()
roles_users = db.Table(
'roles_users', db.Column('id_user', db.Integer(),
db.ForeignKey('user.id')),
db.Column('id_role', db.Integer(), db.ForeignKey('role.id')))
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(64), unique=True)
description = db.Column(db.String(255))
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
nickname = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(128), index=True, unique=True)
password = db.Column(db.String(255))
class Roles(object):
USER = {'name': 'USER', 'description': u'normal user'}
ADMIN = {'name': 'ADMIN', 'description': u'admin user'}
SUPER_ADMIN = {
'name': 'SUPER_ADMIN',
'description': u'super user that can do anything'
}
user_role = db.Table(
'user_role',
db.Column('user_id', db.Integer(),
db.ForeignKey('user.id', ondelete="CASCADE")),
db.Column('role_id', db.Integer(),
db.ForeignKey('role.id', ondelete="CASCADE")))
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(NORMAL_STRING_LENGTH), unique=True)
description = db.Column(db.Unicode(NORMAL_STRING_LENGTH))
class User(db.Model):
id = db.Column(db.Integer(), primary_key=True)
password = db.Column(db.String(NORMAL_STRING_LENGTH))
name = db.Column(db.Unicode(NORMAL_STRING_LENGTH))
@app.before_first_request
def add_ga_tracking_code():
g.ga_tracking_code = os.environ['GA_TRACKING_CODE']
@manager.command
def run():
app.run(debug=True)
youtube_api_key = os.environ['ytokkey']
subscription = db.Table(
'subscription',
db.Column('stream_id', db.Integer(), db.ForeignKey('stream.id')),
db.Column('subscriber_id', db.Integer(), db.ForeignKey('subscriber.id')))
class Stream(db.Model):
id = db.Column(db.Integer, primary_key=True)
type = db.Column(db.String(50))
scheduled_start_time = db.Column(db.DateTime())
status = db.Column(
db.Enum('upcoming', 'live', 'completed', name='stream_status'))
title = db.Column(db.String(100))
subscribers = db.relationship('Subscriber',
secondary=subscription,
backref=db.backref('streams',
lazy='dynamic'))
# reddit_thread = db.Column(db.String(255))
from flask import Flask, render_template
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.security import Security, SQLAlchemyUserDatastore, UserMixin, RoleMixin, login_required
app = Flask(__name__)
app.config["DEBUG"] = True
app.config["SECRET_KEY"] = "super-secret"
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite://"
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)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship("Role",
secondary=roles_users,
picture_data = Column(LargeBinary)
thumbnail = Column(LargeBinary)
user = Column(String(50), nullable=False, default='')
dataset_id = Column(
'ext_dataset_id',
ForeignKey('datasets.id'),
primary_key=True,
)
roles_users = db.Table(
'roles_users',
db.Column('registered_users_user', db.String(50),
db.ForeignKey('registered_users.user')),
db.Column('role_id', db.Integer(), db.ForeignKey('roles.id')),
)
class RegisteredUser(Base, UserMixin):
__tablename__ = 'registered_users'
id = Column('user', String(50), primary_key=True)
name = Column(String(255))
institution = Column(String(45))
abbrev = Column(String(10))
MS = Column(String(255))
email = Column(String(255))
qualification = Column(String(255))
account_date = Column(String(16), nullable=False)
show_assessment = Column(Integer, nullable=False, default=1)
)
celery = make_celery(app)
Bootstrap(app)
Bower(app)
mail = Mail(app)
# Create database connection object
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")),
)
courses_users = db.Table(
"courses_users",
db.Column("user_id", db.Integer(), db.ForeignKey("user.id")),
db.Column("course_id", db.Integer(), db.ForeignKey("course.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))
USER_ENABLE_CONFIRM_EMAIL = False
))
babel = Babel(app)
mail = Mail(app)
db = SQLAlchemy(app)
@babel.localeselector
def get_locale():
translations = [str(translation) for translation in babel.list_translations()]
return request.accept_languages.best_match(translations)
# Define the User-Roles pivot table
user_roles = db.Table('user_roles',
db.Column('id', db.Integer(), primary_key=True),
db.Column('user_id', db.Integer(), db.ForeignKey('user.id', ondelete='CASCADE')),
db.Column('role_id', db.Integer(), db.ForeignKey('role.id', ondelete='CASCADE')))
class TutorialPage(db.Model):
id = db.Column(db.Integer(), primary_key=True)
cat_id = db.Column(db.Integer(), nullable=False)
cat_title = db.Column(db.String(), nullable=False)
title = db.Column(db.String(), nullable=False)
text = db.Column(db.String(), nullable=False)
class Role(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50), unique=True)
class User(db.Model, UserMixin):
from sqlalchemy.orm import sessionmaker, relationship, backref
db_url = '{dialect}://{user}:{passwd}@{host}:{port}/{dbname}'.format(
dialect=config.get('lawdb', 'dialect'),
user=config.get('lawdb', 'username'),
passwd=config.get('lawdb', 'password'),
host=config.get('lawdb', 'host'),
port=config.get('lawdb', 'port'),
dbname=config.get('lawdb', 'dbname'),
)
# We'll bind the app later
db = SQLAlchemy()
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())
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.security import UserMixin, RoleMixin
from sqlalchemy.dialects.postgresql import JSONB
from sqlalchemy import distinct
db = SQLAlchemy()
### Add models here
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')))
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 to_dict(self):
return {
'id': self.id,
'type': 'user',
'attributes': {
'name': self.name,
'description': self.description
}
}
# coding: utf-8
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.security import RoleMixin, UserMixin
db = SQLAlchemy()
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(100), unique=True)
description = db.Column(db.String(255))
def __init__(self, name):
self.name = name
def __repr__(self):
return u"Role(name='{0}')".format(self.name)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
