def get_resource(dbname, resource_name):
result = None
try:
context = log_and_extract_input(get_resource, (dbname, resource_name))
if request.method == 'GET':
fields = context.get("fields", None)
template = context.get("query_params", None)
r_table = dta.get_rdb_table(resource_name, dbname)
res = r_table.find_by_template(template, fields)
rsp = Response(json.dumps(res, default=str), status=200, content_type="application/json")
return rsp
elif request.method == 'POST':
body = context.get("body", None)
r_table = dta.get_rdb_table(resource_name, dbname)
res = r_table.insert(body)
rsp = Response(json.dumps(res, default=str), status=200, content_type="application/json")
return rsp
else:
result = "Invalid request."
return result, 400, {'Content-Type': 'text/plain; charset=utf-8'}
except Exception as e:
print("Exception e = ", e)
return handle_error(e, result)
def get_resource(dbname, resource_name):
result = None
try:
context = log_and_extract_input(get_resource, (dbname, resource_name))
dta.get_rdb_table(resource_name, dbname)
if request.method == 'GET':
if context.get('limit', None):
msg = dta.getDataByTem(resource_name, dbname, context["query_params"], context.get('fields', None),
context['limit'], context['offset'])
if len(msg) < int(context['limit']):
context['links'].remove(context['links'][1])
if len(context['links']) > 1:
msg.append(context['links'])
else:
msg = dta.getDataByTem(resource_name, dbname, context["query_params"], context.get('fields', None))
asd = json.dumps(msg, indent=4, sort_keys=True, default=str)
rsp = Response(asd, status=200, content_type="application/json")
elif request.method == 'POST':
msg = dta.insert(resource_name, dbname, context["body"])
asd = json.dumps(msg, indent=4, sort_keys=True, default=str)
rsp = Response("HTTP: 200 Entry successfully Inserted", status=200, content_type="application/json")
else:
result = "Invalid request."
return result, 400, {'Content-Type': 'text/plain; charset=utf-8'}
except Exception as e:
print("Exception e = ", e)
return handle_error(e, result)
return rsp
def resource_by_id(dbname, resource, primary_key):
"""
:param dbname: Schema/database name.
:param resource: Table name.
:param primary_key: Primary key in the form "col1_col2_..._coln" with the values of key columns.
:return: Result of operations.
"""
result = None
try:
# Parse the incoming request into an application specific format.
context = log_and_extract_input(resource_by_id,
(dbname, resource, primary_key))
#
# SOME CODE GOES HERE
#
# -- TO IMPLEMENT --
if request.method == 'GET':
fields = context.get('fields', None)
r_table = dta.get_rdb_table(resource, dbname)
key = primary_key.split(_key_delimiter)
res = r_table.find_by_primary_key(key, field_list=fields)
rsp = Response(json.dumps(res),
status=200,
content_type='application/json')
return rsp
elif request.method == 'DELETE':
fields = context.get('fields', None)
r_table = dta.get_rdb_table(resource, dbname)
key = primary_key.split(_key_delimiter)
res = r_table.delete_by_key(key)
rsp = Response(json.dumps(res),
status=200,
content_type='application/json')
return rsp
elif request.method == 'PUT':
fields = context.get('fields', None)
r_table = dta.get_rdb_table(resource, dbname)
key = primary_key.split(_key_delimiter)
update_template = context['body']
template = dict(zip(r_table.get_primary_key_columns(), key))
res = r_table.update_by_template(template, update_template)
rsp = Response(json.dumps(res),
status=200,
content_type='application/json')
return rsp
except Exception as e:
print(e)
return handle_error(e, result)
def get_resource(dbname, resource_name):
result = None
try:
context = log_and_extract_input(get_resource, (dbname, resource_name))
table = dta.get_rdb_table(table_name=resource_name, db_name=dbname)
template = context['body']
if request.method == 'GET':
if 'fields' in context.keys():
field_list = context['fields']
else:
field_list = None
result = table.find_by_template(template=template, field_list=field_list)
if len(result) > 0:
rsp = Response(json.dumps(result, default=str), status=200, content_type="application/json")
else:
rsp = Response("Not Found.", status=404, content_type="application/json")
return rsp
elif request.method == 'POST':
result = table.insert(new_record=template)
if result == 1:
rsp = Response(json.dumps(result, default=str), status=200, content_type="application/json")
else:
rsp = Response("Not Found.", status=404, content_type="application/json")
return rsp
else:
result = "Invalid request."
return result, 400, {'Content-Type': 'text/plain; charset=utf-8'}
except Exception as e:
print("Exception e = ", e)
return handle_error(e, result)
def resource_by_id(dbname, resource, primary_key):
"""
:param dbname: Schema/database name.
:param resource: Table name.
:param primary_key: Primary key in the form "col1_col2_..._coln" with the values of key columns.
:return: Result of operations.
"""
result = None
try:
# Parse the incoming request into an application specific format.
context = log_and_extract_input(resource_by_id,
(dbname, resource, primary_key))
#
table = dta.get_rdb_table(resource, dbname)
key_vals = primary_key.split('_')
fields = get_field_list(context)
#
# -- TO IMPLEMENT --
if request.method == 'GET':
#
rsp_data = table.find_by_primary_key(key_fields=key_vals,
field_list=fields)
rsp_str = json.dumps(rsp_data, indent=2, default=str)
result = Response(rsp_str,
status=200,
content_type="application/json")
return result
#
# -- TO IMPLEMENT --
elif request.method == 'DELETE':
#
rsp_data = table.delete_by_key(key_fields=key_vals)
msg = ("Number of rows deleted: \n",
json.dumps(rsp_data, indent=2, default=str))
result = Response(msg, status=200, content_type="application/json")
return result
#
# -- TO IMPLEMENT --
elif request.method == 'PUT':
#
rsp_data = table.update_by_key(key_fields=key_vals,
new_values=context['body'])
msg = ("Number of rows updated: \n",
json.dumps(rsp_data, indent=2, default=str))
result = Response(msg, status=200, content_type="application/json")
return result
#
# -- TO IMPLEMENT --
except Exception as e:
print(e)
return handle_error(e, result)
def resource_by_id(dbname, resource, primary_key):
"""
:param dbname: Schema/database name.
:param resource: Table name.
:param primary_key: Primary key in the form "col1_col2_..._coln" with the values of key columns.
:return: Result of operations.
"""
result = None
try:
# Parse the incoming request into an application specific format.
context = log_and_extract_input(resource_by_id,
(dbname, resource, primary_key))
#
# SOME CODE GOES HERE
#
# -- TO IMPLEMENT --
rdb = dta.get_rdb_table(resource, dbname)
key_fields = primary_key.split(_key_delimiter)
query_params = context.get('query_params', None)
fields = context.get('fields', None)
if request.method == 'GET':
#
# SOME CODE GOES HERE
#
# -- TO IMPLEMENT --
result = rdb.find_by_primary_key(key_fields, fields)
data = json.dumps(result, default=str)
res = Response(data, status=200, content_type='application/json')
return res
elif request.method == 'DELETE':
#
# SOME CODE GOES HERE
#
# -- TO IMPLEMENT --
result = rdb.delete_by_key(key_fields)
data = f'HTTP: 200 Successfully delete {str(result)} row(s).'
res = Response(data,
status=200,
content_type='text/plain; charset=utf-8')
return res
elif request.method == 'PUT':
#
# SOME CODE GOES HERE
#
# -- TO IMPLEMENT --
result = rdb.update_by_key(key_fields, query_params)
data = f'HTTP: 200 Successfully update {str(result)} row(s).'
res = Response(data,
status=200,
content_type='text/plain; charset=utf-8')
return res
except Exception as e:
print(e)
return handle_error(e, result)
def resource_by_id(dbname, resource, primary_key: str):
"""
:param dbname: Schema/database name.
:param resource: Table name.
:param primary_key: Primary key in the form "col1_col2_..._coln" with the values of key columns.
:return: Result of operations.
"""
result = None
try:
# Parse the incoming request into an application specific format.
context = log_and_extract_input(resource_by_id,
(dbname, resource, primary_key))
tbl = dta.get_rdb_table(table_name=resource, db_name=dbname)
ls_pks = primary_key.split("_")
field_list = get_field_list(context)
if request.method == 'GET':
result = tbl.find_by_primary_key(ls_pks, field_list=field_list)
if result is None:
data = []
status = 404
else:
data = result
status = 200
content = {"data": data, "dbname": dbname}
resp = Response(json.dumps(content),
status=status,
content_type="application/json")
return resp
elif request.method == 'DELETE':
result = tbl.delete_by_key(ls_pks)
content = {'result': result}
resp = Response(json.dumps(content),
status=200,
content_type="application/json")
return resp
elif request.method == 'PUT':
kvp_to_put = context.get("body", None)
if kvp_to_put is None:
return result, 400, {
'Content-Type': 'text/plain; charset=utf-8'
}
result = tbl.update_by_key(ls_pks, kvp_to_put)
content = {'result': result}
return Response(json.dumps(content),
status=200,
content_type="application/json")
except Exception as e:
print(e)
return handle_error(e, result)
def resource_by_id(dbname, resource, primary_key):
"""
:param dbname: Schema/database name.
:param resource: Table name.
:param primary_key: Primary key in the form "col1_col2_..._coln" with the values of key columns.
:return: Result of operations.
"""
result = None
try:
# Parse the incoming request into an application specific format.
context = log_and_extract_input(resource_by_id, (dbname, resource, primary_key))
#
# SOME CODE GOES HERE
#
# -- TO IMPLEMENT --
dta.get_rdb_table(resource, dbname)
if request.method == 'GET':
if context.get('limit', None):
msg = dta.getDataByKey(resource, dbname, primary_key.split("_"), context.get('fields', None),
context['limit'], context['offset'])
else:
msg = dta.getDataByKey(resource, dbname, primary_key.split("_"), context.get('fields', None))
asd = json.dumps(msg, indent=4, sort_keys=True, default=str)
rsp = Response(asd, status=200, content_type="application/json")
elif request.method == 'DELETE':
msg = dta.deleteDataByKey(resource, dbname, primary_key.split("_"))
asd = json.dumps(msg, indent=4, sort_keys=True, default=str)
rsp = Response("HTTP: 200 You successfully Delete" + asd + "row(s)", status=200,
content_type="application/json")
elif request.method == 'PUT':
msg = dta.updateDataByKey(resource, dbname, primary_key.split("_"), context['body'])
asd = json.dumps(msg, indent=4, sort_keys=True, default=str)
rsp = Response("HTTP: 200 You successfully Update" + asd + "row(s)", status=200,
content_type="application/json")
except Exception as e:
print(e)
return handle_error(e, result)
return rsp
def resource_by_id(dbname, resource, primary_key):
"""
:param dbname: Schema/database name.
:param resource: Table name.
:param primary_key: Primary key in the form "col1_col2_..._coln" with the values of key columns.
:return: Result of operations.
"""
result = None
try:
# Parse the incoming request into an application specific format.
context = log_and_extract_input(resource_by_id, (dbname, resource, primary_key))
if request.method == 'GET':
fields = context.get("fields", None)
r_table = dta.get_rdb_table(resource, dbname)
key = primary_key.split(_key_delimiter)
res = r_table.find_by_primary_key(key, fields)
rsp = Response(json.dumps(res, default=str), status=200, content_type="application/json")
return rsp
elif request.method == 'DELETE':
r_table = dta.get_rdb_table(resource, dbname)
key = primary_key.split(_key_delimiter)
res = r_table.delete_by_key(key)
rsp = Response(json.dumps(res, default=str), status=200, content_type="application/json")
return rsp
elif request.method == 'PUT':
body = context.get("body", None)
r_table = dta.get_rdb_table(resource, dbname)
key = primary_key.split(_key_delimiter)
res = r_table.update_by_key(key, body)
rsp = Response(json.dumps(res, default=str), status=200, content_type="application/json")
return rsp
except Exception as e:
print(e)
return handle_error(e, result)
def get_resource(dbname, resource_name):
result = None
try:
context = log_and_extract_input(get_resource, (dbname, resource_name))
tbl = dta.get_rdb_table(table_name=resource_name, db_name=dbname)
if request.method == 'GET':
template = context.get("query_params", None)
fields = get_field_list(context)
limit = context.get("limit", 5)
offset = context.get("offset", 0)
if limit is None or offset is None:
limit = 5
offset = 0
data = tbl.find_by_template(template=template,
field_list=fields,
offset=int(offset),
limit=int(limit))
original_url = context.get("url", None)
content = {
"data": data,
"links": format_links(original_url, int(limit), int(offset))
}
return Response(json.dumps(content),
status=200,
content_type="application/json")
elif request.method == 'POST':
kvp_to_put = context.get("body", None)
if kvp_to_put is None:
return result, 400, {
'Content-Type': 'text/plain; charset=utf-8'
}
result = tbl.insert(kvp_to_put)
if result == 1:
content = {
"result": result,
"msg": "Entry successfully inserted."
}
return Response(json.dumps(content),
status=201,
content_type="application/json")
else:
content = {"result": result, "msg": "Entry insertion failed."}
return Response(json.dumps(content),
status=400,
content_type="application/json")
else:
result = "Invalid request."
return result, 400, {'Content-Type': 'text/plain; charset=utf-8'}
# except Exception as e:
except TypeError as e:
print("Exception e = ", e)
return handle_error(e, result)
def resource_by_id(dbname, resource, primary_key):
"""
:param dbname: Schema/database name.
:param resource: Table name.
:param primary_key: Primary key in the form "col1_col2_..._coln" with the values of key columns.
:return: Result of operations.
"""
result = None
try:
# Parse the incoming request into an application specific format.
context = log_and_extract_input(resource_by_id,
(dbname, resource, primary_key))
body = context['body']
fields = context.get("fields", None)
r_table = dta.get_rdb_table(resource, dbname)
key = primary_key.split(_key_delimiter)
if request.method == 'GET':
result = r_table.find_by_primary_key(key, field_list=fields)
response = Response(json.dumps(result),
status=200,
content_type="application/json")
return response
elif request.method == 'DELETE':
count = r_table.get_row_count()
result = r_table.delete_by_key(key)
new = r_table.get_row_count()
response = Response(json.dumps(result),
status=200,
content_type="application/json")
return "HTTP: 410 - " + str(count -
new) + " rows successfully deleted."
elif request.method == 'PUT':
result = r_table.update_by_key(key, new_values=body)
response = Response(json.dumps(result),
status=200,
content_type="application/json")
return "HTTP: 201 - Row successfully updated."
except Exception as e:
print(e)
return handle_error(e, result)
def get_resource(dbname, resource_name):
result = None
try:
context = log_and_extract_input(get_resource, (dbname, resource_name))
#
# SOME CODE GOES HERE
#
# -- TO IMPLEMENT --
if request.method == 'GET':
fields = context.get('fields', None)
r_table = dta.get_rdb_table(resource_name, dbname)
template = context['body']
res = r_table.find_by_template(template)
rsp = Response(json.dumps(res),
status=200,
content_type='application/json')
return rsp
elif request.method == 'POST':
fields = context.get('fields', None)
r_table = dta.get_rdb_table(resource_name, dbname)
template = context['body']
res = r_table.insert(template)
rsp = Response(json.dumps(res),
status=200,
content_type='application/json')
return rsp
else:
result = "Invalid request."
return result, 400, {'Content-Type': 'text/plain; charset=utf-8'}
except Exception as e:
print("Exception e = ", e)
return handle_error(e, result)
def resource_by_id(dbname, resource, primary_key):
"""
:param dbname: Schema/database name.
:param resource: Table name.
:param primary_key: Primary key in the form "col1_col2_..._coln" with the values of key columns.
:return: Result of operations.
"""
result = None
try:
# Parse the incoming request into an application specific format.
context = log_and_extract_input(resource_by_id, (dbname, resource, primary_key))
table = dta.get_rdb_table(table_name=resource, db_name=dbname)
key_fields = primary_key.split(_key_delimiter)
if request.method == 'GET':
if 'fields' in context.keys():
field_list = context['fields']
else:
field_list = None
result = table.find_by_primary_key(key_fields=key_fields, field_list=field_list)
if result is not None:
rsp = Response(json.dumps(result, default=str), status=200, content_type="application/json")
else:
rsp = Response("Not Found.", status=404, content_type="application/json")
return rsp
elif request.method == 'DELETE':
result = table.delete_by_key(key_fields=key_fields)
if result == 1:
rsp = Response(json.dumps(result, default=str), status=200, content_type="application/json")
else:
rsp = Response("Not Found.", status=404, content_type="application/json")
return rsp
elif request.method == 'PUT':
field_list = context['body']
result = table.update_by_key(key_fields=key_fields, new_values=field_list)
if result == 1:
rsp = Response(json.dumps(result, default=str), status=200, content_type="application/json")
else:
rsp = Response("Not Found.", status=404, content_type="application/json")
return rsp
except Exception as e:
print(e)
return handle_error(e, result)
def get_resource(dbname, resource_name):
result = None
try:
context = log_and_extract_input(get_resource, (dbname, resource_name))
#
# SOME CODE GOES HERE
#
# -- TO IMPLEMENT --
rdb = dta.get_rdb_table(resource_name, dbname)
query_params = context.get('query_params', None)
fields = context.get('fields', None)
url = context.get('url', '')
limit = context.get('limit', None)
offset = context.get('offset', None)
if request.method == 'GET':
#
# SOME CODE GOES HERE
#
# -- TO IMPLEMENT --
result = rdb.find_by_template(query_params, fields, limit, offset)
links = get_links(url, limit, offset)
if links is not None:
tmp = result
result = {'response': tmp, 'links': links}
data = json.dumps(result, default=str)
res = Response(data, status=200, content_type='application/json')
return res
elif request.method == 'POST':
#
# SOME CODE GOES HERE
#
# -- TO IMPLEMENT --
rdb.insert(query_params)
result = 'HTTP: 200 Entry successfully inserted.'
return Response(result,
status=200,
content_type='text/plain; charset=utf-8')
else:
result = "Invalid request."
return result, 400, {'Content-Type': 'text/plain; charset=utf-8'}
except Exception as e:
print("Exception e = ", e)
return handle_error(e, result)
def get_resource(dbname, resource_name):
result = None
try:
context = log_and_extract_input(get_resource, (dbname, resource_name))
#
table = dta.get_rdb_table(resource_name, dbname)
template = context['query_params']
fields = get_field_list(context)
#
# -- TO IMPLEMENT --
if request.method == 'GET':
#
rsp_data = table.find_by_template(template=template,
field_list=fields)
rsp_str = json.dumps(rsp_data, indent=2, default=str)
result = Response(rsp_str,
status=200,
content_type="application/json")
return result
#
# -- TO IMPLEMENT --
elif request.method == 'POST':
#
rsp_data = table.insert(new_record=context['body'])
if rsp_data:
msg = "HTTP: 200 Entry successfully inserted"
else:
msg = "Insertion failure"
result = Response(msg, status=200, content_type="application/json")
return result
#
# -- TO IMPLEMENT --
else:
result = "Invalid request."
return result, 400, {'Content-Type': 'text/plain; charset=utf-8'}
except Exception as e:
print("Exception e = ", e)
return handle_error(e, result)
def get_resource(dbname, resource_name):
result = None
try:
context = log_and_extract_input(get_resource, (dbname, resource_name))
print(context)
body = context['body']
fields = context.get("fields", None)
r_table = dta.get_rdb_table(resource_name, dbname)
if request.method == 'GET':
result = r_table.find_by_template(template=context["query_params"],
field_list=fields)
response = Response(json.dumps(result),
status=200,
content_type="application/json")
return response
elif request.method == 'POST':
count = r_table.get_row_count()
result = r_table.insert(new_record=body)
new = r_table.get_row_count()
response = Response(json.dumps(result),
status=200,
content_type="application/json")
return "HTTP: 201 - " + str(new -
count) + " rows successfully inserted."
else:
result = "Invalid request."
return result, 400, {'Content-Type': 'text/plain; charset=utf-8'}
except Exception as e:
print("Exception e = ", e)
return handle_error(e, result)
def get_resource(dbname, resource_name):
result = None
try:
context = log_and_extract_input(get_resource, (dbname, resource_name))
query_params = context["query_params"]
#
# SOME CODE GOES HERE
#
# -- TO IMPLEMENT --
rdb_table = dta.get_rdb_table(resource_name, dbname)
data = 0
if request.method == 'GET':
#
# SOME CODE GOES HERE
#
# -- TO IMPLEMENT --
if 'offset' in query_params.keys():
rel = ['current', 'next', 'previous']
pre_href = context["url"].replace(
"offset=" + query_params['offset'], "offset=" + str(
int(query_params['offset']) -
int(query_params['limit'])))
next_href = context["url"].replace(
"offset=" + query_params['offset'], "offset=" + str(
int(query_params['offset']) +
int(query_params['limit'])))
href = [context['url'], next_href, pre_href]
rsp = [{"rel": x, "href": y} for x, y in zip(rel, href)]
data = rdb_table.find_by_template(
query_params,
field_list=(context['fields']
if 'fields' in context.keys() else None))
rsp_str = json.dumps({
"data": data,
"links": rsp
},
default=converter)
else:
data = rdb_table.find_by_template(
query_params,
field_list=(context['fields']
if 'fields' in context.keys() else None))
rsp_str = json.dumps({"data": data}, default=converter)
rsp = Response(rsp_str,
status=200,
content_type="application/json")
elif request.method == 'POST':
#
# SOME CODE GOES HERE
#
# -- TO IMPLEMENT --
res = rdb_table.insert(query_params)
if res > 0:
rsp_str = str(res) + " row is inserted"
else:
rsp_str = "No entry inserted"
rsp = Response(rsp_str, status=200, content_type="text/plain")
else:
result = "Invalid request."
return result, 400, {'Content-Type': 'text/plain; charset=utf-8'}
except Exception as e:
print("Exception e = ", e)
return handle_error(e, result)
return rsp
def t1():
t = dta.get_rdb_table('people', 'lahman2019')
print(t)
def resource_by_id(dbname, resource, primary_key):
"""
:param dbname: Schema/database name.
:param resource: Table name.
:param primary_key: Primary key in the form "col1_col2_..._coln" with the values of key columns.
:return: Result of operations.
"""
result = None
query_params = None
try:
# Parse the incoming request into an application specific format.
context = log_and_extract_input(resource_by_id,
(dbname, resource, primary_key))
#
# SOME CODE GOES HERE
#
# -- TO IMPLEMENT --
primary_key = primary_key.split('_')
rdb_table = dta.get_rdb_table(resource, dbname)
if request.method == 'GET':
#
# SOME CODE GOES HERE
#
# -- TO IMPLEMENT --
result = rdb_table.find_by_primary_key(
primary_key,
field_list=context['fields']
if 'fields' in context.keys() else None)
rsp_str = json.dumps(result, default=converter)
rsp = Response(rsp_str, status=200, content_type="text/plain")
elif request.method == 'DELETE':
#
# SOME CODE GOES HERE
#
# -- TO IMPLEMENT --
res = rdb_table.delete_by_key(primary_key)
res_str = str(res) + " row is deleted"
rsp = Response(res_str, status=200, content_type="text/plain")
elif request.method == 'PUT':
#
# SOME CODE GOES HERE
#
# -- TO IMPLEMENT --
query_params = context['query_params']
res = rdb_table.update_by_key(primary_key, query_params)
res_str = str(res) + " row is updated"
rsp = Response(res_str, status=200, content_type="text/plain")
except Exception as e:
print(e)
return handle_error(e, result)
return rsp
def test1():
t = dta.get_rdb_table("people", "lahman2019")
print(t)
