def get(self, report_uid, attachment_path): """Get an attachment for a specific Testplan report given their uids.""" attachment_path = os.path.abspath( os.path.join( app.config["DATA_PATH"], defaults.ATTACHMENTS, attachment_path ) ) if os.path.exists(attachment_path): return send_from_directory( directory=os.path.dirname(attachment_path), filename=os.path.basename(attachment_path), ) else: raise exceptions.NotFound()
def del_engine(id): engine = ( models .Engine .query .filter_by(id=id) .first()) if not engine: raise exceptions.NotFound('Engine not found') db.session.delete(engine) db.session.commit() return flask.Response(status=204)
def redirect_to_context(node_id): """Redirects to the context URL of the node. Comment: redirects to whatever the comment is attached to + #node_id (unless 'whatever the comment is attached to' already contains '#', then '#node_id' isn't appended) Post: redirects to main or project-specific blog post Other: redirects to project.url + #node_id """ if node_id.lower() == '{{objectid}}': log.warning( "JavaScript should have filled in the ObjectID placeholder, but didn't. " "URL=%s and referrer=%s", request.url, request.referrer) raise wz_exceptions.NotFound('Invalid ObjectID') try: url = url_for_node(node_id) except ValueError as ex: log.warning("%s: URL=%s and referrer=%s", str(ex), request.url, request.referrer) raise wz_exceptions.NotFound('Invalid ObjectID') return redirect(url)
def get(self, module_id): policy.authorize(flask.request.context, 'v2_rating:get_module', {}) try: module = self.rating_modules[module_id] except KeyError: raise http_exceptions.NotFound( "Module '{}' not found".format(module_id)) infos = module.obj.module_info.copy() return { 'module_id': module_id, 'description': infos['description'], 'enabled': infos['enabled'], 'hot_config': infos['hot_config'], 'priority': infos['priority'], }
def force_remove_multiple(*models, silent=False): count = 0 for m in models: if isinstance(m, db.Model): db.session.delete(m) count += 1 else: msg = "DbModel Not Found:<{}:{}>".format(type(m), m) if silent: logger.error(msg) else: db.session.rollback() raise errors.NotFound(msg) if count > 0: db.session.commit()
async def _handle_ws_reverse(self, adapter: str): websocket: QuartWebSocket = _websocket ws = WebSocket(websocket.http_version, websocket.scheme, websocket.path, websocket.query_string, dict(websocket.headers), websocket) if adapter not in self._adapters: logger.warning( f'Unknown adapter {adapter}. Please register the adapter before use.' ) raise exceptions.NotFound() BotClass = self._adapters[adapter] self_id, response = await BotClass.check_permission(self, ws) if not self_id: raise exceptions.Unauthorized( description=(response and response.body or b"").decode()) if self_id in self._clients: logger.opt(colors=True).warning( "There's already a websocket connection, " f"<y>{escape_tag(adapter.upper())} Bot {escape_tag(self_id)}</y> ignored." ) raise exceptions.Forbidden(description='Client already exists.') bot = BotClass(self_id, ws) await ws.accept() logger.opt(colors=True).info( f"WebSocket Connection from <y>{escape_tag(adapter.upper())} " f"Bot {escape_tag(self_id)}</y> Accepted!") self._bot_connect(bot) try: while not ws.closed: try: data = await ws.receive() except asyncio.CancelledError: logger.warning("WebSocket disconnected by peer.") break except Exception as e: logger.opt(exception=e).error( "Error when receiving data from websocket.") break asyncio.create_task(bot.handle_message(data.encode())) finally: self._bot_disconnect(bot)
def testErrorPageIsRenderedForUndefinedURL(self): """Test that error page is shown for undefined URL.""" self.driver.get(self.args.server_url + '/foobar123') error_code_element = self.driver.find_element( *ErrorPage.ERROR_CODE_ELEMENT) error_description_element = self.driver.find_element( *ErrorPage.ERROR_DESCRIPTION_ELEMENT) error_404 = exceptions.NotFound() self.assertEquals('Error ' + str(error_404.code), error_code_element.text) self.assertEquals(error_404.description.replace(' ', ' '), error_description_element.text.encode('ascii'))
def get(self, report_uid): """Get a Testplan report (JSON) given it's uid.""" # report_uid will be used when looking up the report from a database. report_path = os.path.abspath( os.path.join( app.config["DATA_PATH"], app.config["TESTPLAN_REPORT_NAME"] ) ) if os.path.exists(report_path): return send_from_directory( directory=os.path.dirname(report_path), filename=os.path.basename(report_path), ) else: raise exceptions.NotFound()
def get_all_vars(vtype, job): vt = Vtype[vtype] values = request.args.get("values", type=util.boolstr) only = request.args.get("only") if only is not None: only = [vn.strip() for vn in only.split(",")] if vt == Vtype.results: tasks.flush_updates() try: with db.transact() as conn: vars = _get_vars(db.get_state(conn), vt, job) return jsonify({k: vars[k] for k in only} if only else dict(vars) if values else list(vars)) except KeyError as e: raise wexc.NotFound("No such variable: %s" % e) from e
def search_model(model, query): known_columns = model.__table__.columns.keys() for search_column in flask.request.args: if search_column not in known_columns: raise exceptions.NotFound( 'Search term %s is not supported' % search_column) search_terms = flask.request.args.getlist(search_column) if search_terms: search_terms = [term.lower() for term in search_terms] query = query.filter( func.lower(getattr(model, search_column)).in_(search_terms)) return query
def remove_category(category): current_category = Categories.query.filter( Categories.category_id == category).first() if not current_category: return exceptions.NotFound() form = KillMii() if form.validate_on_submit(): db.session.delete(current_category) db.session.commit() delete_category_thumbnail(current_category.category_id) return redirect(url_for("list_categories")) return render_template("category_delete.html", form=form, item_id=category)
def home_jstree(): """Entry point to view the home project as JSTree""" api = system_util.pillar_api() try: project = Project.find_from_endpoint('/bcloud/home-project', params={'projection': { '_id': 1, 'permissions': 1, 'category': 1, 'user': 1}}, api=api) except ResourceNotFound: raise wz_exceptions.NotFound('No such project') return jsonify(items=jstree_get_children(None, project._id))
def del_lab_agent(id, agent_id): lab_agent = ( models .LabAgent .query .filter_by(agent_id=agent_id, lab_id=id) .first()) if not lab_agent: raise exceptions.NotFound('Lab <-> agent binding not found') db.session.delete(lab_agent) db.session.commit() engine = models.Lab.query.filter_by(id=id).first() schema = schemas.LabSchema() return schema.jsonify(engine), 204
def show_supervisors(id=None): supervisor_query = (models.Supervisor.query.outerjoin(models.Process)) if id is None: supervisors = supervisor_query.all() else: supervisor_query = (supervisor_query.filter( models.Supervisor.id == id)) supervisors = supervisor_query.first() if not supervisors: raise exceptions.NotFound('Supervisor not found') schema = schemas.SupervisorSchema(many=id is None) return schema.jsonify(supervisors), 200
def del_engine_endpoint(id, endpoint_id): engine_endpoint = ( models .EngineEndpoint .query .filter_by(engine_id=id, endpoint_id=endpoint_id).first()) if not engine_endpoint: raise exceptions.NotFound('Engine <-> endpoint binding not found') db.session.delete(engine_endpoint) db.session.commit() engine = models.Engine.query.filter_by(id=id).first() schema = schemas.EngineSchema() return schema.jsonify(engine), 204
def del_engine_user(id, user_id): engine_user = ( models .EngineUser .query .filter_by(engine_id=id, user_id=user_id) .first()) if not engine_user: raise exceptions.NotFound('Engine <-> user binding not found') db.session.delete(engine_user) db.session.commit() engine = models.Engine.query.filter_by(id=id).first() schema = schemas.EngineSchema() return schema.jsonify(engine), 204
def find_service_account_id(self, manager_id: bson.ObjectId) -> bson.ObjectId: _, manager = self._get_manager(mngr_doc_id=manager_id, projection={'service_account': 1}) users_coll = current_app.db('users') service_account_id = manager['service_account'] service_account = users_coll.find_one({ '_id': service_account_id, 'service.flamenco_manager': { '$exists': True } }) if not service_account: self._log.error('Unable to find service account %s for manager %s', service_account_id, manager_id) raise wz_exceptions.NotFound() return service_account_id
def jstree(project_url): """Entry point to view a project as JSTree""" api = system_util.pillar_api() try: project = Project.find_one( { 'projection': { '_id': 1 }, 'where': { 'url': project_url } }, api=api) except ResourceNotFound: raise wz_exceptions.NotFound('No such project') return jsonify(items=jstree_get_children(None, project._id))
def show_console(id, page_id=None): console_query = (models.ConsolePage.query.join(models.Process).filter( models.Process.id == id).order_by(models.ConsolePage.timestamp.asc())) if page_id is None: pages = console_query.all() else: console_query = (console_query.filter( models.ConsolePage.id == page_id)) pages = console_query.first() if not pages: raise exceptions.NotFound('Console page not found') schema = schemas.ConsoleSchema(many=page_id is None) return schema.jsonify(pages), 200
def url_for_node(node_id=None, node=None): assert isinstance(node_id, (str, type(None))) api = system_util.pillar_api() if node_id is None and node is None: raise ValueError('Either node or node_id must be given') if node is None: try: node = Node.find(node_id, api=api) except ResourceNotFound: log.warning( 'url_for_node(node_id=%r, node=None): Unable to find node.', node_id) raise wz_exceptions.NotFound('Unable to find node %r' % node_id) return finders.find_url_for_node(node)
def change_lab_power(id, state): lab = ( models.Lab .query .filter_by(id=id) .first()) if not lab: raise exceptions.NotFound('Lab not found') lab.power = state.lower() db.session.commit() lab = models.Lab.query.filter_by(id=id).first() schema = schemas.LabSchema() return schema.jsonify(lab), 200
def update_component(model, req, box_id, id): component = (model.query.filter_by(box_id=box_id, id=id).first()) if not component: raise exceptions.NotFound(str(model) + ' not found') for field in req: prev_attr = getattr(component, field) if isinstance(req[field], (type(None), type(prev_attr))) or isinstance( prev_attr, type(None)): setattr(component, field, req[field]) else: raise exceptions.BadRequest('wrong datatype: ' + str(type(req[field])) + ' instead of ' + str(type(prev_attr))) db.session.add(component) db.session.commit()
def render_node_page(project_url, page_url, api): """Custom behaviour for pages, which are nodes, but accessible on a custom route base. """ # TODO: ensure this is not called for the home project, as it would # generate conflicting websites project = find_project_or_404(project_url, api=api) try: page = Node.find_one({ 'where': { 'project': project['_id'], 'node_type': 'page', 'properties.url': page_url}}, api=api) except ResourceNotFound: raise wz_exceptions.NotFound('No such node') return project, page
def edit_comment(user_id, node_id, patch): """Edits a single comment. Doesn't do permission checking; users are allowed to edit their own comment, and this is not something you want to revoke anyway. Admins can edit all comments. """ # Find the node. We need to fetch some more info than we use here, so that # we can pass this stuff to Eve's patch_internal; that way the validation & # authorisation system has enough info to work. nodes_coll = current_app.data.driver.db['nodes'] projection = {'user': 1, 'project': 1, 'node_type': 1} node = nodes_coll.find_one(node_id, projection=projection) if node is None: log.warning('User %s wanted to patch non-existing node %s' % (user_id, node_id)) raise wz_exceptions.NotFound('Node %s not found' % node_id) if node['user'] != user_id and not authorization.user_has_role('admin'): raise wz_exceptions.Forbidden('You can only edit your own comments.') # Use Eve to PATCH this node, as that also updates the etag. r, _, _, status = current_app.patch_internal('nodes', {'properties.content': patch['content'], 'project': node['project'], 'user': node['user'], 'node_type': node['node_type']}, concurrency_check=False, _id=node_id) if status != 200: log.error('Error %i editing comment %s for user %s: %s', status, node_id, user_id, r) raise wz_exceptions.InternalServerError('Internal error %i from Eve' % status) else: log.info('User %s edited comment %s', user_id, node_id) # Fetch the new content, so the client can show these without querying again. node = nodes_coll.find_one(node_id, projection={ 'properties.content': 1, 'properties._content_html': 1, }) return status, node
def get(self, offset=0, limit=100, scope_id=None, scope_key=None, fetcher=None, collector=None, active=None): policy.authorize( flask.request.context, 'scope:get_state', {'project_id': scope_id or flask.request.context.project_id}) results = self._storage_state.get_all(identifier=scope_id, scope_key=scope_key, fetcher=fetcher, collector=collector, offset=offset, limit=limit, active=active) if len(results) < 1: raise http_exceptions.NotFound( "No resource found for provided filters.") return { 'results': [{ 'scope_id': r.identifier, 'scope_key': r.scope_key, 'fetcher': r.fetcher, 'collector': r.collector, 'state': r.last_processed_timestamp.isoformat(), 'last_processed_timestamp': r.last_processed_timestamp.isoformat(), 'active': r.active, 'scope_activation_toggle_date': r.scope_activation_toggle_date.isoformat() if r.scope_activation_toggle_date else None } for r in results] }
def show_endpoints(id=None, endpoint_id=None): endpoint_query = (models.Endpoint.query.join(models.Process)) if id is not None: endpoint_query = (endpoint_query.filter(models.Process.id == id)) if endpoint_id is None: endpoints = endpoint_query.all() else: endpoint_query = (endpoint_query.filter(models.Endpoint.id == id)) endpoints = endpoint_query.first() if not endpoints: raise exceptions.NotFound('Endpoint not found') schema = schemas.EndpointSchema(many=endpoint_id is None) return schema.jsonify(endpoints), 200
def error_api(): if request.form.get("action") is None: print("Received an error!") print_multi(request.args) print_multi(request.form) return action_list["webApi_document_template"](request) try: # These values should be consistent for both v1 and v512. if request.form["platform"] != "wii": return exceptions.BadRequest() action = request.form["action"] return action_list[action](request) except KeyError: # This is not an action or a format we know of. return exceptions.NotFound()
def get(self, offset=0, limit=100, begin=None, end=None, filters=None): policy.authorize( flask.request.context, 'dataframes:get', {'tenant_id': flask.request.context.project_id}, ) begin = begin or tzutils.get_month_start() end = end or tzutils.get_next_month() if filters and 'type' in filters: metric_types = [filters.pop('type')] else: metric_types = None if not flask.request.context.is_admin: if flask.request.context.project_id is None: # Unscoped non-admin user return {'total': 0, 'dataframes': []} scope_key = CONF.collect.scope_key if filters: filters[scope_key] = flask.request.context.project_id else: filters = {scope_key: flask.request.context.project_id} results = self._storage.retrieve( begin=begin, end=end, filters=filters, metric_types=metric_types, offset=offset, limit=limit, ) if results['total'] < 1: raise http_exceptions.NotFound( "No resource found for provided filters.") return { 'total': results['total'], 'dataframes': results['dataframes'], }
def doc(self): """Doc for the controller.""" if not self._doc: partial = self.params['partial'] ext_config = structures.DeepReferenceDict( self.pod.extensions_controller.extension_config( 'extensions.editor.EditorExtension')) collection_path = ext_config['screenshots.partials.collection'] if not collection_path: raise werkzeug_exceptions.BadRequest( 'No collection path defined for partial screenshots') col = self.pod.get_collection(collection_path) pod_partial = self.pod.partials.get_partial(partial) partial_example = pod_partial.config.get('editor', {}).get( 'examples', {}).get(self.params['key']) if not partial_example: raise werkzeug_exceptions.NotFound( 'Unable to find example in partial: {}'.format( self.params['key'])) partial_example['partial'] = partial doc_fields = { '$view': ext_config['screenshots.partials.view'], 'partials': [ partial_example, ], } locale = self.route_info.meta.get('locale', self.params.get('locale')) pod_path = os.path.join(collection_path, '_partial.yaml') self._doc = document.Document(pod_path, locale=locale, _pod=self.pod, _collection=col) self._doc.format.update(fields=doc_fields) return self._doc
def pay_list_category(list_id: int): queried_categories = PayCategories.query.order_by( PayCategories.name.asc()).all() retrieved_data = (db.session.query(PayCategories).filter( PayCategories.genre_id == list_id).order_by( PayCategories.category_id).all()) filler = [] if list_id <= 9: for i, pay_categories in enumerate(queried_categories): # Items must be indexed by 1. filler.append( RepeatedElement({ "place": i + 1, "categid": pay_categories.category_id, "name": pay_categories.name, "sppageid": 0, "splinktext": "Link Text", })) else: if not retrieved_data: # Looks like this category does not exist, or contains no movies. return exceptions.NotFound() for i, pay_categories in enumerate(retrieved_data): # This section allows us to sort the categories into genres # Instead of them showing up in all of the genres filler.append( RepeatedElement({ "place": i + 1, "categid": pay_categories.category_id, "name": pay_categories.name, "sppageid": 0, "splinktext": "Link Text", })) return { "type": 3, "img": 1, "categinfo": filler, }