def get_model_rec(self, model, rec_id, **params):
try:
records = request.env[model].search([])
except KeyError as e:
msg = "The model `%s` does not exist." % model
res = error_response(e, msg)
return http.Response(json.dumps(res),
status=200,
mimetype='application/json')
if "query" in params:
query = params["query"]
else:
query = "{*}"
# TODO: Handle the error raised by `ensure_one`
record = records.browse(rec_id).ensure_one()
try:
serializer = Serializer(record, query)
data = serializer.data
except (SyntaxError, QueryFormatError) as e:
res = error_response(e, e.msg)
return http.Response(json.dumps(res),
status=200,
mimetype='application/json')
return http.Response(json.dumps(data),
status=200,
mimetype='application/json')
def delete_model_records(self, model, **post):
filters = json.loads(post["filter"])
try:
model_to_del_rec = request.env[model]
except KeyError as e:
msg = "The model `%s` does not exist." % model
res = error_response(e, msg)
return http.Response(json.dumps(res),
status=200,
mimetype='application/json')
# TODO: Handle error raised by `filters`
recs = model_to_del_rec.search(filters)
try:
is_deleted = recs.unlink()
res = {"result": is_deleted}
return http.Response(json.dumps(res),
status=200,
mimetype='application/json')
except Exception as e:
res = error_response(e, str(e))
return http.Response(json.dumps(res),
status=200,
mimetype='application/json')
def get_binary_record(self, model, rec_id, field, **post):
try:
request.env[model]
except KeyError as e:
msg = "The model `%s` does not exist." % model
res = error_response(e, msg)
return http.Response(json.dumps(res),
status=200,
mimetype='application/json')
rec = request.env[model].browse(rec_id).ensure_one()
if rec.exists():
src = getattr(rec, field).decode("utf-8")
else:
src = False
return http.Response(src)
def get_category_slider_data(self):
"""
It's return the updated category slider data through ajax
:return: category slider template html
"""
response = http.Response(
template="emipro_theme_base.category_slider_container")
return response.render()
def get_brand_slider_data(self):
"""
It's return the updated brand data through ajax
:return: brand slider template html
"""
response = http.Response(
template="emipro_theme_base.brand_slider_container")
return response.render()
def get_template_html(self, style_id, values):
template_id = request.env['slider.styles'].browse(
int(style_id)).get_external_id().get(int(style_id)) + "_template"
template = request.env['ir.ui.view'].sudo().search([('key', '=',
template_id)])
if template:
response = http.Response(template=template_id, qcontext=values)
return response.render()
def slider_preview(self, rec_id, **kwargs):
"""
Return The Slider Preview template
:param rec_id:
:param kwargs:
:return:
"""
return http.Response(template="emipro_theme_base.slider_preview",
qcontext={
'rec_id': rec_id
}).render()
def slider_data(self, **kwargs):
"""
Return the data for slider for product slider and category Slider
If filter ID is not specified then return first filter slider object else it return specified slider filter
:param kwargs:
:return:
"""
slider_id = kwargs.get('slider_id', False)
filter_id = kwargs.get('filter_id', False)
slider_obj = request.env['slider'].sudo().search([('id', '=',
int(slider_id))])
vals = {}
if slider_obj:
filter = slider_obj.slider_filter_ids[
0] if not filter_id else request.env['slider.filter'].sudo(
).search([('id', '=', int(filter_id))])
if filter.filter_id.domain:
domain = safe_eval(filter.filter_id.domain)
domain += [
'|', ('website_id', '=', None),
('website_id', '=', request.website.id),
('website_published', '=', True)
]
product = request.env['product.template'].sudo().search(
domain, limit=slider_obj.slider_limit)
vals = {
'slider_obj':
slider_obj,
'filter_data':
product,
# 'active_filter_data': filter_id if filter_id else slider_obj.slider_filter_ids[0].filter_id.id,
'active_filter_data':
filter_id
if filter_id else slider_obj.slider_filter_ids[0].id,
'is_default':
False if filter_id else True,
'show_view_all':
True
}
tmplt_external_id = slider_obj.slider_style_id.get_external_id(
).get(slider_obj.slider_style_id.id) + "_template"
tmplt = request.env['ir.ui.view'].sudo().search([
('key', '=', tmplt_external_id)
])
if tmplt:
response = http.Response(template=tmplt_external_id,
qcontext=vals)
return response.render()
else:
return False
def delete_model_record(self, model, rec_id, **post):
try:
model_to_del_rec = request.env[model]
except KeyError as e:
msg = "The model `%s` does not exist." % model
res = error_response(e, msg)
return http.Response(json.dumps(res),
status=200,
mimetype='application/json')
# TODO: Handle error raised by `ensure_one`
rec = model_to_del_rec.browse(rec_id).ensure_one()
try:
is_deleted = rec.unlink()
res = {"result": is_deleted}
return http.Response(json.dumps(res),
status=200,
mimetype='application/json')
except Exception as e:
res = error_response(e, str(e))
return http.Response(json.dumps(res),
status=200,
mimetype='application/json')
def get_ajax_cart_sucess(self, product_id=None):
"""
This controller return the template for Ajax Add to Cart with product details
:param product_id: get product id
:return: ajax cart template html
"""
if product_id:
product = request.env['product.template'].search(
[['id', '=', product_id]])
values = {
'product': product,
}
response = http.Response(
template="emipro_theme_base.ajax_cart_success_container",
qcontext=values)
return response.render()
def get_quick_view_item(self, product_id=None):
"""
This controller return the template for QuickView with product details
:param product_id: get product id
:return: quick_view template html
"""
if product_id:
product = request.env['product.template'].search(
[['id', '=', product_id]])
values = {
'product': product,
}
response = http.Response(
template="emipro_theme_base.quick_view_container",
qcontext=values)
return response.render()
def mega_menu_content_dynamic(self, menu_id):
response = http.Response(
template="emipro_theme_base.website_dynamic_category")
current_menu = request.env['website.menu'].sudo().search([('id', '=',
menu_id)])
if current_menu.is_dynamic_menu and current_menu.mega_menu_content_dynamic != response.render(
).decode():
current_menu.write({
"mega_menu_content_dynamic":
response.render().decode(),
"is_dynamic_menu_json":
False
})
return response.render().decode()
else:
return False
def get_model_data(self, model, **params):
try:
records = request.env[model].search([])
except KeyError as e:
msg = "The model `%s` does not exist." % model
res = error_response(e, msg)
return http.Response(json.dumps(res),
status=200,
mimetype='application/json')
if "query" in params:
query = params["query"]
else:
query = "{*}"
if "order" in params:
orders = json.loads(params["order"])
else:
orders = ""
if "filter" in params:
filters = json.loads(params["filter"])
records = request.env[model].search(filters, order=orders)
prev_page = None
next_page = None
total_page_number = 1
current_page = 1
if "page_size" in params:
page_size = int(params["page_size"])
count = len(records)
total_page_number = math.ceil(count / page_size)
if "page" in params:
current_page = int(params["page"])
else:
current_page = 1 # Default page Number
start = page_size * (current_page - 1)
stop = current_page * page_size
records = records[start:stop]
next_page = current_page+1 \
if 0 < current_page + 1 <= total_page_number \
else None
prev_page = current_page-1 \
if 0 < current_page - 1 <= total_page_number \
else None
if "limit" in params:
limit = int(params["limit"])
records = records[0:limit]
try:
serializer = Serializer(records, query, many=True)
data = serializer.data
except (SyntaxError, QueryFormatError) as e:
res = error_response(e, e.msg)
return http.Response(json.dumps(res),
status=200,
mimetype='application/json')
res = {
"count": len(records),
"prev": prev_page,
"current": current_page,
"next": next_page,
"total_pages": total_page_number,
"result": data
}
return http.Response(json.dumps(res),
status=200,
mimetype='application/json')
def get_homepage_test_data(self):
response = http.Response(
template="theme_clarico_vega.js_home_page_1_test")
return response.render()
