|
|
@ -22,222 +22,244 @@ |
|
|
|
|
|
|
|
|
import json |
|
|
import json |
|
|
import logging |
|
|
import logging |
|
|
from odoo import http |
|
|
|
|
|
from odoo.http import request |
|
|
from datetime import datetime |
|
|
|
|
|
from odoo import http, models |
|
|
|
|
|
from odoo.http import request, Response |
|
|
|
|
|
from ast import literal_eval |
|
|
|
|
|
|
|
|
_logger = logging.getLogger(__name__) |
|
|
_logger = logging.getLogger(__name__) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class RestApi(http.Controller): |
|
|
class IrHttp(models.AbstractModel): |
|
|
"""This is a controller which is used to generate responses based on the |
|
|
"""This model is used to authenticate the api-key when sending a request""" |
|
|
api requests""" |
|
|
_inherit = "ir.http" |
|
|
|
|
|
|
|
|
def auth_api_key(self, api_key): |
|
|
@classmethod |
|
|
|
|
|
def _auth_method_rest_api(cls): |
|
|
"""This function is used to authenticate the api-key when sending a |
|
|
"""This function is used to authenticate the api-key when sending a |
|
|
request""" |
|
|
request""" |
|
|
|
|
|
|
|
|
user_id = request.env['res.users'].search([('api_key', '=', api_key)]) |
|
|
try: |
|
|
if api_key is not None and user_id: |
|
|
api_key = request.httprequest.headers.get("Authorization").lstrip("Bearer ") |
|
|
response = True |
|
|
if not api_key: |
|
|
elif not user_id: |
|
|
raise PermissionError("Invalid API key provided.") |
|
|
response = ('<html><body><h2>Invalid <i>API Key</i> ' |
|
|
|
|
|
'!</h2></body></html>') |
|
|
user_id = request.env["res.users.apikeys"]._check_credentials( |
|
|
else: |
|
|
scope="rpc", key=api_key |
|
|
response = ("<html><body><h2>No <i>API Key</i> Provided " |
|
|
) |
|
|
"!</h2></body></html>") |
|
|
request.update_env(user_id) |
|
|
|
|
|
except Exception as e: |
|
|
|
|
|
_logger.error(e) |
|
|
|
|
|
return Response( |
|
|
|
|
|
json.dumps({"message": e.args[0]}), |
|
|
|
|
|
status=401, |
|
|
|
|
|
content_type="application/json", |
|
|
|
|
|
) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class RestApi(http.Controller): |
|
|
|
|
|
"""This is a controller which is used to generate responses based on the |
|
|
|
|
|
api requests""" |
|
|
|
|
|
|
|
|
|
|
|
def simplest_type(self, input): |
|
|
|
|
|
"""Try cast input into native Python class, otherwise return as string""" |
|
|
|
|
|
try: |
|
|
|
|
|
return literal_eval(input) |
|
|
|
|
|
except Exception: |
|
|
|
|
|
# Handle lowercase booleans |
|
|
|
|
|
if input == "true": |
|
|
|
|
|
return True |
|
|
|
|
|
if input == "false": |
|
|
|
|
|
return False |
|
|
|
|
|
return input |
|
|
|
|
|
|
|
|
return response |
|
|
def sanitize_records(self, records): |
|
|
|
|
|
"""Sanitize records for response""" |
|
|
|
|
|
for record in records: |
|
|
|
|
|
for key, value in record.items(): |
|
|
|
|
|
# Manually convert datetime fields to string format |
|
|
|
|
|
if isinstance(value, datetime): |
|
|
|
|
|
record[key] = value.isoformat() |
|
|
|
|
|
return records |
|
|
|
|
|
|
|
|
def generate_response(self, method, model, rec_id): |
|
|
def generate_response(self, method, **query): |
|
|
"""This function is used to generate the response based on the type |
|
|
"""This function is used to generate the response based on the type |
|
|
of request and the parameters given""" |
|
|
of request and the parameters given""" |
|
|
option = request.env['connection.api'].search( |
|
|
|
|
|
[('model_id', '=', model)], limit=1) |
|
|
|
|
|
model_name = option.model_id.model |
|
|
|
|
|
|
|
|
|
|
|
if method != 'DELETE': |
|
|
|
|
|
data = json.loads(request.httprequest.data) |
|
|
|
|
|
else: |
|
|
|
|
|
data = {} |
|
|
|
|
|
fields = [] |
|
|
|
|
|
if data: |
|
|
|
|
|
for field in data['fields']: |
|
|
|
|
|
fields.append(field) |
|
|
|
|
|
if not fields and method != 'DELETE': |
|
|
|
|
|
return ("<html><body><h2>No fields selected for the model" |
|
|
|
|
|
"</h2></body></html>") |
|
|
|
|
|
if not option: |
|
|
|
|
|
return ("<html><body><h2>No Record Created for the model" |
|
|
|
|
|
"</h2></body></html>") |
|
|
|
|
|
try: |
|
|
try: |
|
|
if method == 'GET': |
|
|
model = query.pop("model") |
|
|
fields = [] |
|
|
option = request.env["connection.api"].search( |
|
|
for field in data['fields']: |
|
|
[("model_id", "=", model)], limit=1 |
|
|
|
|
|
) |
|
|
|
|
|
model_name = option.model_id.model |
|
|
|
|
|
model_display_name = option.model_id.name |
|
|
|
|
|
|
|
|
|
|
|
try: |
|
|
|
|
|
data = json.loads(request.httprequest.data) |
|
|
|
|
|
except Exception: |
|
|
|
|
|
data = {} |
|
|
|
|
|
|
|
|
|
|
|
fields = [] |
|
|
|
|
|
if data: |
|
|
|
|
|
for field in data["fields"]: |
|
|
fields.append(field) |
|
|
fields.append(field) |
|
|
|
|
|
|
|
|
|
|
|
# Return records' ID by default if not specified |
|
|
|
|
|
if not fields: |
|
|
|
|
|
fields.append("id") |
|
|
|
|
|
|
|
|
|
|
|
# Get all model's fields if wildcard is used |
|
|
|
|
|
if "*" in fields: |
|
|
|
|
|
fields = [] |
|
|
|
|
|
record_fields = request.env[str(model_name)].fields_get( |
|
|
|
|
|
[], attributes=["type"] |
|
|
|
|
|
) |
|
|
|
|
|
for field, value in record_fields.items(): |
|
|
|
|
|
value_type = value.get("type") |
|
|
|
|
|
if not (value_type == "binary"): |
|
|
|
|
|
fields.append(field) |
|
|
|
|
|
if not option: |
|
|
|
|
|
raise NotImplementedError("No Record Created for the model. ") |
|
|
|
|
|
if method == "GET": |
|
|
if not option.is_get: |
|
|
if not option.is_get: |
|
|
return ("<html><body><h2>Method Not Allowed" |
|
|
raise NameError() |
|
|
"</h2></body></html>") |
|
|
limit = 0 |
|
|
else: |
|
|
if query.get("limit"): |
|
|
datas = [] |
|
|
limit = int(str(query.get("limit"))) |
|
|
if rec_id != 0: |
|
|
offset = 0 |
|
|
partner_records = request.env[ |
|
|
if query.get("offset"): |
|
|
str(model_name)].search_read( |
|
|
offset = int(str(query.get("offset"))) |
|
|
domain=[('id', '=', rec_id)], |
|
|
|
|
|
fields=fields |
|
|
domains = [] |
|
|
) |
|
|
for key, value in query.items(): |
|
|
data = json.dumps({ |
|
|
if not (key == "limit" or key == "offset"): |
|
|
'records': partner_records |
|
|
domains.append((key, "=", self.simplest_type(value))) |
|
|
}) |
|
|
partner_records = request.env[str(model_name)].search_read( |
|
|
datas.append(data) |
|
|
domains, fields, limit=limit, offset=offset |
|
|
return request.make_response(data=datas) |
|
|
) |
|
|
else: |
|
|
|
|
|
partner_records = request.env[ |
|
|
return Response( |
|
|
str(model_name)].search_read( |
|
|
json.dumps({"records": self.sanitize_records(partner_records)}), |
|
|
domain=[], |
|
|
content_type="application/json", |
|
|
fields=fields |
|
|
) |
|
|
) |
|
|
if method == "POST": |
|
|
data = json.dumps({ |
|
|
if not option.is_post: |
|
|
'records': partner_records |
|
|
raise NotImplementedError() |
|
|
}) |
|
|
if not data or "values" not in data: |
|
|
datas.append(data) |
|
|
raise ValueError("No Data Provided") |
|
|
return request.make_response(data=datas) |
|
|
|
|
|
except: |
|
|
data = json.loads(request.httprequest.data) |
|
|
return ("<html><body><h2>Invalid JSON Data" |
|
|
new_resource = request.env[str(model_name)].create(data["values"]) |
|
|
"</h2></body></html>") |
|
|
partner_records = request.env[str(model_name)].search_read( |
|
|
if method == 'POST': |
|
|
[("id", "=", new_resource.id)], fields |
|
|
if not option.is_post: |
|
|
) |
|
|
return ("<html><body><h2>Method Not Allowed" |
|
|
return Response( |
|
|
"</h2></body></html>") |
|
|
json.dumps({"new_record": self.sanitize_records(partner_records)}), |
|
|
else: |
|
|
status=201, |
|
|
try: |
|
|
content_type="application/json", |
|
|
data = json.loads(request.httprequest.data) |
|
|
) |
|
|
datas = [] |
|
|
if method == "PUT": |
|
|
new_resource = request.env[str(model_name)].create( |
|
|
if not option.is_put: |
|
|
data['values']) |
|
|
raise NotImplementedError() |
|
|
partner_records = request.env[ |
|
|
|
|
|
str(model_name)].search_read( |
|
|
if "id" not in query: |
|
|
domain=[('id', '=', new_resource.id)], |
|
|
raise ValueError("No ID Provided") |
|
|
fields=fields |
|
|
if not data or "values" not in data: |
|
|
) |
|
|
raise ValueError("No Data Provided") |
|
|
new_data = json.dumps({'New resource': partner_records, }) |
|
|
|
|
|
datas.append(new_data) |
|
|
resource_id = str(query.get("id")) |
|
|
return request.make_response(data=datas) |
|
|
resource = request.env[str(model_name)].browse(int(resource_id)) |
|
|
except: |
|
|
if not resource.exists(): |
|
|
return ("<html><body><h2>Invalid JSON Data" |
|
|
raise ValueError("Resource not found") |
|
|
"</h2></body></html>") |
|
|
|
|
|
if method == 'PUT': |
|
|
data = json.loads(request.httprequest.data) |
|
|
if not option.is_put: |
|
|
resource.write(data["values"]) |
|
|
return ("<html><body><h2>Method Not Allowed" |
|
|
partner_records = request.env[str(model_name)].search_read( |
|
|
"</h2></body></html>") |
|
|
[("id", "=", resource.id)], fields |
|
|
else: |
|
|
) |
|
|
if rec_id == 0: |
|
|
return Response( |
|
|
return ("<html><body><h2>No ID Provided" |
|
|
json.dumps( |
|
|
"</h2></body></html>") |
|
|
{"updated_record": self.sanitize_records(partner_records)} |
|
|
else: |
|
|
), |
|
|
resource = request.env[str(model_name)].browse( |
|
|
content_type="application/json", |
|
|
int(rec_id)) |
|
|
) |
|
|
if not resource.exists(): |
|
|
if method == "DELETE": |
|
|
return ("<html><body><h2>Resource not found" |
|
|
if not option.is_delete: |
|
|
"</h2></body></html>") |
|
|
raise NotImplementedError() |
|
|
else: |
|
|
|
|
|
try: |
|
|
if "id" not in query: |
|
|
datas = [] |
|
|
raise ValueError("No ID Provided") |
|
|
data = json.loads(request.httprequest.data) |
|
|
|
|
|
resource.write(data['values']) |
|
|
resource_id = str(query.get("id")) |
|
|
partner_records = request.env[ |
|
|
resource = request.env[str(model_name)].browse(int(resource_id)) |
|
|
str(model_name)].search_read( |
|
|
if not resource.exists(): |
|
|
domain=[('id', '=', resource.id)], |
|
|
raise ValueError("Resource not found") |
|
|
fields=fields |
|
|
|
|
|
) |
|
|
partner_records = request.env[str(model_name)].search_read( |
|
|
new_data = json.dumps( |
|
|
[("id", "=", resource.id)], fields |
|
|
{'Updated resource': partner_records, |
|
|
) |
|
|
}) |
|
|
resource.unlink() |
|
|
datas.append(new_data) |
|
|
return Response( |
|
|
return request.make_response(data=datas) |
|
|
json.dumps( |
|
|
|
|
|
{ |
|
|
except: |
|
|
"message": "Resource deleted", |
|
|
return ("<html><body><h2>Invalid JSON Data " |
|
|
"data": self.sanitize_records(partner_records), |
|
|
"!</h2></body></html>") |
|
|
} |
|
|
if method == 'DELETE': |
|
|
), |
|
|
if not option.is_delete: |
|
|
status=202, |
|
|
return ("<html><body><h2>Method Not Allowed" |
|
|
content_type="application/json", |
|
|
"</h2></body></html>") |
|
|
) |
|
|
else: |
|
|
|
|
|
if rec_id == 0: |
|
|
# If not using any method above, simply return an error |
|
|
return ("<html><body><h2>No ID Provided" |
|
|
raise NotImplementedError() |
|
|
"</h2></body></html>") |
|
|
except ValueError as e: |
|
|
else: |
|
|
return Response( |
|
|
resource = request.env[str(model_name)].browse( |
|
|
json.dumps({"message": e.args[0]}), |
|
|
int(rec_id)) |
|
|
status=403, |
|
|
if not resource.exists(): |
|
|
content_type="application/json", |
|
|
return ("<html><body><h2>Resource not found" |
|
|
) |
|
|
"</h2></body></html>") |
|
|
except NotImplementedError as e: |
|
|
else: |
|
|
return Response( |
|
|
|
|
|
json.dumps( |
|
|
records = request.env[ |
|
|
{ |
|
|
str(model_name)].search_read( |
|
|
"message": f"Method not allowed. {e.args[0]}Please contact your admininstrator to enable {method} method for {model_display_name or 'this'} record." |
|
|
domain=[('id', '=', resource.id)], |
|
|
} |
|
|
fields=['id', 'display_name'] |
|
|
), |
|
|
) |
|
|
status=405, |
|
|
remove = json.dumps( |
|
|
content_type="application/json", |
|
|
{"Resource deleted": records, |
|
|
) |
|
|
}) |
|
|
except Exception as e: |
|
|
resource.unlink() |
|
|
_logger.error(e) |
|
|
return request.make_response(data=remove) |
|
|
return Response( |
|
|
|
|
|
json.dumps({"message": f"Internal server error. {e.args[0]}"}), |
|
|
@http.route(['/send_request'], type='http', |
|
|
status=500, |
|
|
auth='none', |
|
|
content_type="application/json", |
|
|
methods=['GET', 'POST', 'PUT', 'DELETE'], csrf=False) |
|
|
) |
|
|
|
|
|
|
|
|
|
|
|
@http.route( |
|
|
|
|
|
["/send_request"], |
|
|
|
|
|
type="http", |
|
|
|
|
|
auth="rest_api", |
|
|
|
|
|
methods=["GET", "POST", "PUT", "DELETE"], |
|
|
|
|
|
csrf=False, |
|
|
|
|
|
) |
|
|
def fetch_data(self, **kw): |
|
|
def fetch_data(self, **kw): |
|
|
"""This controller will be called when sending a request to the |
|
|
"""This controller will be called when sending a request to the |
|
|
specified url, and it will authenticate the api-key and then will |
|
|
specified url, and it will authenticate the api-key and then will |
|
|
generate the result""" |
|
|
generate the result""" |
|
|
|
|
|
|
|
|
http_method = request.httprequest.method |
|
|
http_method = request.httprequest.method |
|
|
api_key = request.httprequest.headers.get('api-key') |
|
|
model = kw.pop("model") |
|
|
auth_api = self.auth_api_key(api_key) |
|
|
model_id = request.env["ir.model"].search([("model", "=", model)]) |
|
|
model = kw.get('model') |
|
|
|
|
|
username = request.httprequest.headers.get('login') |
|
|
|
|
|
password = request.httprequest.headers.get('password') |
|
|
|
|
|
request.session.authenticate(request.session.db, username, |
|
|
|
|
|
password) |
|
|
|
|
|
model_id = request.env['ir.model'].search( |
|
|
|
|
|
[('model', '=', model)]) |
|
|
|
|
|
if not model_id: |
|
|
if not model_id: |
|
|
return ("<html><body><h3>Invalid model, check spelling or maybe " |
|
|
return Response( |
|
|
"the related " |
|
|
json.dumps( |
|
|
"module is not installed" |
|
|
{ |
|
|
"</h3></body></html>") |
|
|
"message": "Invalid model, check spelling or maybe the related module is not installed" |
|
|
|
|
|
} |
|
|
if auth_api == True: |
|
|
), |
|
|
if not kw.get('Id'): |
|
|
status=403, |
|
|
rec_id = 0 |
|
|
content_type="application/json", |
|
|
else: |
|
|
) |
|
|
rec_id = int(kw.get('Id')) |
|
|
|
|
|
result = self.generate_response(http_method, model_id.id, rec_id) |
|
|
return self.generate_response(http_method, model=model_id.id, **kw) |
|
|
return result |
|
|
|
|
|
else: |
|
|
|
|
|
return auth_api |
|
|
|
|
|
|
|
|
|
|
|
@http.route(['/odoo_connect'], type="http", auth="none", csrf=False, |
|
|
|
|
|
methods=['GET']) |
|
|
|
|
|
def odoo_connect(self, **kw): |
|
|
|
|
|
"""This is the controller which initializes the api transaction by |
|
|
|
|
|
generating the api-key for specific user and database""" |
|
|
|
|
|
|
|
|
|
|
|
username = request.httprequest.headers.get('login') |
|
|
|
|
|
password = request.httprequest.headers.get('password') |
|
|
|
|
|
db = request.httprequest.headers.get('db') |
|
|
|
|
|
try: |
|
|
|
|
|
request.session.update(http.get_default_session(), db=db) |
|
|
|
|
|
auth = request.session.authenticate(request.session.db, username, |
|
|
|
|
|
password) |
|
|
|
|
|
user = request.env['res.users'].browse(auth) |
|
|
|
|
|
api_key = request.env.user.generate_api(username) |
|
|
|
|
|
datas = json.dumps({"Status": "auth successful", |
|
|
|
|
|
"User": user.name, |
|
|
|
|
|
"api-key": api_key}) |
|
|
|
|
|
return request.make_response(data=datas) |
|
|
|
|
|
except: |
|
|
|
|
|
return ("<html><body><h2>wrong login credentials" |
|
|
|
|
|
"</h2></body></html>") |
|
|
|
|
|
|
drpsyko101
9 months ago
GitHub
