def __call__(self, request, **kw):
try:
return super().__call__(request, **kw)
except PermissionDenied:
raise rpc.InvalidRequest('permission denied') from None
except Http401:
raise rpc.InvalidRequest('authentication required') from None
def ws_model_create(self, wsrequest):
"""Create a new model
From the client::
client.rpc('model_create', {'field1': 'foo', ...})
:param request:
:return: object with metadata information
"""
model = get_model(wsrequest)
request = wsrequest.wsgi_request
form_class = get_form_class(request, model.form)
if not form_class:
raise rpc.InvalidRequest('cannot create model %s' % model.name)
fields = wsrequest.check_permission(model.name, 'create',
model.fields())
# fields = model.column_fields(fields, 'name')
instance = model.instance(fields=fields)
form = form_class(request, data=wsrequest.params)
if form.is_valid():
with model.session(request) as session:
instance = model.create_model(request,
instance,
form.cleaned_data,
session=session)
return model.tojson(request, instance)
else:
raise rpc.InvalidParams(data=form.tojson())
def __init__(self, rpc, request_id, params):
"""
Initialises the responder
:param id: RPC request ID
:param params: RPC parameters
"""
self.rpc = rpc
self.id = request_id
self.params = params if params is not None else {}
if not isinstance(self.params, dict):
raise rpc.InvalidRequest('params entry must be a dictionary')
async def __call__(self, data):
request_id = data.get('id')
try:
if 'method' in data:
if not request_id:
raise rpc.InvalidRequest('Request ID not available')
method = data['method']
handler = self.methods.get(method)
if not handler:
raise rpc.NoSuchFunction(method)
#
request = RpcWsMethodRequest(self, request_id,
data.get('params'))
result = await maybe_green(self.ws.app, handler, request)
self.write(request_id, result)
else:
raise rpc.InvalidRequest('Method not available')
except rpc.InvalidRequest as exc:
self.write_error(request_id, exc)
except Exception as exc:
self.ws.logger.exception('While loading websocket message')
self.write_error(request_id, exc)
def ws_authenticate(self, wsrequest):
"""Websocket RPC method for authenticating a user
"""
if wsrequest.cache.user_info:
raise rpc.InvalidRequest('Already authenticated')
token = wsrequest.required_param("authToken")
model = wsrequest.app.models.get('user')
if not model:
raise rpc.InternalError('user model missing')
wsgi = wsrequest.ws.wsgi_request
backend = wsgi.cache.auth_backend
auth = 'bearer %s' % token
try:
backend.authorize(wsgi, auth)
except BadRequest:
raise rpc.InvalidParams('bad authToken') from None
args = {model.id_field: getattr(wsgi.cache.user, model.id_field)}
user = model.get_instance(wsgi, **args)
user_info = model.tojson(wsgi, user)
wsrequest.cache.user_info = user_info
return user_info