def get(self):
user = session.query(UserModel).filter(UserModel.user == request.authorization.username).first()
operations = session.query(OperationModel).filter(OperationModel.user_id == user.id).all()
# Checking if fetched operations list empty
if not operations:
return operations, 204
return operations, 200
def updateRoles(id):
form = RoleForm()
if not form.title.data[0].isdigit():
if form.validate_on_submit():
session.query(User_Role).filter(User_Role.id == id).update({User_Role.title: form.title.data})
return redirect(url_for('auth.getRoles'))
flash('Unable to update role!')
flash('Value entered must start with an alphabet!')
return redirect(url_for('auth.getRoles'))
def add_rule():
data = request.json
parameter = data['parameter']
threshold = data['threshold']
user_list = []
payload = {}
# Check if rule exists
if session.query(Rule).filter(Rule.parameter == parameter).first():
payload['status'] = False
payload['message'] = 'parameter %s already exists. Edit the rule instead.' % (parameter)
resp = jsonify(payload)
resp.status_code = 403
return resp
for username in data['usernames']:
user = session.query(User).filter(User.username == username).first()
# Check if all usernames exist
if user:
user_list.append(user)
# If a username does not exist, send an error message
else:
payload['status'] = False
payload['message'] = 'username %s does not exist.' % (username)
resp = jsonify(payload)
resp.status_code = 404
return resp
try:
# Add rule to database
new_rule = Rule(parameter=parameter,
threshold=threshold,
user=user_list)
session.add(new_rule)
session.commit()
except:
# Error saving rule to database
payload['status'] = False
payload['message'] = 'error creating rule.'
resp = jsonify(payload)
resp.status_code = 500
return resp
# Success response
payload['status'] = True
payload['message'] = 'rule for %s with threshold %d created successfuly.' % (parameter, threshold)
resp = jsonify(payload)
resp.status_code = 201
return resp
def edit_parameter(parameter):
data = request.json
threshold = data['threshold']
user_list = []
payload = {}
# Check if rule exists
rule = session.query(Rule).filter(Rule.parameter == parameter).first()
if not rule:
payload['status'] = False
payload['message'] = 'parameter %s does not exist.' % (parameter)
resp = jsonify(payload)
resp.status_code = 404
return resp
for username in data['usernames']:
user = session.query(User).filter(User.username == username).first()
# Check if all usernames exist
if user:
user_list.append(user)
# If a username does not exist, send an error message
else:
payload['status'] = False
payload['message'] = 'username %s does not exist.' % (username)
resp = jsonify(payload)
resp.status_code = 404
return resp
try:
# Edit rule
rule.parameter = parameter
rule.threshold = threshold
rule.user = user_list
session.commit()
except:
# Error editing rule
payload['status'] = False
payload['message'] = 'error editing rule.'
resp = jsonify(payload)
resp.status_code = 500
return resp
# Success response
payload['status'] = True
payload['message'] = 'rule for %s with threshold %d edited successfuly.' % (parameter, threshold)
resp = jsonify(payload)
resp.status_code = 200
return resp
def add_user():
data = request.json
username = data['username']
payload = {}
# Check if username exists
user = session.query(User).filter(User.username == username).first()
if user:
payload['status'] = False
payload['message'] = 'username %s already exists.' % (username)
resp = jsonify(payload)
resp.status_code = 403
return resp
try:
# Add user to database
new_user = User(username=username)
session.add(new_user)
session.commit()
except:
# Error saving event to database
payload['status'] = False
payload['message'] = 'error creating user.'
resp = jsonify(payload)
resp.status_code = 500
return resp
# Success response
payload['status'] = True
payload['message'] = 'user %s created successfuly.' % (username)
resp = jsonify(payload)
resp.status_code = 201
return resp
def last_match_id(self, nickname: str):
query = session.query(self.model)
model = query.filter(self.model.user_id == TftUserModel.id).order_by(
self.model.id.desc()).first()
if model:
match_id = model.match_id
return match_id
raise DbRecordNotExist
def placements_to(self, nickname: str, match_id: str):
"""
Выдать все отфильтрованные матчи
"""
rim_id = session.query(self.model.id)\
.filter(self.model.match_id == match_id)\
.order_by(self.model.id)\
.first()
matches = session.query(self.model)\
.filter(self.model.id >= rim_id)\
.all()
if matches:
placements = [match.placement for match in matches]
return placements
raise DbRecordNotExist
async def employee_put(id: str, employee: Employee) -> Any:
curr_empl = session.query(EmployeeDB) \
.filter(EmployeeDB.id == id) \
.one()
for key, value in employee.dict().items():
setattr(curr_empl, key, value)
session.commit()
return ({'message': 'success'})
def delete(self, id):
parsed_args = parser.parse_args()
delete_files=parsed_args['delete_files']
user = session.query(UserModel).filter(UserModel.user == request.authorization.username).first()
operation = session.query(OperationModel).filter(OperationModel.id == id, OperationModel.user_id ==user.id).first()
# checking if requested operation exists
if not operation:
abort(404, status="fail", message="No such operation")
# Deleting operation
# Deleting related files if specified
# Getting current session, it's not possible to delete row
# in SQLite while it's running on another session
curr_sess=db.session.object_session(operation)
curr_sess.delete(operation)
del_count=0
full_original=os.path.join(BASEDIR, UPLOAD_FOLDER, operation.original_file.split("/")[-1])
if not os.path.exists(full_original) or os.remove(full_original):
del_count+=1
full_keyword=os.path.join(BASEDIR, UPLOAD_FOLDER, operation.keyword.split("/")[-1])
if not os.path.exists(full_keyword) or os.remove(full_keyword):
del_count+=1
full_generated=os.path.join(BASEDIR, UPLOAD_FOLDER, operation.generated_file.split("/")[-1])
if not os.path.exists(full_generated) or os.remove(full_generated):
del_count+=1
if del_count == 3:
curr_sess.commit()
else:
curr_sess.rollback()
abort(501, status="error", message="Cannot delete one of the related file, delete was not performed")
return operation, 204
def placements(self, nickname: str) -> list:
"""
Вернуть все места из базы данных.
"""
matches = session.query(self.model, TftUserModel)\
.filter(self.model.user_id == TftUserModel.id)\
.filter(TftUserModel.nickname == nickname)\
.all()
if matches:
placements = [match[0].placement for match in matches]
return placements
raise DbRecordNotExist
def checkPermissions():
"""
Check if permission/role relationship exists in database.
if it does not, create new permission/role relationship.
if unchecked revoke permissions given to role
"""
if request.method == 'POST':
access = {}
revoked = {}
selected = []
unselected = []
values = [tuple(map(int, value.split('-'))) for value in request.form.getlist('check')]
checked = 'check' in request.form
heads = ['permission', 'role']
access_roles = session.query(perm_role).all()
# check if checked values are already in db before adding
for x in values:
if x not in access_roles:
selected.append(x)
for items in selected:
access = dict(zip(heads, items))
if selected:
role = User_Role.query.filter_by(id = access['role']).first()
perms = Perm.query.filter_by(id = access['permission']).all()
role.givePermissionsTo(perms)
# check if box is unselected and revoke permission in db
for x in access_roles:
if x not in values:
unselected.append(x)
for i in unselected:
revoked = dict(zip(heads, i))
if unselected:
xRole = User_Role.query.filter_by(id = revoked['role']).first()
xPerms = Perm.query.filter_by(id = revoked['permission']).all()
xRole.revokePermissions(xPerms)
return redirect(url_for('auth.getPermissions'))
async def employee_get(offset: int = 0,
limit: int = 10,
sort: str = '+id') -> Employees:
sort_field = sort[1:]
sort_dir = sort[0]
sort_obj = getattr(EmployeeDB, sort_field)
if sort_dir == '-':
sort_obj = sort_obj.desc()
employees = session.query(EmployeeDB) \
.order_by(sort_obj) \
.offset(offset) \
.limit(limit) \
.all()
employees = Employees(**{'employees': employees})
return employees
def get_user_alert(username):
payload = {}
alerts = []
# Check if username exists
user = session.query(User).filter(User.username == username).first()
if not user:
payload['status'] = False
payload['message'] = 'username %s does not exist.' % (username)
resp = jsonify(payload)
resp.status_code = 404
return resp
# Check every event of every rule to see if it exceeds the threshold
for rule in user.rules:
for event in rule.event:
if event.value > rule.threshold:
alerts.append({
'parameter': rule.parameter,
'value': event.value,
'threshold': rule.threshold,
'timestamp': event.timestamp
})
# Success response
payload['status'] = True
# Check if there is any alert
if not alerts:
payload['message'] = 'no alerts for the user %s.' % (username)
else:
payload['message'] = 'alerts for the user %s.' % (username)
payload['alerts'] = alerts
resp = jsonify(payload)
resp.status_code = 200
return resp
def add_event():
data = request.json
parameter = data['parameter']
value = data['value']
payload = {}
# Check if rule exists
rule = session.query(Rule).filter(Rule.parameter == parameter).first()
if not rule:
payload['status'] = False
payload['message'] = 'parameter %s does not exist.' % (parameter)
resp = jsonify(payload)
resp.status_code = 404
return resp
try:
# Add event to database
new_event = Event(value=value, rule=rule)
session.add(new_event)
session.commit()
except:
# Error saving event to database
payload['status'] = False
payload['message'] = 'error creating event.'
resp = jsonify(payload)
resp.status_code = 500
return resp
# Success response
payload['status'] = True
payload['message'] = 'event for %s with value %d created successfuly.' % (
parameter, value)
resp = jsonify(payload)
resp.status_code = 201
return resp
from app.db import session from app.models import Home print(session.query(Home).get_x())
async def read_users():
users = session.query(UserTable).all()
return users
def list_entries():
"""list journal stock entries"""
all_entries = (session.query(Stock).all())
print(earnings_controller.get_all_entries_df(all_entries))
def test_unauth(self):
with self.app:
user = session.query(User).get(1)
self.assertFalse(user.authenticated)
def get_by_username(self, username -> str):
return (
session.query(self.model)
.filter_by(get_by_username=username)
.first()
)
def get_all(self):
return session.query(self.model).all()
def post(self):
parsed_args = parser.parse_args()
original_file=parsed_args['file']
keyword=parsed_args['keyword']
# check if the post request has the file and keyword part and they are not empty and they are allowed
if original_file is None or keyword is None or not allowed_file(original_file.filename) or not allowed_file(keyword.filename):
# init array for collecting responses
response=[]
# Check if file is specified
if original_file is None:
response.append("File parameter has not been specified: Type->File")
# check if keyword is specified
if keyword is None:
response.append("Keyword parameter has not been specified: Type->File")
# check if selected files are in allowed list
if not allowed_file(original_file.filename) or not allowed_file(keyword.filename):
response.append("Uploading files only in {} format is allowed".format(ALLOWED_EXTENSIONS))
abort(400, status="fail", message=response)
# Starting of part adding trademark symbol
if original_file and keyword:
# Security check of file name
original_filename = secure_filename(original_file.filename)
extension = os.path.splitext(original_filename)[1]
# Coverting files to string
keyword_text = keyword.read().decode("utf-8")
text=original_file.read().decode("utf-8")
# Generating uniq id for saving files safely without overlaping
uniq_id=str(uuid.uuid4())
# Saving original file to upload folder with new unique name
original_file_n="original-"+uniq_id+extension
with open(os.path.join(UPLOAD_FOLDER, original_file_n), "w") as f:
f.write(text)
# Saving keyword file to upload folder with new unique name
keyword_n="keyword-"+uniq_id+extension
with open(os.path.join(UPLOAD_FOLDER, keyword_n), "w") as f:
f.write(keyword_text)
# Counter for replacement
count=0
# Looping keywords key against words of original files
for key in keyword_text.splitlines():
while key in text.split():
# with that logic also covered preventing adding trademark symbol
# if already exist
# Adding trademark symbol to the end of the word
text=text.replace(key,key+TRADEMARK_SYMBOL,1)
# increasing replacement counter
count+=1
#Saving generated file to upload folder with new unique name
generated_file_n = "generated-"+uniq_id+extension
with open(os.path.join(UPLOAD_FOLDER, generated_file_n), "w") as f:
f.write(text)
# Fetching session user
user = session.query(UserModel).filter(UserModel.user == request.authorization.username).first()
# Saving as a new operation to database
operation = OperationModel(original_filename, os.path.join(request.host_url, UPLOAD_FOLDER, original_file_n), os.path.join(request.host_url, UPLOAD_FOLDER, keyword_n), os.path.join(request.host_url, UPLOAD_FOLDER, generated_file_n), count, user.id)
OperationModel.add(operation)
return operation, 201
def get_by_email(self, email -> str):
return (
session.query(self.model)
.filter_by(email=email)
.first()
)
