def get_employee(employee_id):
"""Get the employee details against the given employee id.
:param employee_id: int - Unique identification of employee.
:return: Employee details against the given employee id.
:raises: sqlalchemy exceptions.
"""
try:
result_set = session.query(
Employee, department.Department.name
).join(
department.Department,
Employee.department_id == department.Department.department_id
).filter(
Employee.employee_id == employee_id
).one()
result = {
'employee': {
'address': result_set[0].address,
'date_of_joining': str(result_set[0].date_of_joining),
'department': result_set[1],
'employee_id': result_set[0].employee_id,
'gender': result_set[0].gender,
'name': result_set[0].name,
'salary': float(str("%0.2f" % result_set[0].salary))
}
}
return response.Response(result)
except NoResultFound:
return response.create_not_found_response(
constants.ERROR_MESSAGE_NOT_FOUND.format(
title='employee id', id=employee_id))
except (exc.SQLAlchemyError, exc.DBAPIError):
return response.create_fatal_response(
constants.ERROR_MESSAGE_INTERNAL_ERROR)
def put_employee(employee_id, payload):
"""Update the employee details against the given employee id.
:param employee_id: int - Unique identification of employee.
:param payload: json - Employee details.
:return: Success message on update of employee details.
:raises: sqlalchemy exceptions.
"""
try:
employee = {
'address': payload.get('address'),
'date_of_joining': payload.get('date_of_joining'),
'department_id': payload.get('department_id'),
'gender': payload.get('gender'),
'name': payload.get('name'),
'salary': payload.get('salary')
}
affected_row = session.query(Employee).filter(
Employee.employee_id == employee_id).update(employee)
if not affected_row:
raise NoResultFound
session.commit()
return response.Response(message=constants.UPDATE_MESSAGE.format(
module='Employee', title='employee id', id=employee_id))
except NoResultFound:
return response.create_not_found_response(
constants.ERROR_MESSAGE_NOT_FOUND.format(
title='employee id', id=employee_id))
except(exc.SQLAlchemyError, exc.DBAPIError):
return response.create_fatal_response(
constants.ERROR_MESSAGE_INTERNAL_ERROR)
def call_function_with_error_handling(*args, **kwargs):
try:
function_return = function(*args, **kwargs)
except exc.SQLAlchemyError as exception:
sentry.sentry_client.captureMessage(exception, stack=True)
return response.create_fatal_response()
return function_return
def test_flaskify_error_response():
"""Flaskify an error response.
"""
resp = flask.flaskify(response.create_fatal_response('Fatal Error'))
assert resp.status_code == 500
data = json.loads(resp.data.decode('utf8'))
assert data == {'message': 'Fatal Error', 'code': 'internal_error'}
def exception_handler(error):
"""Default handler when uncaught exception is raised.
Note: Exception will also be sent to Sentry if config.SENTRY is set.
Returns:
flask.Response: A 500 response with JSON 'code' & 'message' payload.
"""
message = ('The server encountered an internal error '
'and was unable to complete your request.')
g.log.exception(error)
return flaskify(response.create_fatal_response(message))
def get_employees(filter_data):
"""Get the employees detail against the given filter request.
:param filter_data: dict - Data for filter the result.
:return: Employees details against given filter data. Features supported
(sort / search / paginate).
:raises: sqlalchemy exceptions.
"""
try:
result = []
result_set = session.query(
Employee, department.Department.name
).prefix_with(
'SQL_CALC_FOUND_ROWS'
).join(
department.Department,
Employee.department_id == department.Department.department_id
).filter(
*fields_for_search(filter_data)
).order_by(
*fields_for_sort(filter_data)
).offset(
(int(filter_data.get('page')) - 1) *
int(filter_data.get('page_size'))
).limit(
filter_data.get('page_size')
).all()
# Calculate total number of records after filter data.
total_rows = session.execute('SELECT FOUND_ROWS()').scalar()
for employee in result_set:
result.append({
'employee_id': employee[0].employee_id,
'name': employee[0].name,
'department': employee[1],
'date_of_joining': str(employee[0].date_of_joining),
'gender': employee[0].gender,
'address': employee[0].address,
'salary': float(str("%0.2f" % employee[0].salary))
})
employees = {
'employees': result,
'page': int(filter_data.get('page')),
'page_size':
int(filter_data.get('page_size')),
'total_pages': math.ceil(
total_rows / int(filter_data.get('page_size'))) or None,
'total_records': total_rows or None,
'total_records_per_page': len(result) or None
}
return response.Response(employees)
except(exc.SQLAlchemyError, exc.DBAPIError):
return response.create_fatal_response(
constants.ERROR_MESSAGE_INTERNAL_ERROR)
def test_delete_product_live_time_details_internal_error(mocker):
"""Test delete_product_live_time_details with SQLAlchemyError."""
product_id = 12
db.insert_product_live_time_data()
mocker.patch.object(
product_live_time, 'delete_product_live_time_details',
return_value=response.create_fatal_response('fatal_error'))
delete_response = product_live_time.delete_product_live_time_details(
product_id)
assert delete_response.status == http_status.INTERNAL_ERROR
def post_department(payload):
"""Add the department details.
:param payload: json - Department details.
:return: Department details added against the given data.
:raises: sqlalchemy exceptions.
"""
try:
department = Department(name=payload.get('name'))
session.add(department)
session.commit()
# Get department details via get_department() using last inserted id.
return get_department(department.department_id)
except (exc.SQLAlchemyError, exc.DBAPIError):
return response.create_fatal_response(
constants.ERROR_MESSAGE_INTERNAL_ERROR)
def test_create_book_failure(client, headers):
"""Test create book failure."""
new_book = {
'shelf': 1,
'isbn': '978-0143122968',
'title': 'git this',
'imageUrl': 'https://image.jpg',
'author': 'linus torvalis'
}
(flexmock(book_model).should_receive('create_book').with_args(
new_book).and_return(response.create_fatal_response()).once())
result = client.post('/book', data=json.dumps(new_book), headers=headers)
assert result.status_code == 500
def delete_department(department_id):
"""Delete the department details against the given department id.
:param department_id: int - Unique identification of department.
:return: Success message on delete department details.
:raises: sqlalchemy exceptions.
"""
try:
result_set = session.query(Department). \
filter(Department.department_id == department_id).one()
session.delete(result_set)
session.commit()
return response.Response(message=constants.DELETE_MESSAGE.format(
module='Department', title='department id', id=department_id))
except NoResultFound:
return response.create_not_found_response(
constants.ERROR_MESSAGE_NOT_FOUND.format(title='department id',
id=department_id))
except (exc.SQLAlchemyError, exc.DBAPIError):
return response.create_fatal_response(
constants.ERROR_MESSAGE_INTERNAL_ERROR)
def get_departments(filter_data):
"""Get the departments detail against the given filter request.
:param filter_data: dict - Data for filter the result.
:return: Department details against given filter data. Features supported
(sort / search / paginate).
:raises: sqlalchemy exceptions.
"""
try:
result = []
result_set = session.query(Department).prefix_with(
'SQL_CALC_FOUND_ROWS').filter(
*fields_for_search(filter_data)).order_by(
*fields_for_sort(filter_data)).offset(
(int(filter_data.get('page')) - 1) *
int(filter_data.get('page_size'))).limit(
filter_data.get('page_size')).all()
# Calculate total number of records after filter data.
total_rows = session.execute('SELECT FOUND_ROWS()').scalar()
for department in result_set:
result.append({
'department_id': department.department_id,
'name': department.name
})
departments = {
'departments':
result,
'page':
int(filter_data.get('page')),
'page_size':
int(filter_data.get('page_size')),
'total_pages':
math.ceil(total_rows / int(filter_data.get('page_size'))) or None,
'total_records':
total_rows or None,
'total_records_per_page':
len(result) or None
}
return response.Response(departments)
except (exc.SQLAlchemyError, exc.DBAPIError):
return response.create_fatal_response(
constants.ERROR_MESSAGE_INTERNAL_ERROR)
def post_employee(payload):
"""Add an employee details.
:param payload: json - Employee details.
:return: Employee details added against the given data.
:raises: sqlalchemy exceptions.
"""
try:
employee = Employee(
address=payload.get('address'),
date_of_joining=payload.get('date_of_joining'),
department_id=payload.get('department_id'),
gender=payload.get('gender'),
name=payload.get('name'),
salary=payload.get('salary')
)
session.add(employee)
session.commit()
# Get employee details via get_employee() using last inserted id.
return get_employee(employee.employee_id)
except(exc.SQLAlchemyError, exc.DBAPIError):
return response.create_fatal_response(
constants.ERROR_MESSAGE_INTERNAL_ERROR)
def put_department(department_id, payload):
"""Update the department details against the given department id.
:param department_id: int - Unique identification of department.
:param payload: json - Department details.
:return: Success message on update of department details.
:raises: sqlalchemy exceptions.
"""
try:
department = {'name': payload.get('name')}
affected_row = session.query(Department).filter(
Department.department_id == department_id).update(department)
if not affected_row:
raise NoResultFound
session.commit()
return response.Response(message=constants.UPDATE_MESSAGE.format(
module='Department', title='department id', id=department_id))
except NoResultFound:
return response.create_not_found_response(
constants.ERROR_MESSAGE_NOT_FOUND.format(title='department id',
id=department_id))
except (exc.SQLAlchemyError, exc.DBAPIError):
return response.create_fatal_response(
constants.ERROR_MESSAGE_INTERNAL_ERROR)
def get_department(department_id):
"""Get the department details against the given department id.
:param department_id: int - Unique identification of department.
:return: Department details against the given department id.
:raises: sqlalchemy exceptions.
"""
try:
result_set = session.query(Department). \
filter(Department.department_id == department_id).one()
result = {
'department': {
'department_id': result_set.department_id,
'name': result_set.name
}
}
return response.Response(result)
except NoResultFound:
return response.create_not_found_response(
constants.ERROR_MESSAGE_NOT_FOUND.format(title='department id',
id=department_id))
except (exc.SQLAlchemyError, exc.DBAPIError):
return response.create_fatal_response(
constants.ERROR_MESSAGE_INTERNAL_ERROR)
