def add_request():
"""This function adds a request from a client."""
json_values = request.json
values_required = {
"address", "date", "time", "trouble", "idMemberATE", "idService"
}
response = Response(json.dumps(
json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value,
mimetype="application/json")
if all(key in json_values for key in values_required):
if validator_request.is_valid(json_values):
request_add = Request()
request_add.address = json_values["address"]
request_add.date = json_values["date"]
request_add.time = json_values["time"]
request_add.trouble = json_values["trouble"]
request_add.id_member_ate = json_values["idMemberATE"]
request_add.id_service = json_values["idService"]
result = request_add.add_request()
if result == ResponsesREST.CREATED.value:
response = Response(json.dumps(request_add.json_request()),
status=ResponsesREST.CREATED.value,
mimetype="application/json")
else:
response = Response(json.dumps(json_error(result)),
status=result,
mimetype="application/json")
return response
def add_service():
"""This function adds a service."""
json_values = request.json
values_required = {
"name", "description", "slogan", "typeService", "workingHours",
"minimalCost", "maximumCost", "idCity", "idMemberATE"
}
response = Response(json.dumps(
json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value,
mimetype="application/json")
if all(key in json_values for key in values_required):
if validator_service.is_valid(json_values):
service_add = Service()
service_add.name = json_values["name"]
service_add.description = json_values["description"]
service_add.slogan = json_values["slogan"]
service_add.type_service = json_values["typeService"]
service_add.working_hours = json_values["workingHours"]
service_add.minimal_cost = json_values["minimalCost"]
service_add.maximum_cost = json_values["maximumCost"]
service_add.id_city = json_values["idCity"]
service_add.id_member_ate = json_values["idMemberATE"]
result = service_add.add_service()
if result == ResponsesREST.CREATED.value:
response = Response(json.dumps(service_add.json_service()),
status=ResponsesREST.CREATED.value,
mimetype="application/json")
else:
response = Response(json.dumps(json_error(result)),
status=result,
mimetype="application/json")
return response
def get_reports(filter_search, criterion):
"""This function get a report according to criterion: memberATE, service, date ."""
response = Response(json.dumps(
json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value,
mimetype="application/json")
if validator_get_reports.is_valid({
"filterSearch": filter_search,
"criterion": criterion
}):
get_report = Report()
result = get_report.consult_list_reports(filter_search, criterion)
if result in (ResponsesREST.INVALID_INPUT.value,
ResponsesREST.NOT_FOUND.value,
ResponsesREST.SERVER_ERROR.value):
response = Response(json.dumps(json_error(result)),
status=result,
mimetype="application/json")
else:
list_reports = []
for reports_found in result:
list_reports.append(reports_found.json_report())
response = Response(json.dumps(list_reports),
status=ResponsesREST.SUCCESSFUL.value,
mimetype="application/json")
return response
def find_services_city_filter(filter_search, criterion, id_city):
"""This function obtains the list of services of a city according to the following criteria:
typeService, name, minimalCost or maximumCost."""
response = Response(json.dumps(
json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value,
mimetype="application/json")
if validator_find_services_city.is_valid({
"filterSearch": filter_search,
"criterion": criterion,
"idCity": id_city
}):
get_services = Service()
get_services.id_city = id_city
result = get_services.consult_list_services_city(
filter_search, criterion)
if result in (ResponsesREST.INVALID_INPUT.value,
ResponsesREST.SERVER_ERROR.value,
ResponsesREST.NOT_FOUND.value):
response = Response(json.dumps(json_error(result)),
status=result,
mimetype="application/json")
else:
list_services = []
for service_found in result:
list_services.append(service_found.json_service())
response = Response(json.dumps(list_services),
status=ResponsesREST.SUCCESSFUL.value,
mimetype="application/json")
return response
def get_chats(id_member, member_type):
"""This function fetches a memberATE's chats."""
json_validator = {"idMember": id_member, "memberType": member_type}
response = Response(json.dumps(
json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value,
mimetype="application/json")
if validator_find_chats.is_valid(json_validator):
get_chat = Chat()
get_chat.id_member_ate = id_member
result = get_chat.find_chats(member_type)
if result in (ResponsesREST.NOT_FOUND.value,
ResponsesREST.SERVER_ERROR.value,
ResponsesREST.INVALID_INPUT.value):
response = Response(json.dumps(json_error(result)),
status=result,
mimetype="application/json")
else:
list_chat = []
for chats_found in result:
list_chat.append(chats_found.json_chat())
response = Response(json.dumps(list_chat),
status=ResponsesREST.SUCCESSFUL.value,
mimetype="application/json")
return response
def find_requests(request_status, filter_search, criterion):
"""This function retrieves the list of requests from the service or memberATE criterion."""
json_validator = {
"requestStatus": request_status,
"filterSearch": filter_search,
"criterion": criterion
}
response = Response(json.dumps(
json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value,
mimetype="application/json")
if validator_find_request.is_valid(json_validator):
get_request = Request()
result = get_request.find_request(request_status, filter_search,
criterion)
if result in (ResponsesREST.NOT_FOUND.value,
ResponsesREST.SERVER_ERROR.value,
ResponsesREST.INVALID_INPUT.value):
response = Response(json.dumps(json_error(result)),
status=result,
mimetype="application/json")
else:
list_requests = []
for request_found in result:
list_requests.append(request_found.json_request())
response = Response(json.dumps(list_requests),
status=ResponsesREST.SUCCESSFUL.value,
mimetype="application/json")
return response
def create_token():
"""This function logs in and generates the access token."""
json_values = request.json
values_required = {"username", "password"}
response = Response(json.dumps(json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value, mimetype="application/json")
if all(key in json_values for key in values_required):
if validator_login.is_valid(json_values):
account_login = Account()
account_login.username = json_values["username"]
account_login.password = encode_password(json_values["password"])
account_login.member_ate_status = AccountStatus.ACTIVE.value
result = account_login.login()
if result in (ResponsesREST.SERVER_ERROR.value, ResponsesREST.NOT_FOUND.value,
ResponsesREST.INVALID_REQUEST.value):
response = Response(json.dumps(json_error(result)),
status=result,
mimetype="application/json")
else:
account_login.member_ate_type = result.member_ate_type
account_login.id_member_ate = result.id_member_ate
account_login.id_city = result.id_city
token = Auth.generate_token(account_login)
session.permanent = True
session["token"] = token
response = Response(json.dumps({"token": token,
"memberATEType": account_login.member_ate_type,
"idMemberATE": account_login.id_member_ate,
"idCity": account_login.id_city}),
status=ResponsesREST.CREATED.value, mimetype="application/json")
return response
def send_message_to_email():
"""This function sends a message to an email with the reason for its blocking, unblocking."""
json_values = request.json
values = {"email", "messageSend"}
response = Response(json.dumps(
json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value,
mimetype="application/json")
if all(key in json_values for key in values):
if validator_email_account.is_valid(json_values):
result = Email.send_message_email(json_values["messageSend"],
json_values["email"])
if result == ResponsesREST.CREATED.value:
response = Response(json.dumps({
"email":
json_values["email"],
"messageSend":
json_values["messageSend"]
}),
status=result,
mimetype="application/json")
else:
response = Response(json.dumps(json_error(result)),
status=result,
mimetype="application/json")
return response
def delete_resource(route):
"""This function removes a resource from a user or service."""
response = Response(json.dumps(
json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value,
mimetype="application/json")
resource_delete = Resource()
resource_delete.route_save = route
result = resource_delete.delete_resource_server()
if result in (ResponsesREST.SERVER_ERROR.value,
ResponsesREST.NOT_FOUND.value):
response = Response(json.dumps(json_error(result)),
status=result,
mimetype="application/json")
else:
response = Response(status=result)
return response
def validate_account():
"""This function validates an account so that you can log in."""
json_values = request.json
values_required = {"username", "password", "code"}
response = Response(json.dumps(json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value, mimetype="application/json")
if all(key in json_values for key in values_required):
if validator_login_validator.is_valid(json_values):
account_login = Account()
account_login.username = json_values["username"]
account_login.password = encode_password(json_values["password"])
result = account_login.validate_account(json_values["code"])
if result == ResponsesREST.SUCCESSFUL.value:
response = Response(status=result)
else:
response = Response(json.dumps(json_error(result)),
status=result, mimetype="application/json")
return response
def add_employee_account(id_account):
"""This function adds the type of user employed to an already created account."""
response = Response(json.dumps(
json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value,
mimetype="application/json")
if validator_id.is_valid({"id": id_account}):
account_status = Account()
account_status.id_member_ate = id_account
account_status.member_ate_type = AccountRole.CLIENT_EMPLOYEE.value
result = account_status.add_employee_account()
if result == ResponsesREST.SUCCESSFUL.value:
response = Response(status=result)
else:
response = Response(json.dumps(json_error(result)),
status=result,
mimetype="application/json")
return response
def validate_change_password():
"""This function changes the password of an account based on the
confirmation code."""
json_values = request.json
values_required = {"email", "password", "code"}
response = Response(json.dumps(json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value, mimetype="application/json")
if all(key in json_values for key in values_required):
if validator_login_password.is_valid(json_values):
account_login = Account()
account_login.email = json_values["email"]
account_login.password = encode_password(json_values["password"])
result = account_login.validate_change_password(json_values["code"])
if result == ResponsesREST.SUCCESSFUL.value:
response = Response(status=result)
else:
response = Response(json.dumps(json_error(result)),
status=result, mimetype="application/json")
return response
def get_state_by_id(state_id):
"""This function returns a status according to its ID."""
response = Response(json.dumps(
json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value,
mimetype="application/json")
if validator_id.is_valid({"id": state_id}):
state_get = State()
state_get.id_state = state_id
result = state_get.get_state()
if result in (ResponsesREST.NOT_FOUND.value,
ResponsesREST.SERVER_ERROR.value):
response = Response(json.dumps(json_error(result)),
status=result,
mimetype="application/json")
else:
response = Response(json.dumps(result.json_state()),
status=ResponsesREST.SUCCESSFUL.value,
mimetype="application/json")
return response
def find_resource_main_member_ate(member_ate_id):
"""This function retrieves the main resource of a memberATE."""
response = Response(json.dumps(
json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value,
mimetype="application/json")
if validator_id.is_valid({'id': member_ate_id}):
get_resources_member = Resource()
get_resources_member.id_member_ate = member_ate_id
result = get_resources_member.get_main_resource_account()
if result in (ResponsesREST.NOT_FOUND.value,
ResponsesREST.SERVER_ERROR.value):
response = Response(json.dumps(json_error(result)),
status=result,
mimetype="application/json")
else:
response = Response(json.dumps(result.json_resource()),
status=ResponsesREST.SUCCESSFUL.value,
mimetype="application/json")
return response
def get_country_by_id(country_id):
"""This function gets a country according to its ID."""
response = Response(json.dumps(
json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value,
mimetype="application/json")
if validator_id.is_valid({"id": country_id}):
country_get = Country()
country_get.id_country = country_id
result = country_get.get_country()
if result in (ResponsesREST.NOT_FOUND.value,
ResponsesREST.SERVER_ERROR.value):
response = Response(json.dumps(json_error(result)),
status=result,
mimetype="application/json")
else:
response = Response(json.dumps(result.json_country()),
status=ResponsesREST.SUCCESSFUL.value,
mimetype="application/json")
return response
def get_report_by_id(report_id):
"""This function get a report according to its ID."""
response = Response(json.dumps(
json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value,
mimetype="application/json")
if validator_id.is_valid({"id": report_id}):
report_get = Report()
report_get.id_report = report_id
result = report_get.consult_report()
if result in (ResponsesREST.NOT_FOUND.value,
ResponsesREST.SERVER_ERROR.value):
response = Response(json.dumps(json_error(result)),
status=result,
mimetype="application/json")
else:
response = Response(json.dumps(result.json_report()),
status=ResponsesREST.SUCCESSFUL.value,
mimetype="application/json")
return response
def send_message_to_account():
"""This function updates the verification code and sends it to the email."""
json_values = request.json
values = {"email"}
response = Response(json.dumps(
json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value,
mimetype="application/json")
if all(key in json_values for key in values):
if validator_email.is_valid(json_values):
account = Account()
account.email = json_values["email"]
result = account.change_code(create_code())
if result == ResponsesREST.SUCCESSFUL.value:
response = Response(json.dumps({"email": account.email}),
status=result,
mimetype="application/json")
else:
response = Response(json.dumps(json_error(result)),
status=result,
mimetype="application/json")
return response
def add_resource():
"""This function adds a resource to a user or service."""
resource_save = request.form
values_required = {"isMainResource", "name", "idService", "idMemberATE"}
response = response = Response(json.dumps(
json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value,
mimetype="application/json")
if all(key in resource_save for key in values_required):
resource_add = request.files.getlist("resourceFile")
validator = {
"isMainResource": resource_save["isMainResource"],
"name": resource_save["name"],
"idService": int(resource_save["idService"]),
"idMemberATE": int(resource_save["idMemberATE"]),
"ext": resource_add[0].filename.split(".")[-1]
}
if validator_resource.is_valid(validator):
if resource_add:
resource_server = Resource()
resource_server.is_main_resource = resource_save[
"isMainResource"]
resource_server.name = resource_save["name"]
resource_server.id_service = int(resource_save["idService"])
resource_server.id_member_ate = int(
resource_save["idMemberATE"])
resource_server.resource_file = resource_add[0]
result = resource_server.add_resource_server()
if result == ResponsesREST.CREATED.value:
response = Response(json.dumps(
resource_server.json_resource()),
status=ResponsesREST.CREATED.value,
mimetype="application/json")
else:
response = Response(json.dumps(json_error(result)),
status=result,
mimetype="application/json")
return response
def find_services_employee(id_member_ate):
"""This function gets the list of services for an employee."""
response = Response(json.dumps(
json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value,
mimetype="application/json")
if validator_id.is_valid({"id": id_member_ate}):
get_services = Service()
get_services.id_member_ate = id_member_ate
result = get_services.get_services_employee()
if result in (ResponsesREST.SERVER_ERROR.value,
ResponsesREST.NOT_FOUND.value):
response = Response(json.dumps(json_error(result)),
status=result,
mimetype="application/json")
else:
list_services = []
for service_found in result:
list_services.append(service_found.json_service())
response = Response(json.dumps(list_services),
status=ResponsesREST.SUCCESSFUL.value,
mimetype="application/json")
return response
def find_resources(service_id):
"""This function retrieves the resources of a service."""
response = Response(json.dumps(
json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value,
mimetype="application/json")
if validator_id.is_valid({'id': service_id}):
get_resources_service = Resource()
get_resources_service.id_service = service_id
result = get_resources_service.get_resource_list()
if result in (ResponsesREST.NOT_FOUND.value,
ResponsesREST.SERVER_ERROR.value):
response = Response(json.dumps(json_error(result)),
status=result,
mimetype="application/json")
else:
list_resources = []
for resource_found in result:
list_resources.append(resource_found.json_resource())
response = Response(json.dumps(list_resources),
status=ResponsesREST.SUCCESSFUL.value,
mimetype="application/json")
return response
def add_city():
"""This function adds a city to a state in the database."""
json_values = request.json
values_required = {"name", "idState"}
response = Response(json.dumps(
json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value,
mimetype="application/json")
if all(key in json_values for key in values_required):
if validator_city.is_valid(json_values):
city_add = City()
city_add.name = json_values["name"]
city_add.id_state = json_values["idState"]
result = city_add.add_city()
if result == ResponsesREST.CREATED.value:
response = Response(json.dumps(city_add.json_city()),
status=ResponsesREST.CREATED.value,
mimetype="application/json")
else:
response = Response(json.dumps(json_error(result)),
status=result,
mimetype="application/json")
return response
def get_cities(id_state):
"""This function gets all the cities in a state."""
response = Response(json.dumps(
json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value,
mimetype="application/json")
if validator_id.is_valid({"id": id_state}):
get_city = City()
get_city.id_state = id_state
result = get_city.find_cities()
if result in (ResponsesREST.NOT_FOUND.value,
ResponsesREST.SERVER_ERROR.value):
response = Response(json.dumps(json_error(result)),
status=result,
mimetype="application/json")
else:
list_cities = []
for cities_found in result:
list_cities.append(cities_found.json_city())
response = Response(json.dumps(list_cities),
status=ResponsesREST.SUCCESSFUL.value,
mimetype="application/json")
return response
def find_requests_service(service_id):
"""This function retrieves the list of requests from the service."""
response = Response(json.dumps(
json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value,
mimetype="application/json")
if validator_id.is_valid({"id": service_id}):
get_request = Request()
result = get_request.find_request_service(service_id)
if result in (ResponsesREST.NOT_FOUND.value,
ResponsesREST.SERVER_ERROR.value,
ResponsesREST.INVALID_INPUT.value):
response = Response(json.dumps(json_error(result)),
status=result,
mimetype="application/json")
else:
list_requests = []
for request_found in result:
list_requests.append(request_found.json_request())
response = Response(json.dumps(list_requests),
status=ResponsesREST.SUCCESSFUL.value,
mimetype="application/json")
return response
def get_states(id_country):
"""This function returns all the states of a city."""
response = Response(json.dumps(
json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value,
mimetype="application/json")
if validator_id.is_valid({"id": id_country}):
get_state = State()
get_state.id_country = id_country
result = get_state.find_states()
if result in (ResponsesREST.NOT_FOUND.value,
ResponsesREST.SERVER_ERROR.value):
response = Response(json.dumps(json_error(result)),
status=result,
mimetype="application/json")
else:
list_states = []
for states_found in result:
list_states.append(states_found.json_state())
response = Response(json.dumps(list_states),
status=ResponsesREST.SUCCESSFUL.value,
mimetype="application/json")
return response
def get_messages(id_chat):
"""This function get a messages from a chat."""
response = Response(json.dumps(
json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value,
mimetype="application/json")
if validator_id.is_valid({"id": id_chat}):
get_message = Message()
get_message.id_chat = id_chat
result = get_message.get_messages_list()
if result in (ResponsesREST.NOT_FOUND.value,
ResponsesREST.SERVER_ERROR.value):
response = Response(json.dumps(json_error(result)),
status=result,
mimetype="application/json")
else:
list_chat = []
for message_found in result:
list_chat.append(message_found.json_message())
response = Response(json.dumps(list_chat),
status=ResponsesREST.SUCCESSFUL.value,
mimetype="application/json")
return response
def change_status(service_id):
"""This function changes the status of a service, 1 active, 2 inactive, 3 blocked."""
json_values = request.json
values_required = {"serviceStatus"}
response = Response(json.dumps(
json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value,
mimetype="application/json")
if all(key in json_values for key in values_required):
json_validator = json_values
json_validator["idService"] = service_id
if validator_change_status_service.is_valid(json_validator):
service_change_status = Service()
service_change_status.id_service = service_id
service_change_status.service_status = json_values["serviceStatus"]
result = service_change_status.change_status()
if result == ResponsesREST.SUCCESSFUL.value:
response = Response(status=result)
else:
response = Response(json.dumps(json_error(result)),
status=result,
mimetype="application/json")
return response
def add_report():
"""This function add a report a service."""
json_values = request.json
values_required = {"reason", "idService", "idMemberATE"}
response = Response(json.dumps(
json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value,
mimetype="application/json")
if all(key in json_values for key in values_required):
if validator_report.is_valid(json_values):
report_add = Report()
report_add.reason = json_values["reason"]
report_add.id_service = json_values["idService"]
report_add.id_member_ate = json_values["idMemberATE"]
result = report_add.add_report()
if result == ResponsesREST.CREATED.value:
response = Response(json.dumps(report_add.json_report()),
status=ResponsesREST.CREATED.value,
mimetype="application/json")
else:
response = Response(json.dumps(json_error(result)),
status=result,
mimetype="application/json")
return response
def get_image(route):
"""This function retrieves an image according to its path."""
resource_get = Resource()
resource_get.route_save = route
result = resource_get.get_resource_server()
if result in (ResponsesREST.NOT_FOUND.value,
ResponsesREST.SERVER_ERROR.value):
response = Response(json.dumps(json_error(result)),
status=result,
mimetype="application/json")
else:
response = send_file(io.BytesIO(result.resourceFile),
mimetype="image/png",
as_attachment=False)
return response
def add_message():
"""This function add a message to chat."""
json_values = request.json
values_required = {"message", "idChat", "memberType"}
response = Response(json.dumps(
json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value,
mimetype="application/json")
if all(key in json_values for key in values_required):
if validator_message.is_valid(json_values):
message_add = Message()
message_add.message = json_values["message"]
message_add.id_chat = json_values["idChat"]
message_add.member_type = json_values["memberType"]
result = message_add.add_message()
if result == ResponsesREST.CREATED.value:
response = Response(json.dumps(message_add.json_message()),
status=ResponsesREST.CREATED.value,
mimetype="application/json")
else:
response = Response(json.dumps(json_error(result)),
status=result,
mimetype="application/json")
return response
def change_service(service_id):
"""This function changes all the data of a service according to its ID."""
json_values = request.json
values_required = {
"name", "description", "slogan", "typeService", "workingHours",
"minimalCost", "maximumCost", "idCity", "idMemberATE"
}
response = Response(json.dumps(
json_error(ResponsesREST.INVALID_INPUT.value)),
status=ResponsesREST.INVALID_INPUT.value,
mimetype="application/json")
if all(key in json_values for key in values_required):
json_validator = json_values
json_validator["idService"] = int(service_id)
if validator_service.is_valid(json_validator):
service_change = Service()
service_change.id_service = int(service_id)
service_change.name = json_values["name"]
service_change.description = json_values["description"]
service_change.slogan = json_values["slogan"]
service_change.type_service = json_values["typeService"]
service_change.working_hours = json_values["workingHours"]
service_change.minimal_cost = json_values["minimalCost"]
service_change.maximum_cost = json_values["maximumCost"]
service_change.id_city = json_values["idCity"]
service_change.id_member_ate = int(json_values["idMemberATE"])
result = service_change.change_service()
if result == ResponsesREST.SUCCESSFUL.value:
response = Response(json.dumps(service_change.json_service()),
status=ResponsesREST.SUCCESSFUL.value,
mimetype="application/json")
else:
response = Response(json.dumps(json_error(result)),
status=result,
mimetype="application/json")
return response
