def search_read(self,
model,
domain=None,
fields=None,
context=None,
limit=80,
offset=0,
order=None,
**kw):
ctx = request.session.context.copy()
ctx.update(context and parse_value(context) or {})
domain = domain and parse_value(domain) or []
fields = fields and parse_value(fields) or None
limit = limit and int(limit) or None
offset = offset and int(offset) or None
model = request.env[model].with_context(ctx)
result = model.search_read(domain,
fields=fields,
offset=offset,
limit=limit,
order=order)
content = json.dumps(result,
sort_keys=True,
indent=4,
cls=ResponseEncoder)
return Response(content,
content_type='application/json;charset=utf-8',
status=200)
def read_group(self,
model,
domain,
fields,
groupby,
context=None,
offset=0,
limit=None,
orderby=False,
lazy=True,
**kw):
ctx = request.session.context.copy()
ctx.update(context and parse_value(context) or {})
domain = domain and parse_value(domain) or []
fields = fields and parse_value(fields) or []
groupby = groupby and parse_value(groupby) or []
limit = limit and int(limit) or None
offset = offset and int(offset) or None
lazy = misc.str2bool(lazy)
model = request.env[model].with_context(ctx)
result = model.read_group(domain,
fields,
groupby,
offset=offset,
limit=limit,
orderby=orderby,
lazy=lazy)
content = json.dumps(result,
sort_keys=True,
indent=4,
cls=ResponseEncoder)
return Response(content,
content_type='application/json;charset=utf-8',
status=200)
def search(self,
model,
domain=None,
context=None,
count=False,
limit=80,
offset=0,
order=None,
**kw):
ctx = request.session.context.copy()
ctx.update({'prefetch_fields': False})
ctx.update(context and parse_value(context) or {})
domain = domain and parse_value(domain) or []
count = count and misc.str2bool(count) or None
limit = limit and int(limit) or None
offset = offset and int(offset) or None
model = request.env[model].with_context(ctx)
result = model.search(domain,
offset=offset,
limit=limit,
order=order,
count=count)
if not count:
result = result.ids
content = json.dumps(result,
sort_keys=True,
indent=4,
cls=ResponseEncoder)
return Response(content,
content_type='application/json;charset=utf-8',
status=200)
def unlink(self, model, ids=None, context=None, **kw):
ctx = request.session.context.copy()
ctx.update(context and parse_value(context) or {})
ids = ids and parse_value(ids) or []
records = request.env[model].with_context(ctx).browse(ids)
result = records.unlink()
content = json.dumps(result, sort_keys=True, indent=4, cls=ResponseEncoder)
return Response(content, content_type='application/json;charset=utf-8', status=200)
def create(self, model, values=None, context=None, **kw):
ctx = request.session.context.copy()
ctx.update(context and parse_value(context) or {})
values = values and parse_value(values) or {}
model = request.env[model].with_context(ctx)
result = model.create(values).ids
content = json.dumps(result, sort_keys=True, indent=4, cls=ResponseEncoder)
return Response(content, content_type='application/json;charset=utf-8', status=200)
def call(self, model, method, ids=None, context=None, args=None, kwargs=None, **kw):
check_method_name(method)
ctx = request.session.context.copy()
ctx.update(context and parse_value(context) or {})
ids = ids and parse_value(ids) or []
args = args and parse_value(args) or []
kwargs = kwargs and parse_value(kwargs) or {}
records = request.env[model].with_context(ctx).browse(ids)
result = getattr(records, method)(*args, **kwargs)
content = json.dumps(result, sort_keys=True, indent=4, cls=RecordEncoder)
return Response(content, content_type='application/json;charset=utf-8', status=200)
def report(self,
report,
ids,
type='PDF',
context=None,
options=None,
file_response=False,
**kw):
ctx = request.session.context.copy()
ctx.update(context and parse_value(context) or {})
ids = ids and parse_value(ids) or []
options = options and parse_value(options) or {}
result = {'report': report, 'type': type}
report = request.env['ir.actions.report']._get_report_from_name(report)
if type.lower() == "html":
data = report.with_context(ctx).render_qweb_html(ids,
data=options)[0]
result.update({
'content': base64.b64encode(data),
'content_type': 'text/html',
'content_length': len(data)
})
elif type.lower() == "pdf":
data = report.with_context(ctx).render_qweb_pdf(ids,
data=options)[0]
result.update({
'content': base64.b64encode(data),
'content_type': 'application/pdf',
'content_length': len(data)
})
elif type.lower() == "text":
data = report.with_context(ctx).render_qweb_text(ids,
data=options)[0]
result.update({
'content': base64.b64encode(data),
'content_type': 'text/plain',
'content_length': len(data)
})
else:
return exceptions.NotFound()
if file_response and misc.str2bool(file_response):
headers = [('Content-Type', result.get('content_type')),
('Content-Length', result.get('content_length'))]
response = request.make_response(data, headers)
else:
content = json.dumps(result,
sort_keys=True,
indent=4,
cls=ResponseEncoder)
response = Response(content,
content_type='application/json;charset=utf-8',
status=200)
return response
def fields(self, model, fields=None, attributes=None, **kw):
fields = fields and parse_value(fields) or None
attributes = attributes and parse_value(attributes) or None
result = request.env[model].fields_get(allfields=fields,
attributes=attributes)
content = json.dumps(result,
sort_keys=True,
indent=4,
cls=ResponseEncoder)
return Response(content,
content_type='application/json;charset=utf-8',
status=200)
def upload(self, model, id, field=None, context=None, **kw):
ctx = request.session.context.copy()
ctx.update(context and parse_value(context) or {})
files = request.httprequest.files.getlist('ufile')
if field is not None and len(files) == 1:
record = request.env[model].with_context(ctx).browse(int(id))
result = record.write({field: base64.b64encode(files[0].read())})
else:
result = []
for ufile in files:
attachment = request.env['ir.attachment'].create({
'datas':
base64.encodestring(ufile.read()),
'datas_fname':
ufile.filename,
'name':
ufile.filename,
'res_model':
model,
'res_id':
int(id),
})
result.append(attachment.id)
content = json.dumps(result,
sort_keys=True,
indent=4,
cls=RecordEncoder)
return Response(content,
content_type='application/json;charset=utf-8',
status=200)
def custom(self, context=None, **kw):
endpoint = kw.get('custom', False)
if endpoint and endpoint.exists():
ctx = request.session.context.copy()
ctx.update(context and parse_value(context) or {})
return endpoint.with_context(ctx).evaluate(request.params)
return exceptions.NotFound()
def _get_eval_context(self, endpoint, params={}):
active_id = params.get('id', None)
active_ids = params.get('ids', [])
if active_id and isinstance(active_id, (str, bytes, bytearray)):
try:
active_id = parse_value(active_id)
except:
try:
active_id = int(active_id)
except:
active_id = None
if active_ids and isinstance(active_ids, (str, bytes, bytearray)):
try:
active_ids = parse_value(active_ids)
except:
active_ids = None
active_id = active_id or self.env.context.get('active_id')
active_ids = active_ids or self.env.context.get('active_ids')
return {'active_id': active_id, 'active_ids': active_ids}
def access(self, model, ids, operation='read', fields=None, **kw):
ids = ids and parse_value(ids) or []
fields = fields and parse_value(fields) or None
try:
rights = request.env[model].check_access_rights(operation)
rules = request.env[model].browse(ids).check_access_rule(
operation) is None
fields = request.env[model].check_field_access_rights(
operation, fields=fields)
result = rights and rules and bool(fields)
except (AccessError, UserError):
raise
result = False
content = json.dumps(result,
sort_keys=True,
indent=4,
cls=ResponseEncoder)
return Response(content,
content_type='application/json;charset=utf-8',
status=200)
def custom(self, context=None, **kw):
endpoint = kw.get('custom', False)
if endpoint and endpoint.exists():
ctx = request.session.context.copy()
ctx.update(context and parse_value(context) or {})
result = endpoint.with_context(ctx).evaluate(request.params)
content = json.dumps(result,
sort_keys=True,
indent=4,
cls=RecordEncoder)
return Response(content,
content_type='application/json;charset=utf-8',
status=200)
return exceptions.NotFound()
def access_rules(self, model, ids, operation='read', **kw):
ids = ids and parse_value(ids) or []
try:
result = request.env[model].browse(ids).check_access_rule(
operation) is None
except (AccessError, UserError):
result = False
content = json.dumps(result,
sort_keys=True,
indent=4,
cls=ResponseEncoder)
return Response(content,
content_type='application/json;charset=utf-8',
status=200)
