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))