def delete_user_identity(request): # Grab the identity id = request.matchdict['identity_id'] try: identity = DBSession.query(Identity) \ .filter(Identity.id==id) \ .first() except DBAPIError: raise httpexceptions.HTTPServiceUnavailable( connection_error_message, content_type='text/plain', ) if identity is None: raise httpexceptions.HTTPNotFound() elif len(identity.user.identities) <= 1: raise httpexceptions.HTTPForbidden("Cannot delete the only remaining " "identity connection.") # Check that this user has permission to remove an identity. permissible = security.has_permission('delete', identity, request) if not permissible: raise httpexceptions.HTTPUnauthorized() # Remove the identity DBSession.delete(identity) raise httpexceptions.HTTPNoContent()
def delete_attachment_view(request, file_field): utils.delete_attachment(request) # Remove metadata. record = {"data": {}} record["data"][file_field] = None utils.patch_record(record, request) raise httpexceptions.HTTPNoContent()
def _process_result(self, result, created=False, context=None): if result is None: return httpexceptions.HTTPNoContent() if created: self.request.response.status = 201 if ILocation.providedBy(result): self.request.response.headers[ 'Location'] = self.request.resource_url(result) _try_add_etag(self.request, result, context=context) return result
def retry_message(request): '''Unlocks and retries the message at a point in the future''' data = V.retry_schema.to_python(request.json, request) after = datetime.utcnow() + timedelta(seconds=data['delay']) M.HTTPMessage.m.update_partial( dict(_id=int(request.matchdict['message_id'])), { 's.status': 'ready', 's.after': after }) M.HTTPMessage.channel.pub('enqueue', int(request.matchdict['message_id'])) return exc.HTTPNoContent()
def get(request): data = V.get_schema.to_python(request.params, request) sleep_ms = asint(request.registry.settings['sleep_ms']) # Ignore gets from the queue, as they skew our response time results messages = MessageGetter.get(request.matchdict['qname'], sleep_ms, data['client'], data['timeout'], data['count']) if messages: return dict((msg.url(request), msg.data) for msg in messages) else: return exc.HTTPNoContent()
def _hello_endpoint(request): helloid = int(request.matchdict["helloid"]) if helloid == 500: raise exc.HTTPInternalServerError() if helloid == 404: raise exc.HTTPNotFound() if helloid == 302: raise exc.HTTPFound() if helloid == 204: raise exc.HTTPNoContent() if helloid == 900: raise NotImplementedError() return Response("Hello: " + str(helloid))
def delete_pet(context, request): """ Remove a pet request.matchdict: * 'pet_id' Pet's Unique identifier `{"type": "string", "required": true, "pattern": "^[a-zA-Z0-9-]+$"}` """ pet_id = request.matchdict["pet_id"] if pet_id in PETS: logger.info('Deleting pet %s..', pet_id) del PETS[pet_id] raise httpexceptions.HTTPNoContent() else: raise httpexceptions.HTTPNotFound()
def get(request): data = V.get_schema.to_python(request.params, request) sleep_ms = asint(request.registry.settings['chapman.sleep_ms']) # Ignore gets from the queue, as they skew our response time results try: import newrelic.agent newrelic.agent.set_background_task() except ImportError: pass messages = MessageGetter.get(request.matchdict['qname'], sleep_ms, data['client'], data['timeout'], data['count']) if messages: return dict((msg.url(request), msg.data) for msg in messages) else: return exc.HTTPNoContent()
def leave(request): if request.authenticated_userid is None: raise exc.HTTPNotFound() pubid = request.matchdict["pubid"] group = models.Group.get_by_pubid(request.db, pubid) if group is None: raise exc.HTTPNotFound() if request.authenticated_user not in group.members: raise exc.HTTPNotFound() group.members.remove(request.authenticated_user) _send_group_notification(request, 'group-leave', group.pubid) return exc.HTTPNoContent()
def scoreCMO(request): Helper.permissions(request) # Collect information try: mid = int(request.params["mid"]) qid = int(request.params["qid"]) score = int(request.params["score"]) except: raise exc.HTTPBadRequest("Necessary content is missing") # TODO: decide upon score range and values score = float(int(score)) * 0.05 # Reduce score to between 0-5 # Record the users opinion db.execute('labelModel', [request.session["username"], qid, mid, score]) raise exc.HTTPNoContent()
def collectCMO(request): Helper.permissions(request) # Collect the question id from the request try: qid = int(request.params["qid"]) except: raise exc.HTTPBadRequest("Question ID not passed") # Collect the collection of unlabelled models for that user and question unlabelled = db.execute('collectUnlabelled', [request.session["username"], qid]) # Select and return a modelID at random # TODO: Include directed learning if len(unlabelled): modelID, = random.choice(unlabelled) return {"mid": modelID} # No models left to annotate, no model id to return raise exc.HTTPNoContent()
def leave(group, request): """Route for leaving a group. Used by the Hypothesis client.""" groups_service = request.find_service(name='group') groups_service.member_leave(group, request.authenticated_userid) return httpexceptions.HTTPNoContent()
def delete_message(request): M.HTTPMessage.m.remove(dict(_id=int(request.matchdict['message_id']))) return exc.HTTPNoContent()
def delete_network(request): uuid = request.matchdict['uuid'] session = _get_session(request) network = _get_network(uuid, session) session.delete(network) return httpexc.HTTPNoContent()