def get(self, id=None):
if id:
try:
user = db_session.query(TabUser).filter(TabUser.id == id).one()
user_schema = UserSchema().dump(user)
db_session.close()
return jsonify(user_schema)
except BaseException as exc:
return str(exc), 404
else:
users = db_session.query(TabUser).all()
users_schema = UserSchema(many=True).dump(users)
db_session.close()
return jsonify(users_schema)
def delete(self, id):
try:
# Find Association and delete
asso = db_session.query(TabUserRoles).filter(
TabUserRoles.user_id == id).all()
for item in asso:
item.delete(item)
# Delete User
user = db_session.query(TabUser).filter(TabUser.id == id).one()
user.delete(user)
return "", 200
except BaseException as exc:
return str(exc), 404
def get(self, id=None):
if id:
try:
role = db_session.query(TabRole).filter(TabRole.id == id).one()
role_schema = RolesSchema().dump(role)
db_session.close()
return jsonify(role_schema)
except BaseException as exc:
return str(exc), 404
else:
role = db_session.query(TabRole).all()
role_schema = RolesSchema(many=True).dump(role)
db_session.close()
return jsonify(role_schema)
def put(self, id):
rev_type = db_session.query(TabRevisionTypes).filter(TabRevisionTypes.id == id).first()
rev_type.name = request.json['name']
rev_type.description = request.json['description']
rev_type.expiration = request.json['expiration']
rev_type.exp_reminder = request.json['exp_reminder']
rev_type.update()
return Response(status=200)
def put(self, id):
user = db_session.query(TabUser).filter(TabUser.id == id).one()
user.autor = user_from_request(request)
roles = request.json['roles']
owned_loc = request.json['owned_loc']
# User update
user.email = request.json['email']
user.name = request.json['name']
user.surname = request.json['surname']
user.phone = request.json['phone']
user.is_enabled = request.json['is_enabled']
# TODO: Rebuild to efficient variant
# Deleting all roles from user Association table
asso = db_session.query(TabUserRoles).filter(
TabUserRoles.user_id == id).all()
for item in asso:
db_session.delete(item)
print('Deleted', item.role_id)
db_session.commit()
# Appending roles to user
for item in roles:
role = db_session.query(TabRole).filter(
TabRole.id == item['id']).first()
user.roles.append(role)
print('Appended', role.name)
# Deleting owned locations from Association table
owned_loc_asso = db_session.query(TabLocOwners).filter(
TabLocOwners.id_user == id).all()
for item in owned_loc_asso:
db_session.delete(item)
db_session.commit()
#Appending onwed_loc to user
for item in owned_loc:
location = db_session.query(TabLocation).filter(
TabLocation.id == item['id']).first()
user.owned_loc.append(location)
user.update()
return
def put(self, id):
device = db_session.query(TabRevisions).filter(
TabRevisions.id == id).first()
device.id_location = request.json['id_location']
device.id_device_type = request.json['id_device_type']
device.id_category = request.json['id_category']
device.id_acc_center = request.json['id_acc_center']
device.update()
return Response(status=200)
def get(self):
revision = db_session.query(TabRevisions) \
.join(TabDevice, TabRevisions.device) \
.join(TabRevisionTypes, TabRevisions.revision_type) \
.join(TabUser, TabRevisions.technician) \
.all()
rev_result = RevissionsSchemaEnd(many=True).dump(revision)
response = jsonify(rev_result)
print(response.json)
db_session.close()
return response
def get(self, id):
revision = db_session.query(TabRevisions, TabDevice, TabRevisionTypes, TabUser, Pricelist) \
.join(TabDevice, TabRevisions.id_device == TabDevice.id) \
.join(TabRevisionTypes, TabRevisions.id_rev == TabRevisionTypes.id) \
.join(TabUser, TabRevisions.id_technician == TabUser.id) \
.join(Pricelist,
and_(TabRevisions.id_rev == Pricelist.id_rev_type, TabDevice.id_category == Pricelist.id_cat)) \
.filter(TabRevisions.id == id).first()
schema = RevissionsSchemaEnd(many=True)
result = schema.dump(revision)
response = jsonify(result)
return Response(
response=jsonify(response),
status=200,
)
def post(self):
try:
new_rev_type = TabRevisionTypes(name=request.json['name'],
description=request.json['description'],
expiration=request.json['expiration'],
exp_reminder=request.json['exp_reminder'],
autor=1)
group = db_session.query(TabGroupOfRevTypes).filter(TabGroupOfRevTypes.id == request.json['id_group']).first()
new_rev_type.group.append(group)
print(new_rev_type)
TabRevisionTypes.add(new_rev_type)
return "", 201
except BaseException as e:
print(e)
return flask_restful.abort(409)
def get(self, id, attachment_type):
obj_revisson = db_session.query(TabRevisions)\
.join(TabDevice, TabRevisions.device)\
.join(TabLocation, TabDevice.location) \
.join(TabRevisionTypes, TabRevisions.revision_type)\
.filter(TabRevisions.id == id).first()
# Filename for export
attachment_filename = translate_rev_name(obj_revisson.device.location.name) \
+ "-" + translate_rev_name(obj_revisson.revision_type.name) \
+ "-" + attachment_type + ".pdf"
path = "D:/RevManager/UPLOAD_FILES/{0}/{1}/{2}.pdf".format(
obj_revisson.device.location.id_acc_center,
obj_revisson.device.id_acc_center,
str(obj_revisson.id) + "-" + attachment_type)
return send_file(path,
as_attachment=True,
attachment_filename=attachment_filename)
def post(self):
data = request.get_json(force=True)
email = data['email']
password = data['password']
user = db_session.query(TabUser).filter(TabUser.email == email).first()
if user == None:
response = make_response(
jsonify({"message": "invalid username/password"}))
response.status_code = 401
return response
if check_password_hash(user.password, password):
token = create_token(user)
user.lastlogin = time.strftime('%Y-%m-%d %H:%M:%S')
user.update()
return {'token': token}, 200
else:
response = make_response(
jsonify({"message": "invalid username/password"}))
response.status_code = 401
return response
def post(self):
# TODO:Ošetřit duplicity
"""
Example of User JSON for POST method:
{
"user": {
"autor": 1,
"email": "*****@*****.**",
"is_enabled": true,
"name": "Test",
"password": "******",
"phone": "123456789",
"surname": "User 3"
},
"roles": [
1,
2
]
}
"""
# Get data from JSON
global isAdded
response = request.get_json()
res_role = response['roles']
res_user = response['user']
# Deserialize JSON to Obj User over UserSchemaPut
user = UserSchemaPut().load(res_user)
user.autor = user_from_request(request)
# Appending roles to User
print(res_role)
for item in res_role:
role = db_session.query(TabRole).filter(TabRole.id == item).first()
user.roles.append(role)
# Add and commmt do DB
user.add(user)
return
def post(self):
data = json.loads(request.form['data'])
id_revision = data['id']
attachment_type = data['type']
obj_revisson = db_session.query(TabRevisions) \
.join(TabDevice, TabRevisions.device) \
.join(TabLocation, TabDevice.location) \
.join(TabRevisionTypes, TabRevisions.revision_type) \
.filter(TabRevisions.id == id_revision).first()
f = RevFile()
f.setRelativePath(loc_acc=obj_revisson.device.location.id_acc_center,
device_acc=obj_revisson.device.id_acc_center)
f.filename = str(id_revision)
# File saving Logic
if attachment_type == 'def':
rev_v = request.files['file']
f.saveFile(file=rev_v, file_type="def")
obj_revisson.rev_v = True
obj_revisson.update()
elif attachment_type == 'periodic':
rev_p = request.files['file']
f.saveFile(file=rev_p, file_type="period")
obj_revisson.rev_p = True
obj_revisson.update()
elif attachment_type == 'bug':
rev_z = request.files['file']
f.saveFile(file=rev_z, file_type="bug")
obj_revisson.rev_z = True
obj_revisson.fix_date = data['fix_date']
obj_revisson.update()
else:
pass
return "", 200
def decorated_function(*args, **kwargs):
if not request.headers.get('Authorization'):
response = jsonify(message='Missing authorization header')
response.status_code = 403
return response
try:
payload = parse_token(request)
except DecodeError:
response = jsonify(message='Token is invalid')
response.status_code = 401
return response
except ExpiredSignature:
response = jsonify(message='Token has expired')
response.status_code = 401
return response
user_id = payload['sub']
user = db_session.query(TabUser).filter_by(id=user_id).first()
roles_list = user.get_roles()
if not (roles[0] in roles_list or 'admin' in roles):
response = jsonify(message='Unauthorized role')
response.status_code = 403
return response
return f(*args, **kwargs)
def delete(self, id):
db_session.query(TabGroupOfRevTypes).filter(TabGroupOfRevTypes.id == id).delete()
db_session.commit()
return Response(status=200)
def post(self):
# try:
data = json.loads(request.form['data'])
print(data)
"""
Class for save file
f = File() # Class init
- file from request
- filename: Custom or name of file
- data from json for make PATH
PATH build style:
id_location/id_device/id_revisionTypesGroup/id_revision
"""
# Find device for recognize ACC Centre
device = db_session.query(TabDevice) \
.join(TabLocation, TabDevice.location) \
.filter(TabDevice.id == data['id_device']).first()
# Find last ID in revission for filename
last_id = db_session.query(func.max(TabRevisions.id)).scalar()
if last_id is None:
last_id = 0
f = RevFile()
f.setRelativePath(loc_acc=device.location.id_acc_center,
device_acc=device.id_acc_center)
f.filename = str(last_id + 1)
# File saving Logic
if data['file_v'] is not None:
rev_v = request.files['file_v']
f.saveFile(file=rev_v, file_type="def")
if data['file_p'] is not None:
rev_p = request.files['file_p']
f.saveFile(file=rev_p, file_type="period")
if data['file_z'] is not None:
rev_z = request.files['file_z']
f.saveFile(file=rev_z, file_type="bug")
try:
fix_date = data['fix_date']
except BaseException as exc:
print(exc)
fix_date = None
# Add to database
new_revission = TabRevisions(
realization=data['realization'],
authorize=False,
id_device=data['id_device'],
id_technician=user_from_request(request),
id_rev=data['id_revisionType'],
is_fault=data['is_fault'],
rm_authorization=data['rm_authorization_required'],
autor=user_from_request(request),
rev_v=True if data['file_v'] is not None else False,
rev_p=True if data['file_p'] is not None else False,
rev_z=True if data['file_z'] is not None else False,
fix_date=fix_date,
expiration=data['expiration'])
TabRevisions.add(new_revission)
return Response(status=201)
def get(self):
rev_type = db_session.query(TabGroupOfRevTypes).all()
schema = GroupOfRevTypesSchemaNested(many=True, only=("id", "name"))
result = schema.dump(rev_type)
response = jsonify(result)
return response
def get(self):
rev_type = db_session.query(TabRevisionTypes).all()
schema = RevisionTypesSchemaNested(many=True)
result = schema.dump(rev_type)
response = jsonify(result)
return response
def delete(self, id):
db_session.query(TabGroupRevJoin).filter(TabGroupRevJoin.id_rev_type == id).delete()
db_session.query(TabRevisionTypes).filter(TabRevisionTypes.id == id).delete()
db_session.commit()
return "", 200
def get(self, id):
rev_group = db_session.query(TabGroupOfRevTypes).filter(TabGroupOfRevTypes.id == id).first()
schema = GroupOfRevTypesSchemaNested()
result = schema.dump(rev_group)
response = jsonify(result)
return response
def test_delete(self):
rev_type = db_session.query(TabRevisionTypes).filter(
TabRevisionTypes.name == "Testovací revize").one()
delete = requests.delete(
"http://127.0.0.1:5000/api/revision_type/{0}".format(rev_type.id))
assert delete.status_code == 200
def put(self, id):
rev_group = db_session.query(TabGroupOfRevTypes).filter(TabGroupOfRevTypes.id == id).first()
rev_group.name = request.json['name']
rev_group.description = request.json['description']
rev_group.update()
return Response(status=200)
def get(self, id):
rev_type = db_session.query(TabRevisionTypes).filter(TabRevisionTypes.id == id).first()
schema = RevisionTypesSchema()
result = schema.dump(rev_type)
response = jsonify(result)
return response
def test_get(self):
rev_type = db_session.query(TabRevisionTypes).filter(
TabRevisionTypes.name == "Testovací revize").one()
assert rev_type.name == "Testovací revize"
