def create_app(config=None, debug=True):
app = create_base_app(config, debug)
app.config['DATABASE'] = {
'name': 'example2.db',
'engine': 'peewee.SqliteDatabase',
}
db = Database(app)
class Role(db.Model, RoleMixin):
name = TextField(unique=True)
description = TextField(null=True)
class User(db.Model, UserMixin):
email = TextField()
password = TextField()
last_login_at = DateTimeField(null=True)
current_login_at = DateTimeField(null=True)
last_login_ip = TextField(null=True)
current_login_ip = TextField(null=True)
login_count = IntegerField(null=True)
active = BooleanField(default=True)
confirmed_at = DateTimeField(null=True)
class UserRoles(db.Model):
""" Peewee does not have built-in many-to-many support, so we have to
create this mapping class to link users to roles."""
user = ForeignKeyField(User, related_name='roles')
role = ForeignKeyField(Role, related_name='users')
name = property(lambda self: self.role.name)
description = property(lambda self: self.role.description)
class Connection(db.Model):
user = ForeignKeyField(User, related_name='connections')
provider_id = TextField()
provider_user_id = TextField()
access_token = TextField()
secret = TextField(null=True)
display_name = TextField()
full_name = TextField()
profile_url = TextField()
image_url = TextField()
rank = IntegerField(null=True)
app.security = Security(app, PeeweeUserDatastore(db, User, Role, UserRoles))
app.social = Social(app, PeeweeConnectionDatastore(db, Connection))
@app.before_first_request
def before_first_request():
for Model in (Role, User, UserRoles, Connection):
Model.drop_table(fail_silently=True)
Model.create_table(fail_silently=True)
populate_data()
app.get_user = lambda: User.select().get()
return app
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(auth_config=None, debug=True):
app = create_base_app(auth_config, debug)
app.config['MONGODB_DB'] = 'flask_social_test'
app.config['MONGODB_HOST'] = 'localhost'
app.config['MONGODB_PORT'] = 27017
db = MongoEngine(app)
class Role(db.Document, RoleMixin):
name = db.StringField(required=True, unique=True, max_length=80)
description = db.StringField(max_length=255)
class User(db.Document, UserMixin):
email = db.StringField(unique=True, max_length=255)
password = db.StringField(required=True, max_length=120)
active = db.BooleanField(default=True)
remember_token = db.StringField(max_length=255)
authentication_token = db.StringField(max_length=255)
roles = db.ListField(db.ReferenceField(Role), default=[])
@property
def connections(self):
return Connection.objects(user_id=str(self.id))
class Connection(db.Document):
user_id = db.ObjectIdField()
provider_id = db.StringField(max_length=255)
provider_user_id = db.StringField(max_length=255)
access_token = db.StringField(max_length=255)
secret = db.StringField(max_length=255)
display_name = db.StringField(max_length=255)
full_name = db.StringField(max_length=255)
profile_url = db.StringField(max_length=512)
image_url = db.StringField(max_length=512)
rank = db.IntField(default=1)
@property
def user(self):
return User.objects(id=self.user_id).first()
app.security = Security(app, MongoEngineUserDatastore(db, User, Role))
app.social = Social(app, MongoEngineConnectionDatastore(db, Connection))
@app.before_first_request
def before_first_request():
for m in [User, Role, Connection]:
m.drop_collection()
populate_data()
app.get_user = lambda: User.objects().first()
return app
def create_sqlalchemy_app(config=None):
print 'create_sqlalchemy_app'
app = create_app(config)
app.config[
'SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/flask_social_example.sqlite'
db = SQLAlchemy(app)
Security(app, SQLAlchemyUserDatastore(db))
Social(app, SQLAlchemyConnectionDatastore(db))
@app.before_first_request
def before_first_request():
db.drop_all()
db.create_all()
populate_data()
return app
def create_mongoengine_app(auth_config=None):
app = create_app(auth_config)
app.config['MONGODB_DB'] = 'flask_social_example'
app.config['MONGODB_HOST'] = 'localhost'
app.config['MONGODB_PORT'] = 27017
db = MongoEngine(app)
Security(app, MongoEngineUserDatastore(db))
Social(app, MongoEngineConnectionDatastore(db))
@app.before_first_request
def before_first_request():
from flask.ext.security import User, Role
from flask.ext.social import SocialConnection
User.drop_collection()
Role.drop_collection()
SocialConnection.drop_collection()
populate_data()
return app
app.secret_key = os.environ['SECRET']
app.config['SECURITY_LOGIN_URL'] = "/none"
heroku = Heroku()
Mobility(app)
db = SQLAlchemy(app)
from app.models import User, Role, Connection, Comic, Series
# Setup Flask-Security
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security = Security(app, user_datastore)
social = Social(app, SQLAlchemyConnectionDatastore(db, Connection))
heroku.init_app(app)
from views import index, search, my_collection
@login_failed.connect_via(app)
def on_login_failed(sender, provider, oauth_response):
connection_values = get_connection_values_from_oauth_response(
provider, oauth_response)
connection_values['display_name'] = connection_values['display_name'][
'givenName'] + " " + connection_values['display_name']['familyName']
connection_values['full_name'] = connection_values['display_name']
session['google_id'] = connection_values['provider_user_id']
user = user_datastore.create_user(google_id=session['google_id'])
user_datastore.commit()
app = Flask(__name__)
app.config.from_yaml(app.root_path)
app.config.from_heroku()
app.wsgi_app = MethodRewriteMiddleware(app.wsgi_app)
db = SQLAlchemy(app)
webassets = Environment(app)
# Late import so modules can import their dependencies properly
from . import assets, models, views
security_ds = SQLAlchemyUserDatastore(db, models.User, models.Role)
social_ds = SQLAlchemyConnectionDatastore(db, models.Connection)
app.security = Security(app, security_ds)
app.social = Social(app, social_ds)
class SocialLoginError(Exception):
def __init__(self, provider):
self.provider = provider
@app.before_first_request
def before_first_request():
try:
models.db.create_all()
except Exception, e:
app.logger.error(str(e))
app.config['SECURITY_POST_LOGIN'] = '******' #REDIRECT
app.config['SOCIAL_FACEBOOK'] = {
'oauth': {
'consumer_key': '110626275752351',
'consumer_secret': 'a6d52ed9f11260e72c70b0c5432266f3',
'request_token_params': {
'scope': 'email'
}
}
}
app.config['SOCIAL_CONNECT_ALLOW_REDIRECT'] = "localhost:5000/profile"
app.config['SECRET_KEY'] = "foobarbazblah"
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///test.sqlite'
db = SQLAlchemy(app)
Security(app, SQLAlchemyUserDatastore(db))
Social(app, SQLAlchemyConnectionDatastore(db))
@app.before_first_request
def before_first_request():
db.create_all()
@app.route('/profile')
@login_required
def profile():
return render_template(
'profile.html',
content='Profile Page',
facebook_conn=current_app.social.facebook.get_connection())
from flask_application.helpers import datetimeformat
app.jinja_env.filters['datetimeformat'] = datetimeformat
# Business Logic
# http://flask.pocoo.org/docs/patterns/packages/
# http://flask.pocoo.org/docs/blueprints/
from flask_application.controllers.frontend import frontend
app.register_blueprint(frontend)
from flask.ext.security import Security, MongoEngineUserDatastore
from flask_application.models import db, User, Role, Connection
from flask_application.security_extras import ExtendedRegisterForm
# Setup Flask-Security
user_datastore = MongoEngineUserDatastore(db, User, Role)
app.security = Security(app,
user_datastore,
register_form=ExtendedRegisterForm)
# Setup Flask-Social
from flask.ext.social import Social
from flask.ext.social.datastore import MongoEngineConnectionDatastore
app.social = Social(app, MongoEngineConnectionDatastore(db, Connection))
from flask_application.controllers.admin import admin
app.register_blueprint(admin)
login_manager = LoginManager() # Create MongoDB database object. mongo = PyMongo() # Create BCrypt object bcrypt = Bcrypt() # Create flask-security object security = None # Create flask-principal object principal = Principal() # Create flask-social object social = Social() # Create mail obj mail = Mail() # Mailer mailer = Mailer(mail) uds = UserDataStore() upload_folder = join(dirname(realpath(__file__)), 'static/uploads/') allowed_extensions = set(['txt', 'pdf', 'png', 'jpg', 'jpeg', 'gif']) # Initialize mongo utils access points profile_mongo_utils = ProfileMongoUtils(mongo) user_mongo_utils = UserMongoUtils(mongo)
