def delete_user(request):
# FIXME: Not implemented. Some thought needs to go into this. I think a
# deletion flag would be appropriate, but this will involve changing quite
# a number of queries.
# Tim thinks - makbe just lock the password and remove all machines?
response = HTTPNotImplemented()
return response
def delete_server(request):
# FIXME: Not implemented. Again, this needs thought. Probably logical
# deletion through a "deleted" flag.
# Or else, add a new server with the same name and blank UUID, as currently for multiple
# servers with the same name we only see the last.
response = HTTPNotImplemented()
return response
def addContact(contacts, request):
form = ContactForm()
btns = ContactBtns()
btns.prevBtn.flags.disabled = True
btns.nextBtn.flags.disabled = False # TODO support add-another
users = request.root['users']
projects = request.root['projects']
retval = {'form': form,
'btns': btns,
'viewUsers' : view_execution_permitted(users, request),
'viewContacts' : True,
'viewProjects' : view_execution_permitted(projects, request),
'currentUser': request.user}
if request.method == 'POST':
form.process(request.POST)
btns.process(request.POST)
if btns.cancelBtn.data:
url = request.resource_url(contacts).rstrip('/')
return HTTPFound(location = url)
elif btns.okBtn.data:
if not form.validate():
return retval
# Create a new Contact
contact = Contact(form.name.data, contacts)
form.populate_obj(contact)
contacts.reindex(contact)
url = request.resource_url(contact).rstrip('/')
return HTTPFound(location = url)
else:
return HTTPNotImplemented()
return retval
def editContact(contact, request):
contacts = request.root['contacts']
# or contact.__parent__ ?
# or find_interface(Users) ?
form = ContactForm(obj=contact)
btns = ContactBtns()
selection = request.session.get('selectedContacts', [])
myPos = None
btns.prevBtn.flags.disabled = True
btns.nextBtn.flags.disabled = True
try:
myPos = selection.index(contact.key)
if myPos > 0:
btns.prevBtn.flags.disabled = False
if myPos < len(selection) - 1:
btns.nextBtn.flags.disabled = False
except ValueError:
pass
referer = request.get('HTTP_REFERER', request.url)
users = request.root['users']
projects = request.root['projects']
retval = {'form': form,
'btns': btns,
'came_from': referer,
'viewUsers' : view_execution_permitted(users, request),
'viewContacts' : True,
'viewProjects' : view_execution_permitted(projects, request),
'currentUser': request.user}
if request.method == 'POST':
if 'came_from' in request.params:
retval['came_from'] = request.params['came_from']
form.process(request.POST)
btns.process(request.POST)
if btns.cancelBtn.data:
# go back if you can
url = request.params.get('came_from',
request.resource_url(contact).rstrip('/'))
return HTTPFound(location = url)
elif btns.okBtn.data:
request.session['selectedContacts'] = []
url = request.resource_url(contact).rstrip('/')
elif btns.prevBtn.data and not btns.prevBtn.flags.disabled:
selected = selection[myPos - 1]
url = request.resource_url(contacts, selected, "@@edit")
elif btns.nextBtn.data and not btns.nextBtn.flags.disabled:
selected = selection[myPos + 1]
url = request.resource_url(contacts, selected, "@@edit")
else:
return HTTPNotImplemented()
if not form.validate():
return retval
# Update an existing Contact
form.populate_obj(contact)
contacts.reindex(contact)
return HTTPFound(location = url)
return retval
def editUser(user, request):
users = request.root['users']
# or user.__parent__ ?
form = UserForm(obj=user)
btns = UserBtns()
selection = request.session.get('selectedUsers', [])
myPos = None
btns.prevBtn.flags.disabled = True
btns.nextBtn.flags.disabled = True
try:
myPos = selection.index(user.key)
if myPos > 0:
btns.prevBtn.flags.disabled = False
if myPos < len(selection) - 1:
btns.nextBtn.flags.disabled = False
except ValueError:
pass
contacts = request.root['contacts']
projects = request.root['projects']
retval = {
'form': form,
'btns': btns,
'viewUsers': True,
'viewContacts': view_execution_permitted(contacts, request),
'viewProjects': view_execution_permitted(projects, request),
'currentUser': request.user
}
if request.method == 'POST':
form.process(request.POST)
btns.process(request.POST)
if btns.cancelBtn.data:
del request.session['linkFromUser']
url = request.resource_url(user).rstrip('/')
return HTTPFound(location=url)
elif btns.okBtn.data:
request.session['selectedUsers'] = []
url = request.resource_url(user).rstrip('/')
elif btns.prevBtn.data and not btns.prevBtn.flags.disabled:
selected = selection[myPos - 1]
url = request.resource_url(users, selected, "@@edit")
elif btns.nextBtn.data and not btns.nextBtn.flags.disabled:
selected = selection[myPos + 1]
url = request.resource_url(users, selected, "@@edit")
elif btns.linkBtn.data:
request.session['linkFromUser'] = user.key
url = request.resource_url(contacts, "@@link")
return HTTPFound(location=url)
else:
return HTTPNotImplemented()
if not form.validate():
return retval
# Update an existing User
form.populate_obj(user)
users.reindex(user)
return HTTPFound(location=url)
return retval
def _validate_job_parameters(json_body):
"""
Tests supported parameters not automatically validated by colander deserialize.
"""
if json_body["mode"] not in [EXECUTE_MODE_ASYNC, EXECUTE_MODE_AUTO]:
raise HTTPNotImplemented(detail="Execution mode '{}' not supported.".format(json_body["mode"]))
if json_body["response"] != EXECUTE_RESPONSE_DOCUMENT:
raise HTTPNotImplemented(detail="Execution response type '{}' not supported.".format(json_body["response"]))
outputs = json_body.get("outputs", [])
if isinstance(outputs, dict):
outputs = [dict(id=out, **keys) for out, keys in outputs.items()]
for job_output in outputs:
mode = job_output["transmissionMode"]
if mode not in EXECUTE_TRANSMISSION_MODE_OPTIONS:
raise HTTPNotImplemented(detail="Execute transmissionMode '{}' not supported.".format(mode))
def _validate_job_parameters(json_body):
"""
Tests supported parameters not automatically validated by colander deserialize.
"""
if json_body["mode"] not in [EXECUTE_MODE_ASYNC, EXECUTE_MODE_AUTO]:
raise HTTPNotImplemented(detail="Execution mode '{}' not supported.".
format(json_body["mode"]))
if json_body["response"] != EXECUTE_RESPONSE_DOCUMENT:
raise HTTPNotImplemented(
detail="Execution response type '{}' not supported.".format(
json_body["response"]))
for job_output in json_body["outputs"]:
mode = job_output["transmissionMode"]
if mode not in EXECUTE_TRANSMISSION_MODE_OPTIONS:
raise HTTPNotImplemented(
detail="Execute transmissionMode '{}' not supported.".format(
mode))
def validate_values(self, values, renderTemplates={}):
req = self.request
if values.get('token') != req.session.get_csrf_token():
raise InvalidCSRFToken()
try:
### determine actual form used in this submission
schema_id = values['type']
schema = self.schemas[schema_id]
form = schema.getSchema(req, values)
except KeyError, e:
raise HTTPNotImplemented("Unexpected submission type!")
def validate_form(self):
values = variable_decode(self.request.params)
schema_id = values.get('type')
if not schema_id: raise HTTPNotImplemented()
try:
resp = self.validate_values(values)
except Invalid, error:
log.error(error.error_dict)
self.result['values'][schema_id] = error.value or {}
self.result['errors'][schema_id] = error.error_dict or {}
self.request.response.status_int = 401
def instance_put_json(request):
ctx = request.context
user_id = authenticated_userid(request) or Everyone
permissions = get_permissions(user_id, ctx.get_discussion_id())
instance = ctx._instance
if not instance.user_can(user_id, CrudPermissions.UPDATE, permissions):
return HTTPUnauthorized()
try:
updated = instance.update_from_json(request.json_body, user_id, ctx)
view = request.GET.get('view', None) or 'default'
if view == 'id_only':
return [updated.uri()]
else:
return updated.generic_json(view, user_id, permissions)
except NotImplemented:
raise HTTPNotImplemented()
def myNotImplementedView(exception, request):
"""
catch any MyNotImplementedError raised
"""
print(
'DEBUG HINT\n',
'API called with request\n',
'METHOD : {method}\n'.format(method=exception.method),
'URL : {path_url}\n'.format(path_url=exception.path_url),
'QUERY STRING: {qs}\n'.format(qs=exception.query_string),
'this method is not yet implemented\n'
)
return HTTPNotImplemented(
headers={
"content_type": 'application/json',
"charset": 'utf-8',
},
body='{exception}'.format(exception=exception)
)
def create_or_update_object(request, implemented_types):
'''Creates or Updates a Gnome object.'''
json_request = json.loads(request.body)
if not JSONImplementsOneOf(json_request, implemented_types):
raise HTTPNotImplemented()
obj = get_session_object(obj_id_from_url(request), request.session)
if obj:
try:
UpdateObject(obj, json_request)
except ValueError as e:
# TODO: We might want to log this message somewhere, as the
# response is a bit vague
raise HTTPUnsupportedMediaType(e)
else:
obj = CreateObject(json_request, request.session['objects'])
set_session_object(obj, request.session)
return obj.serialize()
def modify_user_language_preference(request):
json_data = request.json_body
ctx = request.context
user_id = request.authenticated_userid or Everyone
permissions = get_permissions(user_id, ctx.get_discussion_id())
instance = ctx._instance
if not instance.user_can(user_id, CrudPermissions.UPDATE, permissions):
return HTTPUnauthorized()
try:
updated = instance.update_from_json(json_data, user_id, ctx)
view = request.GET.get('view', None) or 'default'
if view == 'id_only':
return [updated.uri()]
else:
return updated.generic_json(view, user_id, permissions)
except NotImplemented:
raise HTTPNotImplemented()
except ObjectNotUniqueError as e:
raise JSONError(str(e), code=409)
def post(self, request):
resource = self.get_resource(request)
try:
context = extract_context(request)
except NotImplementedError as e:
raise HTTPNotImplemented(e.message)
context['diecutter'] = {
'api_url':
'%s://%s' %
(request.environ['wsgi.url_scheme'], request.environ['HTTP_HOST']),
'version':
VERSION,
'now':
datetime.now()
}
if not resource.exists:
return NotFound('Template not found')
writers = self.get_writers(request, resource, context)
dispatcher = self.get_dispatcher(request, resource, context, writers)
response = dispatcher(request, resource, context)
return response
def addUser(users, request):
form = UserForm()
btns = UserBtns()
contacts = request.root['contacts']
projects = request.root['projects']
retval = {
'form': form,
'btns': btns,
'viewUsers': True,
'viewContacts': view_execution_permitted(contacts, request),
'viewProjects': view_execution_permitted(projects, request),
'currentUser': request.user
}
if request.method == 'POST':
form.process(request.POST)
btns.process(request.POST)
if btns.cancelBtn.data:
url = request.resource_url(users).rstrip('/')
return HTTPFound(location=url)
elif btns.okBtn.data:
if not form.validate():
return retval
# Create a new User
user = User(form.name.data, users)
form.populate_obj(user)
users.reindex(user)
url = request.resource_url(user).rstrip('/')
return HTTPFound(location=url)
elif btns.linkBtn.data:
request.session['linkFromUser'] = user.key
url = request.resource_url(contacts, "@@link")
return HTTPFound(location=url)
else:
return HTTPNotImplemented()
return retval
def getActivityLike(context, request):
"""
"""
return HTTPNotImplemented()
def getUserLikedActivities(context, request):
"""
"""
return HTTPNotImplemented()
def share(context, request):
"""
"""
return HTTPNotImplemented()
def put(self, request):
raise HTTPNotImplemented()
def unsubscribe(context, request):
"""
"""
return HTTPNotImplemented()
def getUserSubscriptions(context, request):
"""
"""
return HTTPNotImplemented()
def delete(self):
raise HTTPNotImplemented()
def unlike(context, request):
"""
"""
return HTTPNotImplemented()
def view(self):
raise HTTPNotImplemented()
def test_it_shows_the_exception_message_to_the_user(self, pyramid_request):
exc = HTTPNotImplemented("This is the error message")
result = error.http_error(exc, pyramid_request)
assert result["message"] == "This is the error message"
def edit(self):
raise HTTPNotImplemented()
def test_it_reports_exception_to_sentry(self, pyramid_request, sentry_sdk):
exc = HTTPNotImplemented()
error.http_error(exc, pyramid_request)
sentry_sdk.capture_exception.assert_called_once_with(exc)
def handleNotImplemented(self, retval):
raise HTTPNotImplemented()
def test_it_sets_response_status(self, pyramid_request):
exc = HTTPNotImplemented()
error.http_error(exc, pyramid_request)
assert pyramid_request.response.status_int == 501
def update(self):
raise HTTPNotImplemented()
