def groups():
# Groups login
print('----------------- group_bp.route(/group/)')
print('current_user /group/: ', current_user)
logger = init_logger(__name__, testing_mode=False)
profile = current_user.profile
print('profile: ', profile)
# Show all group & CRUD options
if profile == 'admin':
# Get all groups
all_groups = GroupMethod.get_all_groups()
else:
# Get all groups in which current_user is manager
all_groups = GroupMethod.user_get_all_groups_manager(
current_user.username)
print('all_groups: ', all_groups)
if len(all_groups) > 0:
logger.info(
'Current User: {}\n'
'\t\tGROUP - <create - POST>: all_groups loaded successfully - len(all_groups): {}'
.format(current_user.username, len(all_groups)))
else:
logger.info(
'Current User: {}\n'
'\t\tGROUP - <create - POST>: all_groups could not be loaded - len(all_groups): 0'
.format(current_user.username))
return render_template('group/group_zmenu.html',
groups=all_groups,
profile=profile)
def read(username: str):
# User read
print('----------------- user_bp.route(/user/read/)')
print('username: '******'profile']
logger = init_logger(__name__, testing_mode=False)
try:
user_data = UserMethod.get_user_by_session_data(username)
if user_data:
logger.info(
'Current User: {}\n'
'\t\tUSER - <create>: user <{}> loaded successfully'.format(
current_user.username, username))
else:
logger.warning(
'Current User: {}\n'
'\t\tUSER - <create>: user <{}> could not be loaded'.format(
current_user.username, username))
return render_template('user/user_read.html',
filename=user_data['picture'],
profile=profile,
user=user_data)
except Exception as e:
print('Exception in /user/read/{}'.format(username))
print('error: ', e)
logger.error('Current User: {}\n'
'\t\tUSER - <create>: something is wrong\n'
'\t\tException: {}'.format(current_user.username, e))
return render_template('errors/404.html'), 404
def set_language(language=None):
print('----------------- user_bp.route(/language/{})'.format(language))
session['language'] = language
print('session[language]: ', session['language'])
print('1. current_user.language: ', current_user.language)
language_class = 'flag-icon-co' if language == 'es' else 'flag-icon-us'
logger = init_logger(__name__, testing_mode=False)
try:
logger.error('Current User: {}\n'
'\t\tUSER - <set_language>: language <{}> updated'.format(
current_user.username, language))
return redirect(
url_for('case_bp.cases_user_login',
language_class=language_class,
profile=session['profile']))
# return redirect(url_for('user_bp.users',
# language_class=language_class,
# profile=session['profile']))
except Exception as e:
print('Exception in /language/{}'.format(language))
print('error: ', e)
logger.error(
'Current User: {}\n'
'\t\tUSER - <set_language>: Something is wrong - language: {}\n'
'\t\tException: {}'.format(current_user.username, language, e))
return render_template('errors/404.html'), 404
def read(caseName: str):
# Case read
print('----------------- case_bp.route(/case/read/)')
print('caseName: ', caseName)
logger = init_logger(__name__, testing_mode=False)
# profile = session['profile']
case_data = CaseMethod.get_case_by_case_name(caseName)
groups = CaseMethod.get_all_groups_name()
if case_data:
logger.info('Current User: {}\n'
'\t\tCASE - <read>: case_data loaded successfully - caseName: {}'
.format(current_user.username, case_data['name']))
else:
logger.warning('Current User: {}\n'
'\t\tCASE - <read>: case_data could not be loaded'
.format(current_user.username))
if groups:
logger.info('Current User: {}\n'
'\t\tCASE - <read>: groups loaded successfully - groups len: {}'
.format(current_user.username, len(groups)))
else:
logger.warning('Current User: {}\n'
'\t\tCASE - <read>: groups could not be loaded'
.format(current_user.username))
print('case_data: ', case_data)
print('groups: ', groups)
return case_data
def delete(username: str):
# User delete
print('----------------- user_bp.route(/user/delete/)')
print('username: '******'profile']
user_delete = UserMethod.delete_user_by_username(username)
if user_delete:
flash(
'The user <{}> has been deleted successfully'.format(username))
logger.info(
'Current User: {}\n'
'\t\tUSER - <delete>: user <{}> has been deleted successfully'.
format(current_user.username, username))
else:
flash('The user <{}> could not be deleted'.format(username))
logger.warning(
'Current User: {}\n'
'\t\tUSER - <create>: user <{}> could not be deleted'.format(
current_user.username, username))
return redirect(url_for('user_bp.users', profile=profile))
except Exception as e:
print('Exception in /user/delete/{}'.format(username))
print('error: ', e)
logger.error('Current User: {}\n'
'\t\tUSER - <create>: something is wrong\n'
'\t\tException: {}'.format(current_user.username, e))
return render_template('errors/404.html'), 404
def cases_user(username: str):
print('------------------ case_bp.route(/case/{})'.format(username))
logger = init_logger(__name__, testing_mode=False)
# if current_user_profile == 'user':
print('Current User: {}\n'
'\t\tCASE - <cases/{}>: current user data has been loaded successfully'
.format(current_user.username, username))
logger.info('Current User: {}\n'
'\t\tCASE - <cases/{}>: current user data has been loaded successfully'
.format(current_user.username, username))
current_user_cases_and_groups = CaseMethod.get_user_cases_and_groups_by_username(username)
if current_user_cases_and_groups:
print('Current User: {}\n'
'\t\tCASE - <cases/{}>: current_user_cases_and_groups loaded successfully'
.format(current_user.username, username))
logger.info('Current User: {}\n'
'\t\tCASE - <cases/{}>: current_user_cases_and_groups loaded successfully'
.format(current_user.username, username))
else:
print('Current User: {}\n'
'\t\tCASE - <cases/{}>: current_user_cases_and_groups could not be loaded'
.format(current_user.username, username))
logger.warning('Current User: {}\n'
'\t\tCASE - <cases/{}>: current_user_cases_and_groups could not be loaded'
.format(current_user.username, username))
print('current_user_cases_and_groups: ', current_user_cases_and_groups)
return render_template('case/case_user_cases.html',
cases=current_user_cases_and_groups,
language_class='flag-icon-co' if session['language'] == 'es' else 'flag-icon-us',
profile=current_user.profile,
state=request.args.get('state'),
title='User Cases')
def update(caseName: str):
# Case update
print('----------------- case_bp.route(/case/update/) - {}'.format(request.method))
print('caseName: ', caseName)
logger = init_logger(__name__, testing_mode=False)
# profile = session['profile']
if request.method == 'GET':
case_data = CaseMethod.get_case_by_case_name(caseName)
print('case_data: ', case_data)
if case_data:
print('CASE - <update - GET>: case_data loaded successfully - caseName: {}'.format(case_data['name']))
logger.info('Current User: {}\n'
'\t\tCASE - <update - GET>: case_data loaded successfully - caseName: {}'
.format(current_user.username, case_data['name']))
else:
logger.error('Current User: {}\n'
'\t\tCASE - <update - GET>: case_data could not be loaded'
.format(current_user.username))
all_groups = CaseMethod.get_all_groups_name()
if all_groups and len(all_groups) > 0:
logger.info('Current User: {}\n'
'\t\tCASE - <update>: all_groups loaded successfully - all_groups len: {}'
.format(current_user.username, len(all_groups)))
else:
logger.error('Current User: {}\n'
'\t\tCASE - <update - GET>: all_groups could not be loaded'
.format(current_user.username))
print('case_data: ', case_data)
print('all_groups: ', all_groups)
all_groups = CaseMethod.filter_groups(all_groups, case_data['groups'])
print('*** all_groups: ', all_groups)
return case_data
# return render_template('case/case_update.html',
# case=case_data,
# groups=all_groups,
# profile=profile)
elif request.method == 'POST':
# groups = request.form.getlist('current_case_groups')
case_data = {
'name': request.form.get('name'),
'caseId': request.form.get('id'),
'description': request.form.get('description'),
'groups': [request.form.get('group')],
'status': request.form.get('status'),
'type': request.form.get('type'),
'dueDate': request.form.get('dueDate')
}
print('case_data: ', case_data)
print('caseName: ', caseName)
if CaseMethod.update_case_data(caseName, case_data):
logger.info('Current User: {}\n'
'\t\tCASE - <update - POST>: Case \'{}\' updated successfully'
.format(current_user.username, case_data['name']))
else:
logger.warning('Current User: {}\n'
'\t\tCASE - <update - POST>: Case \'{}\' could not be updated'
.format(current_user.username, case_data['name']))
return redirect(url_for('case_bp.cases_user',
username=current_user.username))
def case_environment(caseName: str):
# Create case environment
print('------------------- case_bp.route(/case/{})'.format(caseName))
logger = init_logger(__name__, testing_mode=False)
logger.info('Current User: {}\n'
'\t\tCASE - <case_environment>: The case <{}> has been selected'
.format(current_user.username, caseName))
return None
def create():
# Case create
print('----------------- case_bp.route(/case/create/) - {}'.format(request.method))
logger = init_logger(__name__, testing_mode=False)
# profile = session['profile']
currentUserUsername = current_user.username
# if request.method == 'POST':
caseId = request.form.get('id')
caseGroup = request.form.get('group')
caseName = request.form.get('name')
caseDescription = request.form.get('description')
caseType = request.form.get('type')
caseStatus = request.form.get('status')
caseDueDate = request.form.get('dueDate')
caseClientName = request.form.get('clientName')
caseClientId = request.form.get('clientId')
caseClientDescription = request.form.get('clientDescription')
validateExistUser = CaseMethod.validate_case_exist(caseId)
print('validate_exist_user: '******'*** --- caseGroup: ', caseGroup)
# Validate if caseId does not exist
if validateExistUser.count() == 0:
print('case with ID: {} - does not exist...'.format(caseId))
newCase = {'id': caseId,
'name': caseName,
'description': caseDescription,
'type': caseType,
'status': caseStatus,
'groups': [caseGroup],
'dueDate': caseDueDate,
'clientName': caseClientName,
'clientId': caseClientId,
'client_description': caseClientDescription}
print('NEW CASE - data: {}'.format(newCase))
caseCreated = CaseMethod.create_case(newCase)
if caseCreated:
flash('Case created successfully')
logger.info('Current User: {}\n'
'\t\tCASE - <create - POST>: Case \'{}\' has been created successfully'
.format(current_user.username, caseName))
else:
flash('Case could not be created...')
logger.warning('Current User: {}\n'
'\t\tCASE - <create - POST>: Case \'{}\' could not be created'
.format(current_user.username, caseName))
else:
print('Provided case ID already exist...')
flash('Case could not be created... Provided case ID already exist')
logger.warning('Current User: {}\n'
'\t\tCASE - <create - POST>: Case \'{}\' could not be created'
.format(current_user.username, caseId))
return redirect(url_for('case_bp.cases_user',
state=request.args.get('state'),
username=currentUserUsername))
def cases_user_login():
print('------------------ case_bp.route(/cases/user/login)')
current_user_username = current_user.username
logger = init_logger(__name__, testing_mode=False)
logger.info('Current User: {}\n'
'\t\tCASE - <cases/user/login>: current user username: {}'
.format(current_user.username, current_user_username))
print('current_user_username: '******'case_bp.cases_user',
state=request.args.get('state'),
username=current_user_username))
def update_session(session_data: dict) -> None:
# Store all provided data in the current session
print('------------------- update_session')
logger = init_logger(__name__, testing_mode=False)
session['access_token'] = session_data['access_token']
session['authenticated'] = session_data['authenticated']
session['email'] = session_data['email']
session['profile'] = session_data['profile']
session['provider'] = session_data['provider']
session['session_id'] = session_data['session_id']
session['username'] = session_data['username']
logger.info('update_session: session has been updated successfully')
def users():
# User login
print('----------------- user_bp.route(/user/)')
logger = init_logger(__name__, testing_mode=False)
# Select user type: admin, manager or user
print('|--- current_user: '******'|--- request: ', request)
print('|--- session: ', session)
print('~~~~~~~~~~~~ session: ', session)
profile = session['profile']
user_method = []
try:
state = session['session_id'] # The same state value
if profile == 'admin':
print('---------- admin')
user_method = UserMethod.get_all_users_name()
elif profile == 'manager':
print('---------- manager')
user_method = UserMethod.get_all_users_name_manager(
current_user.username)
elif profile == 'user':
print('---------- user')
return redirect(
url_for('case_bp.cases_user', username=current_user.username))
else:
# Required profile does not exist
print('Required profile does not exist')
logger.critical(
'Current User: {}\n'
'\t\tUSER - <users>: Required profile does not exist'.format(
current_user.username))
if len(user_method) > 0:
logger.info(
'Current User: {}\n'
'\t\tUSER - <users>: users loaded successfully - len(user_method): {}'
.format(current_user.username, len(user_method)))
return render_template('user/user_zmenu.html',
language_class='flag-icon-co' if
session['language'] == 'es' else 'flag-icon-us',
profile=profile,
state=state,
users=user_method)
except Exception as e:
print('Exception in /user')
print('error: ', e)
logger.error('Current User: {}\n'
'\t\tUSER - <users>: Something wrong in users...\n'
'\t\tERROR: {}'.format(current_user.username, e))
return render_template('errors/404.html'), 404
def get_user_image(filename: str):
# Return filename image
print('---------------- get_user_image')
logger = init_logger(__name__, testing_mode=False)
try:
return UserMethod.load_user_picture(filename)
except Exception as e:
print('Exception in /user/image/{}'.format(filename))
print('error: ', e)
logger.warning(
'Current User: {}\n'
'\t\tUSER - <get_user_image>: User image could not be loaded... something is wrong!!!'
.format(current_user.username))
return render_template('errors/404.html'), 404
def create():
# Group create
print('------------------- group_bp.create - {}'.format(request.method))
profile = session['profile']
logger = init_logger(__name__, testing_mode=False)
if request.method == 'GET':
all_users = UserMethod.get_all_users_username()
if len(all_users) > 0:
logger.info(
'Current User: {}\n'
'\t\tGROUP - <create - GET>: all_users loaded successfully - len(all_users): {}'
.format(current_user.username, len(all_users)))
else:
logger.warning(
'Current User: {}\n'
'\t\tGROUP - <create - GET>: all_users could not be loaded - len(all_users): 0'
.format(current_user.username))
return render_template('group/group_create.html',
profile=profile,
users=all_users)
elif request.method == 'POST':
managers_list = GroupMethod.extract_users(
request.form.getlist('managers_list'))
users_list = GroupMethod.extract_users(
request.form.getlist('users_list'))
group_data = {
'_id': 1,
'name': request.form.get('name'),
'description': request.form.get('description'),
'user_groups_manager': managers_list,
'user_groups': users_list
}
print('group_data: ', group_data)
group_created = GroupMethod.create_group(group_data)
if group_created:
flash('Group created successfully')
logger.info(
'Current User: {}\n'
'\t\tGROUP - <create - POST>: group created successfully - group_name: {}'
.format(current_user.username, group_data['name']))
else:
flash('Group could not be created')
logger.warning(
'Current User: {}\n'
'\t\tGROUP - <create - POST>: group could not be created - group_name: {}'
.format(current_user.username, group_data['name']))
return redirect(url_for('group_bp.groups', profile=profile))
def delete(caseName: str):
# Case delete
print('----------------- case_bp.route(/case/delete/)')
print('caseName: ', caseName)
logger = init_logger(__name__, testing_mode=False)
# profile = session['profile']
delete_case = CaseMethod.delete_case_by_case_name(caseName)
if delete_case:
flash('The case <{}> has been deleted successfully'.format(caseName))
logger.info('Current User: {}\n'
'\t\tCASE - <delete>: case \'{}\' has been deleted successfully'
.format(current_user.username, caseName))
else:
flash('The case <{}> could not be deleted'.format(caseName))
logger.warning('Current User: {}\n'
'\t\tCASE - <delete>: case \'{}\' could not be deleted'
.format(current_user.username, caseName))
return redirect(url_for('case_bp.cases_user',
username=current_user.username))
def delete(group_name: str):
# Group delete
print('------------------ group_bp.delete - {}'.format(group_name))
logger = init_logger(__name__, testing_mode=False)
profile = session['profile']
if GroupMethod.delete_group_by_group_name(group_name):
flash(
'The group <{}> has been deleted successfully'.format(group_name))
logger.info(
'Current User: {}\n'
'\t\tGROUP - <delete>: group deleted successfully - group_name: {}'
.format(current_user.username, group_name))
else:
flash('The group <{}> could not be deleted'.format(group_name))
logger.warning(
'Current User: {}\n'
'\t\tGROUP - <delete>: group could not be deleted - group_name: {}'
.format(current_user.username, group_name))
return redirect(url_for('group_bp.groups', profile=profile))
def settings():
# User login
print('----------------- user_bp.route(/user/settings)')
logger = init_logger(__name__, testing_mode=False)
try:
logger.info(
'Current User: {}\n'
'\t\tUSER - <settings>: user settings loaded successfully'.format(
current_user.username))
return redirect(
url_for('user_bp.update', username=current_user.username))
except Exception as e:
print('Exception in /user/settings')
print('error: ', e)
logger.error(
'Current User: {}\n'
'\t\tUSER - <settings>: user settings exception - exception: {}'.
format(current_user.username, e))
return render_template('errors/404.html'), 404
def read(group_name: str):
# Group read
print('------------------ group_bp.read - {}'.format(group_name))
logger = init_logger(__name__, testing_mode=False)
profile = session['profile']
group_data = GroupMethod.get_group_by_group_name(group_name)
if group_data:
logger.info(
'Current User: {}\n'
'\t\tGROUP - <read>: group loaded successfully - group_name: {}'.
format(current_user.username, group_data['name']))
else:
logger.warning(
'Current User: {}\n'
'\t\tGROUP - <update - POST>: group loaded successfully'.format(
current_user.username))
print('group_data: ', group_data)
return render_template('group/group_read.html',
group=group_data,
profile=profile)
def cases():
# Cases login
print('----------------- case_bp.route(/cases/)')
logger = init_logger(__name__, testing_mode=False)
# Select user type: admin, manager or user
print('|--- current_user: '******'|--- request: ', request)
print('|--- session: ', session)
profile = session['profile']
state = session['session_id'] # The same state value
all_groups = CaseMethod.get_all_groups_name()
print('len(all_groups): ', len(all_groups))
if len(all_groups) > 0:
logger.info('Current User: {}\n'
'\t\tCASE - <cases>: all_groups have been loaded successfully - len(all_groups): {}'
.format(current_user.username, len(all_groups)))
else:
logger.warning('Current User: {}\n'
'\t\tCASE - <cases>: all_groups could not be loaded - 0'
.format(current_user.username))
print('case - session: ', session)
print('case - profile: ', profile)
# Get all cases
all_cases = CaseMethod.get_all_cases()
if len(all_cases) > 0:
logger.info('Current User: {}\n'
'\t\tCASE - <cases>: all_cases have been loaded successfully - len(all_cases): {}'
.format(current_user.username, len(all_cases)))
else:
logger.warning('Current User: {}\n'
'\t\tCASE - <cases>: all_cases could not be loaded - len(all_cases): 0'
.format(current_user.username))
print('all_cases: ', all_cases)
# Show all cases & CRUD options
return render_template('case/case_zmenu.html',
cases=all_cases,
groups=all_groups,
profile=profile,
state=state)
def logout():
# Logout & Close current session
print('-------------------- logout')
logger = init_logger(__name__, testing_mode=False)
try:
logout_user()
print('session: ', session)
print('session[access_token]: ', session['access_token'])
logger.info('LOGIN - <logout>: User {} has logged out successfully '.format(session['email']))
# Update logout-time in session collection
LoginMethod.update_logout_time(session['access_token'])
del session['access_token']
del session['authenticated']
del session['email']
del session['profile']
del session['session_id']
del session['username']
session.modified = True
return redirect(url_for('login_bp.login'))
except Exception as e:
logger.error('LOGIN - <logout>: User {} could not logged out successfully - ERROR: {}'
.format(session['username'], e))
def login():
languages = {'en': 'English', 'es': 'Español'}
# Login local user
print('----------------- login %s' % request.method)
logger = init_logger(__name__, testing_mode=False)
state = LoginMethod.generate_state_var()
print('state: ', state)
if request.method == 'GET':
current_app.logger.info('LOGIN - <login - GET>: Login form loaded successfully')
return render_template('login/login.html',
state=state)
if request.method == 'POST':
print('POST method running for login_bp - Validating User')
logger.info('LOGIN - <login - POST>: Login form received successfully')
# Validate login form
validate_login_form = ValidateLoginForm(request.form)
logger.info('LOGIN - <login - POST>: Login form send to validation')
print('validate_login_form: ', validate_login_form)
if validate_login_form.validate():
print('|--> Login form validated')
logger.info('LOGIN - <login - POST>: Login form has been validated successfully for user: <{}>'
.format(validate_login_form.email.data))
# Catch user & password
email_or_username = validate_login_form.email.data
password = validate_login_form.password.data
remember = validate_login_form.remember.data
print('email_or_username: '******'email: ', email)
if email:
# Validate that user exists
user_from_db_by_email = LoginMethod.get_user_by_email(email)
user = LoginMethod.user_method_validate_user(user_from_db_by_email, password)
print('******* ****** type(user): ', type(user))
# Check if user actually exists take the login supplied password, hash it,
# and compare it to the hashed password in the database if not login or
# not check_password_hash(login.password, password
if not user:
print('Provided user email doesn\'t exist, invalid password or user is not active')
flash('Something is wrong!!!\n'
'\t- Provided email doesn\'t exist\n'
'\t- Invalid password\n'
'-\tUser is not active')
logger.warning('LOGIN - <login - POST>: Something is wrong!!!:\n'
'\t- Provided email doesn\'t exist'
'\t- Invalid password'
'\t- User is not active')
return redirect(url_for('login_bp.login',
state=state))
print('|--> user: '******'The user has been added to current session environment...')
# Update session data
session_data = LoginMethod.user_method_session_data(user, state)
print('Session data updated... session_data: ', session_data)
update_session(session_data)
print('Session data updated... session: ', session)
# Create login register
new_login = LoginMethod.create_login(user_id=LoginMethod.user_method_get_user_id(user))
print('new_login: \n', new_login)
if not new_login:
flash('Something was wrong, and session could not be initiated... try again')
return redirect(url_for('login_bp.login'))
flash('Successful Login')
print('Successful Login')
print('session: ', session)
logger.info('LOGIN - <login>: User {} has logged in successfully '.format(email))
print('-*-*-*-*-*-*-*-*-*-*-*-*-*- User Login')
language_class = 'flag-icon-co' if session['language'] == 'es' else 'flag-icon-us'
return redirect(url_for('case_bp.cases_user_login',
language_class=language_class,
state=state))
else:
flash('Some provided data is not valid or wrong')
logger.warning('LOGIN - <login - POST>: A user has provided wrong data ')
return redirect(url_for('login_bp.login'))
def create_app():
print('------------ create_app')
""" Initialize the core application """
# Flask: --- Setup ----------------------------------
app = Flask(__name__, instance_relative_config=True)
# Flask: --- Config Setup ---------------------------
app.config.from_object('application.instance.config.Config')
app.config['DEBUG'] = True
app.config['MONGO_URI'] = URI
""" Load Configuration """
# Flask-Babel: --- Setup ----------------------------
babel.init_app(app)
# Flask-login: --- Setup ----------------------------
login_manager.init_app(app)
# Flask-pymongo: --- Setup --------------------------
mongo.init_app(app)
""" Initialize plugins """
print('<< Connected successfully with DB >>\n\t\t', mongo.db)
login_manager.login_message = 'You must be logged in to access this page'
login_manager.login_message_category = 'info'
login_manager.session_protection = 'strong'
login_manager.login_view = 'login_bp.login'
# Logs management & configuration
# file_handler = FileHandler.file_handler()
logger = init_logger(__name__, testing_mode=False)
print('-*-*-*-*-*-*-*-*-*-*-*-*-*- logger: ', logger)
logger.info('SETUP - <create-app>: Plugins initialized successfully')
# Use the modified encoder class to handle ObjectId & datetime object while jsonify the response
app.json_encoder = JSONEncoder
from application.modules import UserMethod, User
@login_manager.user_loader
def load_user(user_id) -> User: # (session_token):
print('Validating user - user_id: ', user_id)
logger.info(
'SETUP - <create-app / load_user> Validating user: {}'.format(
user_id))
user_to_return = UserMethod.load_user(user_id)
if user_to_return:
logger.info(
'SETUP - <create-app / load_user> User loaded successfully:\n{}'
.format(user_to_return))
if user_to_return.language != 'es':
logger.info(
'SETUP - <create-app / load_users> language validated - EN'
)
app.config['BABEL_DEFAULT_LOCALE'] = 'en'
else:
logger.info(
'SETUP - <create-app / load_users> language validated - ES'
)
return user_to_return
@login_manager.unauthorized_handler
def unauthorized():
flash('You must be logged in to view that page')
logger.info(
'SETUP - <unauthorized>: Current user has not been authorized')
return redirect(url_for('login_bp.login'))
@babel.localeselector
def get_locale():
# If a user is logged in, use the Locale from the user settings
try:
language = session['language']
logger.info(
'SETUP - <get_locale> - session language has been loaded - {}'.
format(session['language']))
except KeyError:
# Otherwise try to guess the language from the user accept header
# the browser transmits. We support 'en'/'es'
language = request.accept_languages.best_match(
app.config['LANGUAGES'].keys())
logger.warning(
'SETUP - <get_locale / KeyError>: language in None, then try to guess the language\n'
'\tfrom the user accept header the browser transmits. We support \'en\'/\'es\'\n'
'\t\tlanguage = {}'.format(language))
return language
@babel.timezoneselector
def get_timezone():
user = getattr(g, 'user', None)
if user is not None:
logger.info('SETUP - <get_timezone>: {}'.format(user.timezone))
return user.timezone
@app.context_processor
def inject_conf_var():
logger.info(
'SETUP - <inject_conf_var>: languages loading and validation')
return dict(AVAILABLE_LANGUAGES=app.config['LANGUAGES'],
CURRENT_LANGUAGE=session.get(
'language',
request.accept_languages.best_match(
app.config['LANGUAGES'].keys())))
# --------------------------------------- Error Handler
@app.errorhandler(Exception)
def error_handler(error):
print('-------------------- ERROR: - {}'.format(error.code))
print('error: ', error)
msg = '''Request resulted in ERROR
CODE: {}
MESSAGE:{}'''.format(
error.code or 500, error.description or 'Internal Server Error')
print('type(error): ', type(error))
print('msg: ', msg)
logger.error(
'SETUP - <error_handler>: An ERROR has occurred - {}\n{}'.format(
msg, error))
# exc_info=error)
if isinstance(error, HTTPException):
description = error.get_description(request.environ)
code = error.code
name = error.name
else:
description = ('We encountered an error'
'While trying to fulfill your request')
code = 500
name = 'Internal Server Error'
templates_to_try = 'errors/{}.html'.format(code, 'errors/generic.html')
prev_page = AuxFuncs.previous_page(request.path)
print('templates_to_try: ', templates_to_try)
return render_template(templates_to_try,
code=code,
name=Markup(name),
description=description,
error=error,
prev_page=prev_page)
with app.app_context():
""" Blueprints """
# Blueprint for module routes in app
from application.modules import (case_bp, group_bp, login_bp, user_bp)
# Register Blueprints
app.register_blueprint(case_bp)
app.register_blueprint(group_bp)
app.register_blueprint(login_bp)
app.register_blueprint(user_bp)
logger.info(
'SETUP - <app.app_context>: All blueprints have been loaded successfully'
)
return app
def update(username: str):
# User update
print('----------------- user_bp.route(/user/update/) - {}'.format(
request.method))
print('username: '******'profile']
try:
if request.method == 'GET':
user_data = UserMethod.get_user_by_session_data(username)
if user_data:
logger.info(
'Current User: {}\n'
'\t\tUSER - <update - GET>: user <{}> update format has been loaded successfully'
.format(current_user.username, username))
else:
logger.warning(
'Current User: {}\n'
'\t\tUSER - <update - GET>: user<{}> update format could not be loaded'
.format(current_user.username, username))
print('current_user.username: '******'user_data[username]: ', user_data['username'])
print('current_user.username == user_data[username]: ',
current_user.username == user_data['username'])
return render_template(
'user/user_update.html',
filename=user_data['picture'],
is_owner=current_user.username == user_data['username'],
profile=profile,
user=user_data)
elif request.method == 'POST':
print('profile: ', profile)
print('username: '******'current_user.username: '******'username == current_user.username: '******'admin' or profile
== 'manager') and username != current_user.username:
print('the user has profile of: {}\nor is owner{}'.format(
profile, username == current_user.username))
user_data = {
'name': request.form.get('name'),
'username': request.form.get('username'),
'email': request.form.get('email'),
'profile': request.form.get('profile'),
'active': request.form.get('active'),
'language': request.form.get('language')
}
user_update = UserMethod.update_user_data(
profile, username, user_data)
if user_update:
logger.info(
'Current User: {}\n'
'\t\tUSER - <update - POST>: user<{}> has been updated successfully'
.format(current_user.username, username))
else:
logger.warning(
'Current User: {}\n'
'\t\tUSER - <update - POST>: user<{}> could no be updated'
.format(current_user.username, username))
print('user_data: ', user_data)
print('username: '******'user_bp.users', profile=profile))
picture = None
if 'picture' in request.files:
print('picture in request files...')
picture = request.files['picture']
else:
print('picture is not in request files XXX')
user_data = {
'name': request.form.get('name'),
'username': request.form.get('username'),
'email': request.form.get('email'),
'picture': '' if not picture else picture.filename,
'password': request.form.get('password'),
'profile': request.form.get('profile'),
'active': request.form.get('active'),
'language': request.form.get('language')
}
user_update = UserMethod.update_user_data(profile, username,
user_data, picture)
if user_update:
logger.info(
'Current User: {}\n'
'\t\tUSER - <update - POST>: user<{}> has been updated successfully'
.format(current_user.username, username))
else:
logger.warning(
'Current User: {}\n'
'\t\tUSER - <update - POST>: user<{}> could no be updated'.
format(current_user.username, username))
print('user_data: ', user_data)
print('username: '******'user_bp.users', profile=profile))
except Exception as e:
print('Exception in /user/update/{}'.format(username))
print('error: ', e)
logger.error(
'Current User: {}\n'
'\t\tUSER - <update - POST>: user<{}> something is wrong\n'
'\t\tException: {}'.format(current_user.username, username, e))
return render_template('errors/404.html'), 404
def create():
# User create
print('----------------- user_bp.route(/user/create/) - {}'.format(
request.method))
logger = init_logger(__name__, testing_mode=False)
profile = session['profile']
try:
if request.method == 'GET':
logger.info(
'Current User: {}\n'
'\t\tUSER - <create>: user create form loaded successfully'.
format(current_user.username))
return render_template('user/user_create.html', profile=profile)
elif request.method == 'POST':
email_user_data = UserMethod.get_user_by_email(
request.form.get('email'))
username_user_data = UserMethod.get_user_by_username(
request.form.get('username'))
if not email_user_data:
logger.info(
'Current User: {}\n'
'\t\tUSER - <create>: user email <{}> does not exist in DB'
.format(current_user.username, request.form.get('email')))
if not username_user_data:
logger.info(
'Current User: {}\n'
'\t\tUSER - <create>: user username <{}> does not exist in DB'
.format(current_user.username,
request.form.get('username')))
picture = None
if 'picture' in request.files:
print('picture in request files...')
picture = request.files['picture']
else:
print('picture is not in request files XXX')
email = request.form.get('email')
username = request.form.get('username')
user_data = {
'_id': 1,
'name': request.form.get('name'),
'username': username.replace(' ', ''),
'email': email.replace(' ', ''),
'picture': '' if not picture else picture.filename,
'language': request.form.get('language'),
'password': request.form.get('password'),
'profile': request.form.get('profile')
}
user_created = UserMethod.create_user(user_data, picture)
if user_created:
flash('User created successfully')
logger.info(
'Current User: {}\n'
'\t\tUSER - <create>: user <{}> created successfully'
.format(current_user.username,
user_created['username']))
return redirect(
url_for('user_bp.users', profile=profile))
else:
flash('User could not be created...')
logger.warning(
'Current User: {}\n'
'\t\tUSER - <create>: user <{}> could not be created'
.format(current_user.username,
user_created['username']))
return redirect(
url_for('user_bp.users', profile=profile))
else:
flash(
'User username already exist in Database, try a different username'
)
logger.warning(
'Current User: {}\n'
'\t\tUSER - <create>: user <{}> already exist in Database'
.format(current_user.username,
request.form.get('username')))
return redirect(url_for('user_bp.create', profile=profile))
else:
flash(
'User email already exist in Database, try a different email'
)
logger.warning(
'Current User: {}\n'
'\t\tUSER - <create>: user email <{}> already exist in Database'
.format(current_user.username, request.form.get('email')))
return redirect(url_for('user_bp.create', profile=profile))
return redirect(url_for('user_bp.users', profile=profile))
except Exception as e:
print('Exception in /user/create/')
print('error: ', e)
logger.error(
'Current User: {}\n'
'\t\tUSER - <create>: something is wrong\n\t\tException: {}'.
format(current_user.username, e))
return render_template('errors/404.html'), 404
def update(group_name: str):
# Group update
print('------------------ group_bp.update - {}'.format(group_name))
logger = init_logger(__name__, testing_mode=False)
profile = session['profile']
if request.method == 'GET':
group_data = GroupMethod.get_group_by_group_name(group_name)
if group_data:
print(
'GROUP - <update - GET>: group_data loaded successfully - group_name: {}'
.format(group_data['name']))
logger.info(
'Current User: {}\n'
'\t\tGROUP - <update - GET>: group_data loaded successfully - group_name: {}'
.format(current_user.username, group_data['name']))
else:
print('GROUP - <update - GET>: group_data could not be loaded')
logger.warning(
'Current User: {}\n'
'\t\tGROUP - <update - GET>: group_data could not be loaded'.
format(current_user.username))
print('group_data: ', group_data)
all_users_list = GroupMethod.only_username_list(
GroupMethod.users_get_all_users_username())
all_group_managers = group_data['managers']
all_group_users = group_data['users']
print('all_users_list: ', all_users_list)
print('all_group_managers: ', all_group_managers)
print('all_group_users: ', all_group_users)
users = GroupMethod.extract_managers_and_users(all_users_list,
all_group_managers,
all_group_users)
print('users: ', users)
if len(users) > 0:
logger.info(
'Current User: {}\n'
'\t\tGROUP - <update - GET>: users loaded successfully - len(users): {}'
.format(current_user.username, len(users)))
else:
logger.warning(
'Current User: {}\n'
'\t\tGROUP - <update - GET>: users could not be loaded - len(users): 0'
.format(current_user.username))
return render_template('group/group_update.html',
group=group_data,
profile=profile,
users=users)
elif request.method == 'POST':
print('managers_list: ', request.form.getlist('managers_list'))
print('users_list: ', request.form.getlist('users_list'))
managers_list = GroupMethod.extract_users(
request.form.getlist('managers_list'))
users_list = GroupMethod.extract_users(
request.form.getlist('users_list'))
print('managers_list: ', managers_list)
print('users_list: ', users_list)
group_data = {
'name': request.form.get('name'),
'description': request.form.get('description'),
'manager': managers_list,
'user': users_list
}
print('group_data: ', group_data)
if GroupMethod.update_group_data(group_name, group_data):
logger.info(
'Current User: {}\n'
'\t\tGROUP - <update - POST>: group has been updated successfully - group_name): {}'
.format(current_user.username, group_data['name']))
else:
logger.info(
'Current User: {}\n'
'\t\tGROUP - <update - POST>: group loaded successfully - group_name: {}'
.format(current_user.username, group_data['name']))
return redirect(url_for('group_bp.groups', profile=profile))
