def update_language(data):
"""Update language information .
Args:
id (int): unique identifier for the language (language_id).
data (str): dictionary record contain language_name and language_code
Returns:
response.Response: message or error.
"""
if not isinstance(data, dict) or not data:
return response.create_error_response(
error.ERROR_CODE_NOT_FOUND, 'Invalid data sent for save language.')
with mysql.db_session() as session:
update_language = session.query(ItunesLanguages) \
.get(data.get('language_id'))
if not update_language:
return response.create_error_response(
error.ERROR_CODE_NOT_FOUND,
'{} record id not found.'.format(data['language_id']))
else:
update_language.language = data.get('language_name')
update_language.language_code = data.get('language_code')
session.merge(update_language)
return response.Response(message='Data updated!!!')
def put_employee(employee_id, payload):
"""Update the employee details against the given employee id.
:param employee_id: str - Unique identification of employee.
:param payload: json - Request body.
:return: Success message on update of employee details.
"""
if not validator.is_number(employee_id):
return response.create_error_response(
code=constants.ERROR_CODE_BAD_REQUEST,
message=constants.ERROR_MESSAGE_BAD_REQUEST.format(
title='employee id', id=employee_id))
validate = validator.validate_request(payload, 'PUT', 'employee')
if validate:
return response.create_error_response(
code=constants.ERROR_CODE_BAD_REQUEST, message=validate)
return employee.put_employee(employee_id, payload)
def update_node(nodeid, paramdict):
"""Update node for passed node.
Args:
nodeid: Node ID to update for new column values as passed
paramdict: Dictionary of column:columnvalue
Returns:
response.Response: the node data for the said nodeid.
"""
if paramdict == {}:
return response.create_error_response(message='Update data invalid',
code=500)
with mysql.db_session() as session:
result_set = session.query(Node).get(nodeid)
if result_set:
for colname, colval in paramdict.items():
setattr(result_set, colname, colval)
session.merge(result_set)
response_message = response.Response(message=result_set.to_dict())
else:
return response.create_not_found_response(
'No such node found to update')
return response_message
def create_product_live_time_details(
product_id, time_of_day_product, time_zone, store_id=None):
"""Create product live time details.
Args:
product_id (int): Unique identification for product.
time_of_day_product (str): Time to product go live.
time_zone (str): Time Zone to product go live.
store_id (int): Unique identification for DMS.
Returns:
response.Response: Response dict of inserted product live time
details or error.
"""
timed_release_data = {
'product_id': product_id,
'time_of_day_product': time_of_day_product,
'time_zone': time_zone,
'store_id': store_id
}
required_fields = ['product_id', 'time_of_day_product', 'time_zone']
validation_error = validators.validate_timed_release_dataset(
timed_release_data, required_fields)
if validation_error:
return response.create_error_response(
code=error.ERROR_CODE_BAD_REQUEST, message=validation_error)
timed_release_data_to_add = ProductLiveTime(**timed_release_data)
with sql.db_session() as session:
session.add(timed_release_data_to_add)
timed_release_insert_response = {'product': timed_release_data}
return response.Response(message=timed_release_insert_response)
def update(self, source, **data):
"""Update the model from the data passed.
"""
if not source:
return response.create_error_response(
message='The source cannot be empty.')
data = utils.key_exclude(data, source.keys())
data = self.validate(data, operation=operations.READ)
if not data:
return data
# Recreate the object - check ancestors.
current = self.fetch_one(
**{key: operations.Equal(val)
for key, val in source.items()})
if not current:
return current
fields = response.Response(
message=dict(list(source.items()) + list(data.message.items())))
ancestors = self.ensure_indexes(fields, current.message)
if not ancestors:
return ancestors
return self.table.update(current, fields.message)
def put_department(department_id, payload):
"""Update the department details against the given department id.
:param department_id: str - Unique identification of department.
:param payload: json - Request body.
:return: Success message on update of department details.
"""
if not validator.is_number(department_id):
return response.create_error_response(
code=constants.ERROR_CODE_BAD_REQUEST,
message=constants.ERROR_MESSAGE_BAD_REQUEST.format(
title='department id', id=department_id))
validate = validator.validate_request(payload, 'PUT', 'department')
if validate:
return response.create_error_response(
code=constants.ERROR_CODE_BAD_REQUEST, message=validate)
return department.put_department(department_id, payload)
def update_product_by_id(data):
"""Update product data for the given product_id.
Args:
product_id (int): id product.
data (dict): dict containing product data.
e.g; {product_id : product_id, product_name : product_name, ..}
session (object): db session object, to make it transactional.
Returns:
response.Response: response object containing dict of product or error.
"""
if data == {}:
return response.create_error_response(
error.ERROR_CODE_NOT_FOUND,
'Invalid data sent for update product.')
with mysql.db_session() as session:
update_product = session.query(Product) \
.get(data.get('product_id'))
if not update_product:
return response.create_not_found_response(
'product id:{} not found.'.format(data['product_id']))
else:
update_product.product_name = data.get('product_name')
session.merge(update_product)
return response.Response(message=update_product.to_dict())
def test_custom_error_response():
"""Test creating a custom error response.
"""
error_message = 'something'
resp = response.create_error_response('code', error_message)
assert resp.errors.get('code') == 'code'
assert resp.errors.get('message') == error_message
def authenticate_and_call(*args, **kwargs):
if not is_authenticated(request.headers):
return flaskify(
response.create_error_response(
code=constants.ERROR_CODE_UNAUTHORIZED_REQUEST,
message=constants.ERROR_MESSAGE_UNAUTHORIZED_ACCESS,
status=oto_status.UNAUTHORIZED))
return func(*args, **kwargs)
def ensure_indexes(self, validation_response, current=None):
"""Ensure index unicity.
One particularity of an index: it should be unique. For example in
DynamoDb: an index has a hash and a range, combined, they represent the
key of that specific row – and thus should be unique.
If an index only has one key, that key on its own should also be
unique (e.g. user_id).
Args:
validation_response (Response): The validation response that
contains the validated fields.
current (dict): Operations such as update requires to check against
the found ancestor and the current row that needs to be
validated.
Return:
Response: The response
"""
if not validation_response:
return validation_response
data = validation_response.message
errors = {}
current = current or {}
for index in self.indexes:
# Some databases allow to have non unique indexes. In this case,
# we ignore this index for the check.
if not index.unique:
continue
keys = index.keys
query = dict()
for key in keys:
key_value = data.get(key, current.get(key))
if not key_value:
break
query.update({key: operations.Equal(key_value)})
if not query:
continue
ancestor = self.fetch_one(**query)
if ancestor:
if not current or dict(ancestor.message) != dict(current):
errors.update(
{key: exceptions.FIELD_ALREADY_USED
for key in keys})
if errors:
return response.create_error_response(
consts.ERROR_CODE_DUPLICATE_KEY, errors)
return response.Response()
def get_departments(filter_data):
"""Get the departments detail.
:param filter_data: dict - Data for filter the result.
:return: Departments detail.
"""
validate = validator.validate_filter_request(filter_data, 'department')
if validate:
return response.create_error_response(
code=constants.ERROR_CODE_BAD_REQUEST, message=validate)
return department.get_departments(filter_data)
def post_employee(payload):
"""Add an employee details.
:param payload: json - Employee details.
:return: Employee details added against the given data.
"""
validate = validator.validate_request(payload, 'POST', 'employee')
if validate:
return response.create_error_response(
code=constants.ERROR_CODE_BAD_REQUEST, message=validate)
return employee.post_employee(payload)
def post_department(payload):
"""Add the department details.
:param payload: json - Department details.
:return: Department details added against the given data.
"""
validate = validator.validate_request(payload, 'POST', 'department')
if validate:
return response.create_error_response(
code=constants.ERROR_CODE_BAD_REQUEST, message=validate)
return department.post_department(payload)
def get_employees(filter_data):
"""Get the employees detail.
:param filter_data: dict - Data for filter the result.
:return: Employees detail.
"""
validate = validator.validate_filter_request(filter_data, 'employee')
if validate:
return response.create_error_response(
code=constants.ERROR_CODE_BAD_REQUEST, message=validate)
return employee.get_employees(filter_data)
def delete_employee(employee_id):
"""Delete the employee details against the given employee id.
:param employee_id: str - Unique identification of employee.
:return: Success message on delete employee details.
"""
if not validator.is_number(employee_id):
return response.create_error_response(
code=constants.ERROR_CODE_BAD_REQUEST,
message=constants.ERROR_MESSAGE_BAD_REQUEST.format(
title='employee id', id=employee_id))
return employee.delete_employee(employee_id)
def get_department(department_id):
"""Get the department details against the given department id.
:param department_id: str - Unique identification of department.
:return: Department details against the given department id.
"""
if not validator.is_number(department_id):
return response.create_error_response(
code=constants.ERROR_CODE_BAD_REQUEST,
message=constants.ERROR_MESSAGE_BAD_REQUEST.format(
title='department id', id=department_id))
return department.get_department(department_id)
def update_product_live_time(product_id, data):
"""Update product live time details.
Args:
product_id (str): Product id to update Spotify product live time.
data (dict): Product live time data to be updated.
Returns:
response.Response: Response message upon successful update.
or error Response otherwise.
"""
if not validators.is_digit_and_non_zero(product_id):
return response.create_error_response(
code=error.ERROR_CODE_BAD_REQUEST,
message=error.ERROR_MESSAGE_INTEGER_NON_NEGATIVE.format(
product_id))
validation_error = validators.validate_timed_release_dataset(
data, data.keys())
if validation_error:
return response.create_error_response(
code=error.ERROR_CODE_BAD_REQUEST, message=validation_error)
return product_live_time.update_product_live_time_details(product_id, data)
def delete_product_live_time_details(product_id):
"""Delete product live time details by product id.
Args:
product_id (str): Product id to delete product live time details.
Returns:
response.Response: Response containing delete success message or error
response message.
"""
if not validators.is_digit_and_non_zero(product_id):
return response.create_error_response(
code=error.ERROR_CODE_BAD_REQUEST,
message=error.ERROR_MESSAGE_INTEGER_NON_NEGATIVE.format(
product_id))
return product_live_time.delete_product_live_time_details(product_id)
def health_check():
"""Health check handler.
Checks database connection. 200 if OK, otherwise 503 service unavailable.
Returns:
Response: the system status.
"""
try:
db.execute("SELECT * FROM label_status")
except SQLAlchemyError as err:
print("OS error: {0}".format(err))
return response.create_error_response(
code='Internal Server Error',
message='could not connect to psql',
status=503)
return response.Response(message={'status': 'ok'}, status=200)
def get_product_live_time_details(product_id):
"""Check if product id exist in product live table and return it.
Args:
product_id (str): Product id to fetch Spotify product live time.
Return:
response.Response: product live time details on successful fetch
or error response.
"""
if not validators.is_digit_and_non_zero(product_id):
return response.create_error_response(
code=error.ERROR_CODE_BAD_REQUEST,
message=error.ERROR_MESSAGE_INTEGER_NON_NEGATIVE.format(
product_id))
return product_live_time.get_product_live_time_details(product_id)
def get_language_by_id(language_id):
"""Get language information by language id.
Args:
language_id (int): unique identifier for the language (language_id).
Returns:
response.Response: containing dict of product or error.
"""
with mysql.db_session() as session:
ItunesLanguage = session.query(ItunesLanguages).get(language_id)
if not ItunesLanguage:
return response.create_error_response(
error.ERROR_CODE_NOT_FOUND,
'{} record id not available.'.format(language_id))
return response.Response(message=ItunesLanguage.to_dict())
def validate(self, values, operation):
"""Validate the model.
Args:
values (dict): The values to validate.
operation (int): The different operations
(correspond to schema operations).
Return:
Response.
"""
data = dict()
errors = dict()
success = False
items = set(values.keys())
if operation is operations.READ and not values:
return response.Response()
if operation is operations.CREATE:
items = set(self.fields.keys())
for name in items:
field = self.fields.get(name)
if not field:
continue
try:
value = values.get(name)
if isinstance(value, operations.Base):
value = value.validate(field)
data[name] = value
continue
data[name] = field.validate(value)
except exceptions.FieldException as e:
errors[name] = e.args[0]
status = False
if errors:
return response.create_error_response(consts.ERROR_CODE_VALIDATION,
errors)
return response.Response(message=data)
def create_node(paramdict):
"""Update node for passed node id.
Args:
paramdict: Dictionary column value pairs to be added as a row
Returns:
response.Response: the node
"""
if paramdict is None or 'name' not in paramdict or 'surname' \
not in paramdict:
return response.create_error_response(
message='Name and surname is mandatory', code=500)
with mysql.db_session() as session:
new_node = Node(name=paramdict.get('name'),
surname=paramdict.get('surname'))
session.add(new_node)
response_message = response.Response(message=paramdict)
return response_message
def search_for_books(search_term, search_category):
"""Search for a book."""
with mysql_connector.db_session() as session:
if search_category == 'isbn':
results = session.query(LibraryBook).filter(
LibraryBook.ISBN.contains(search_term)).limit(20)
elif search_category == 'title':
results = session.query(LibraryBook).filter(
LibraryBook.BOOK_TITLE.contains(search_term)).limit(20)
elif search_category == 'author':
results = session.query(LibraryBook).filter(
LibraryBook.BOOK_AUTHOR.contains(search_term)).limit(20)
else:
return response.create_error_response(400,
'Invalid Search Category')
results_data = []
for book in results:
results_data.append(book.to_dict())
return response.Response(results_data)
def create_product_live_time_detail():
"""Save info about product live time detail.
Returns:
flask.Response: Response contains dict describing product live time
details, or validation message.
"""
valid_request_json = True
try:
timed_release_data = request.get_json()
if not isinstance(timed_release_data, dict):
valid_request_json = False
except BadRequest:
valid_request_json = False
if not valid_request_json:
return flaskify(response.create_error_response(
code=error.ERROR_CODE_BAD_REQUEST,
message=error.ERROR_MESSAGE_INVALID_REQUEST_BODY))
return flaskify(product_live_time.create_product_live_time_detail(
timed_release_data))
def test_create_product_live_time_detail_failure(description, product_id,
time_of_day_product,
time_zone, store_id,
expected_response,
monkeypatch):
"""Test for create product live time detail with failure."""
request_body = {
'product_id': product_id,
'time_of_day_product': time_of_day_product,
'time_zone': time_zone,
'store_id': store_id
}
monkeypatch.setattr(
product_live_time, 'create_product_live_time_detail',
MagicMock(return_value=response.create_error_response(
code=error.ERROR_CODE_BAD_REQUEST, message=expected_response)))
with app.test_client() as client:
result = client.post('/product',
data=json.dumps(request_body),
content_type='application/json')
assert result.status_code == http_status.BAD_REQUEST
