def create_access_rights(config):
"""Create access rights"""
with open('rights.yaml', 'r') as stream:
roles_rights = yaml.load(stream)
if not os.path.isfile(config.DB_FILE):
print('[WARNING] File [{}] doesn\'t exist.'.format(config.DB_FILE))
sys.exit(1)
app = create_app(config_object=config)
with app.app_context():
DB.init_app(app)
for group in roles_rights['rights']:
for rule in roles_rights['rights'][group]:
rights = Rights(name=get_rights_name(group,
rule['permission']),
group=group,
permission=rule['permission'],
description=rule['description'])
DB.session.add(rights)
DB.session.commit()
print('[SUCCESS] Rights imported to [{}] file'.format(config.DB_FILE))
sys.exit(0)
def flask_app():
""" Create base flask application for testing. """
app = create_app('testing')
app.app_context().push()
DB.drop_all(app=app)
DB.create_all(app=app)
return app
def rights_check(config, rights_file):
"""Check of rights version"""
if not os.path.isfile(rights_file):
print('[Warning] File [{}] doesn\'t exist.'.format(rights_file))
sys.exit(1)
with open(rights_file, 'r') as stream:
roles_rights = yaml.load(stream)
app = create_app(config_object=config)
with app.app_context():
DB.init_app(app)
internal = Internal.query.order_by(
Internal.rights_version.desc()).first()
if internal.rights_version != roles_rights['version']:
print(
'[WARNING] Rights version [{}] in file [{}] differs from proper [{}].'
.format(roles_rights['version'], rights_file,
internal.rights_version))
sys.exit(0)
print('[SUCCESS] Rights in [{}] file is in correct version [{}].'.format(
rights_file, internal.rights_version))
class Internal(DB.Model):
"""Scheme versions"""
uid = DB.Column(UUID, primary_key=True, default=uuid.uuid4)
db_version = DB.Column(DB.Integer, nullable=False)
rights_version = DB.Column(DB.Integer, nullable=False)
updated_at = DB.Column(DB.DateTime())
def db_add_user(config, user_email):
"""Adding user"""
if not os.path.isfile(config.DB_FILE):
print('[WARNING] File [{}] doesn\'t exist.'.format(config.DB_FILE))
sys.exit(1)
app = create_app(config_object=config)
with app.app_context():
DB.init_app(app)
user = User.query.filter_by(email=user_email).first()
if user:
print('[WARNING] User [{}] is already added. '.format(user_email))
sys.exit(0)
admin = User(email=user_email,
password=BCRYPT.generate_password_hash(uuid.uuid4().hex),
gdpr_version=config.GDPR_VERSION,
is_active=True)
DB.session.add(admin)
DB.session.commit()
print(
'[SUCCESS] Admin user was set. For activation, you should reset password.'
)
sys.exit(0)
class User(DB.Model):
"""User data model"""
__tablename__ = 'users'
id = DB.Column(DB.Integer, primary_key=True) # pylint: disable=invalid-name
steam_id = DB.Column(DB.String(50), nullable=False, unique=True)
created_at = DB.Column(DB.DateTime())
class User(DB.Model):
"""User data model"""
uid = DB.Column(UUID, primary_key=True, default=uuid.uuid4)
email = DB.Column(DB.String(255), nullable=False, unique=True)
password = DB.Column(DB.String(255), nullable=False, server_default='')
confirmed_at = DB.Column(DB.DateTime())
gdpr_version = DB.Column(DB.Integer, nullable=False)
is_active = DB.Column(DB.Boolean(), nullable=False, server_default='0')
def configure_extensions(app):
"""
This function configures all extensions used in app.
"""
DB.init_app(app)
with app.app_context():
DB.create_all()
DB.session.commit()
class Rights(DB.Model):
"""Access rights"""
uid = DB.Column(UUID, primary_key=True, default=uuid.uuid4)
name = DB.Column(DB.String(50), nullable=False, unique=True)
group = DB.Column(DB.String(50), nullable=False)
permission = DB.Column(DB.String(50), nullable=False)
description = DB.Column(DB.String(255), nullable=False)
def import_rights(config, rights_file):
"""Import rights to database
:param config: Configuration object
:param rights_file: File with rights and roles definitions
:return:
"""
with open(rights_file, 'r') as stream:
roles_rights = yaml.load(stream)
if not os.path.isfile(config.DB_FILE):
print('[WARNING] File [{}] doesn\'t exist.'.format(config.DB_FILE))
sys.exit(1)
app = create_app(config_object=config)
with app.app_context():
DB.init_app(app)
rr_scheme = {'rights': [], 'roles': [], 'role_rights': []}
for role in roles_rights['roles']:
rr_scheme['roles'].append(Role(name=get_role_name(role)))
for group in roles_rights['rights']:
for rule in roles_rights['rights'][group]:
rr_scheme['rights'].append(
Rights(name=get_rights_name(group, rule['permission']),
group=group,
permission=rule['permission'],
description=rule['description']))
for role in rule['roles']:
rr_scheme['role_rights'].append(
RoleRights(role=get_role_name(role),
rights=get_rights_name(
group, rule['permission'])))
for rights in rr_scheme['rights']:
DB.session.add(rights)
for roles in rr_scheme['roles']:
DB.session.add(roles)
for role_rights in rr_scheme['role_rights']:
DB.session.add(role_rights)
DB.session.commit()
print('[SUCCESS] Rights imported to [{}] file'.format(config.DB_FILE))
class Rights(DB.Model):
"""Access rights"""
name = DB.Column(DB.String(50), primary_key=True)
group = DB.Column(DB.String(50), nullable=False)
permission = DB.Column(DB.String(50), nullable=False)
description = DB.Column(DB.String(255), nullable=False)
class BaseModel:
""" This class is BaseModel and used by all model object in our app"""
id = sa.Column(sa.Integer, primary_key=True)
create_at = sa.Column(sa.DateTime, server_default=sql.func.now())
update_at = sa.Column(sa.DateTime, onupdate=sql.func.now())
deleted = sa.Column(sa.Boolean, default=False)
delete_at = sa.Column(sa.DateTime)
def __init__(self, *args, **kwargs):
super(BaseModel, self).__init__(*args, **kwargs)
for data in args:
for key in data:
if isinstance(data[key], dict):
setattr(self, key, data[key])
def from_request(self, *args):
"""Parsing data from request json
"""
for data in args:
for key in data:
if isinstance(data[key], dict):
setattr(self, key, data[key])
def save(self):
"""Method to save object to database"""
sa.session.add(self)
sa.session.commit()
def delete(self):
"""Method to delete object
In this method just add flag deleted to data.
Not remove data from database
"""
self.deleted = True
self.delete_at = datetime.now()
self.save()
def restore(self):
"""Method to restore object
In this method just set flag deleted to false to restore object.
"""
self.deleted = False
self.delete_at = None
self.save()
def remove(self):
"""Method to remove object permanently from database"""
sa.session.delete(self)
sa.session.commit()
def flask_app_user_in_db():
""" Create flask application for testing with a user in the DB. """
app = create_app('testing')
DB.drop_all(app=app)
DB.create_all(app=app)
app.app_context().push()
user_id = {'user_id': "1"}
schema = UserSchema().load(user_id)
new_user = UserModel(**schema.data)
DB.session.begin()
DB.session.add(new_user)
DB.session.commit()
return app
def create_app(config_name='development'):
""" Create the application with the relevant configuration. """
app = Flask(__name__)
app.config.from_object(CONFIG_MAPPER[config_name])
app.wsgi_app = ProxyFix(app.wsgi_app)
from . import extensions
from . import modules
for content in (
extensions,
modules,
):
content.init_app(app)
DB.create_all(app=app)
return app
def db_init(config):
"""Creation of database"""
if os.path.isfile(config.DB_FILE):
print('[WARNING] File [{}] already exists.'.format(config.DB_FILE))
sys.exit(0)
if not os.path.exists(os.path.dirname(config.DB_FILE)):
os.makedirs(os.path.dirname(config.DB_FILE))
app = create_app(config_object=config)
with app.app_context():
DB.init_app(app)
DB.create_all()
DB.session.commit()
print('[SUCCESS] File [{}] created.'.format(config.DB_FILE))
sys.exit(0)
def register_extensions(app):
"""Register Flask extensions."""
BCRYPT.init_app(app)
DB.init_app(app)
MAIL.init_app(app)
BOOTSTRAP.init_app(app)
bootstrapcdn = WebCDN(
"https://stackpath.bootstrapcdn.com/bootstrap/3.3.7/")
bootswatchcdn = WebCDN(
"https://stackpath.bootstrapcdn.com/bootswatch/3.3.7/")
app.extensions['bootstrap']['cdns'].update({
'bootstrapcdn': bootstrapcdn,
'bootswatchcdn': bootswatchcdn
})
CSRF.init_app(app)
def db_check(config):
"""Check of database"""
if not os.path.isfile(config.DB_FILE):
print('[WARNING] File [{}] doesn\'t exist.'.format(config.DB_FILE))
sys.exit(1)
app = create_app(config_object=config)
with app.app_context():
DB.init_app(app)
internal = Internal.query.order_by(Internal.db_version.desc()).first()
if internal.db_version != config.DB_VERSION:
print(
'[WARNING] Schema version [{}] in file [{}] differs from proper [{}].'
.format(internal.db_version, config.DB_FILE,
config.DB_VERSION))
sys.exit(0)
print('[SUCCESS] Schema in [{}] file is in correct version [{}].'.format(
config.DB_FILE, config.DB_VERSION))
def db_init(config):
"""Creation of database"""
if os.path.isfile(config.DB_FILE):
print('[WARNING] File [{}] already exists.'.format(config.DB_FILE))
sys.exit(0)
if not os.path.exists(os.path.dirname(config.DB_FILE)):
os.makedirs(os.path.dirname(config.DB_FILE))
app = create_app(config_object=config)
with app.app_context():
DB.init_app(app)
DB.create_all()
internal = Internal(db_version=config.DB_VERSION,
rights_version=0,
updated_at=datetime.now())
DB.session.add(internal)
DB.session.commit()
print('[SUCCESS] File [{}] created.'.format(config.DB_FILE))
class Token(DB.Model):
"""Token data model"""
uid = DB.Column(UUID, primary_key=True, default=uuid.uuid4)
token_type = DB.Column(DB.Integer, nullable=False)
created_at = DB.Column(DB.DateTime(), nullable=False)
valid_until = DB.Column(DB.DateTime(), nullable=False)
is_active = DB.Column(DB.Boolean(), nullable=False, server_default='1')
user_uid = DB.Column(UUID, DB.ForeignKey('user.uid'), nullable=False)
note = DB.Column(DB.String(20), nullable=False, server_default='')
user = DB.relationship('User', back_populates='tokens', lazy='select')
class Player(DB.Model):
"""User data model"""
uid = DB.Column(UUID, primary_key=True, default=uuid.uuid4)
user_uid = DB.Column(UUID, DB.ForeignKey('user.uid'), nullable=False)
steam_id = DB.Column(DB.Integer, nullable=False)
name = DB.Column(DB.String(50), nullable=False, unique=True)
avatar = DB.Column(DB.String(300), nullable=False, unique=True)
avatar_medium = DB.Column(DB.String(300), nullable=False, unique=True)
avatar_full = DB.Column(DB.String(300), nullable=False, unique=True)
user = DB.relationship('User', back_populates='players', lazy='select')
class UserRole(DB.Model):
"""User Roles"""
uid = DB.Column(UUID, primary_key=True, default=uuid.uuid4)
name = DB.Column(DB.String(50), nullable=False, unique=True)
class RoleRights(DB.Model):
"""Connection roles <--> rights"""
uid = DB.Column(UUID, primary_key=True, default=uuid.uuid4)
role = DB.Column(DB.String(50), nullable=False)
rights = DB.Column(DB.String(50), nullable=False)
class RoleRight(DB.Model):
"""Connection roles <--> rights"""
uid = DB.Column(UUID, primary_key=True, default=uuid.uuid4)
role_uid = DB.Column(UUID, nullable=False, unique=True)
right_uid = DB.Column(UUID, nullable=False, unique=True)
class Role(DB.Model):
"""User Roles"""
name = DB.Column(DB.String(50), primary_key=True)
def register_extensions(flask_app: Flask) -> None:
DB.init_app(flask_app)
class Player(DB.Model):
"""User data model"""
uid = DB.Column(UUID, primary_key=True, default=uuid.uuid4)
user_uid = DB.Column(UUID, DB.ForeignKey('user.uid'), nullable=False)
steam_id = DB.Column(DB.Integer, nullable=False)
name = DB.Column(DB.String(50), nullable=False, unique=True)
avatar = DB.Column(DB.String(300), nullable=False, unique=True)
avatar_medium = DB.Column(DB.String(300), nullable=False, unique=True)
avatar_full = DB.Column(DB.String(300), nullable=False, unique=True)
user = DB.relationship('User', back_populates='players', lazy='select')
User.players = DB.relationship('Player',
order_by=Player.name,
back_populates='user',
lazy='select')
@unique
class TokenType(Enum):
"""Type of tokens"""
INVITATION = 1
RESET_PASSWORD = 2
ACCESS = 3
RENEW_ACCESS = 4
class Token(DB.Model):
"""Token data model"""
class User(DB.Model):
user_id = DB.Column(DB.String(40), primary_key=True)
first_name = DB.Column(DB.String(100))
last_name = DB.Column(DB.String(100))
def register_extensions(app):
"""Register Flask extensions."""
DB.init_app(app)
API.init_app(app)
