def index(site=None): query = Question.select(Question, User, Site, Title, SQL(utils.rating_sql)).join(Site).switch(Question).join( User).switch( Question).join( Title) if site: query = query.where(Site.url == site) try: site_element = Site.select().where(Site.url == site).get() except DoesNotExist: abort(404) return else: site_element = utils.get_fallback_site() query = query.order_by(SQL("ci_lower_bound DESC, random")) # return jsonify(model_to_dict(query.get())) paginated_query = PaginatedQuery(query, paginate_by=10, check_bounds=True) pagearray = utils.create_pagination(paginated_query.get_page_count(), paginated_query.get_page()) return render_template( "list.html", pagearray=pagearray, num_pages=paginated_query.get_page_count(), page=paginated_query.get_page(), questions=paginated_query.get_object_list(), site=site_element, voted=session["voted"] if "voted" in session and not config.make_cacheable else None, infohidden="hide" in request.cookies )
def search(index_name): """ Search the index for documents matching the given query. """ if not request.args.get("q"): error('Missing required search parameter "q".') search_query = request.args["q"] ranking = request.args.get("ranking", Index.RANK_SIMPLE) if ranking and ranking not in (Index.RANK_SIMPLE, Index.RANK_BM25): error('Unrecognized "ranking" type.') filters = dict((key, request.args.getlist(key)) for key in request.args if key not in _PROTECTED_KEYS) index = get_object_or_404(Index, Index.name == index_name) query = index.search(search_query, ranking, True, **filters) pq = PaginatedQuery( query, paginate_by=app.config["PAGINATE_BY"], page_var=app.config["PAGE_VAR"], check_bounds=False ) return jsonify( { "documents": _serialize_documents(pq.get_object_list(), include_score=ranking is not None), "page": pq.get_page(), "pages": pq.get_page_count(), } )
def search(index_name): """ Search the index for documents matching the given query. """ if not request.args.get('q'): error('Missing required search parameter "q".') search_query = request.args['q'] ranking = request.args.get('ranking', Index.RANK_SIMPLE) if ranking and ranking not in (Index.RANK_SIMPLE, Index.RANK_BM25): error('Unrecognized "ranking" type.') filters = dict( (key, value) for key, value in request.args.items() if key not in ('page', 'q', 'key', 'ranking')) index = get_object_or_404(Index, Index.name == index_name) query = index.search(search_query, ranking, **filters) pq = PaginatedQuery( query, paginate_by=app.config['PAGINATE_BY'], page_var=app.config['PAGE_VAR'], check_bounds=False) return jsonify({ 'documents': _serialize_documents( pq.get_object_list(), include_score=ranking is not None), 'page': pq.get_page(), 'pages': pq.get_page_count()})
def list_corpsums(): query = CorpSum.select().order_by(CorpSum.id) pg = PaginatedQuery(query, paginate_by=10, page_var='page', check_bounds=True) page = pg.get_page() page_count = pg.get_page_count() corpsums = pg.get_object_list() return render_template('corpsum/list_corpsums.html', corpsums=corpsums, page=page, page_count=page_count)
def attachment_search(): """ Search the index for attachments matching the given query. """ phrase = request.args.get('q', '') or None ranking, _ = validate_ranking() ordering = request.args.getlist('ordering') filters = extract_metadata_filters() # Allow filtering by index. idx_list = request.args.getlist('index') if idx_list: indexes = Index.select(Index.id).where(Index.name << idx_list) else: indexes = None query = Attachment.search(phrase or '*', indexes, ranking if phrase else None, ordering, force_star_all=True if not phrase else False, **filters) pq = PaginatedQuery(query.naive(), paginate_by=app.config['PAGINATE_BY'], page_var=app.config['PAGE_VAR'], check_bounds=False) response = [] for attachment in pq.get_object_list(): data = { 'document_id': attachment.document_id, 'filename': attachment.filename, 'hash': attachment.hash, 'id': attachment.id, 'identifier': attachment.identifier, 'mimetype': attachment.mimetype, 'timestamp': attachment.timestamp.strftime('%Y-%m-%d %H:%M:%S'), } if phrase: data['score'] = attachment.score url_params = { 'document_id': data['document_id'], 'pk': data['filename'] } if app.config['AUTHENTICATION']: url_params['key'] = app.config['AUTHENTICATION'] data['data'] = url_for('attachment_download', **url_params) response.append(data) return jsonify({ 'attachment_count': Attachment.select().count(), 'attachments': response, 'filters': filters, 'ordering': ordering, 'page': pq.get_page(), 'pages': pq.get_page_count(), 'ranking': ranking, 'search_term': phrase, })
def index(): page_no = request.args.get('page', type=int) or 1 query_type = request.args.get('qt', type=str) query_param = request.args.get('qp', type=str) or '' file_type = file_type_mapping.get(request.args.get('ft', type=str), 'docker_files') if not query_param: query_type = "default" file_items_query = query_type_mapping.get(query_type, query_for_default)(query_param, file_type) paginated_query = PaginatedQuery(file_items_query, paginate_by=PAGE_SIZE, page=page_no) paginated_query_iter = paginated_query.get_object_list() return render_template('pages/placeholder.main.html', page_count=paginated_query.get_page_count(), page=paginated_query.get_page(), file_with_tags=paginated_query_iter, qt=query_type, qp=query_param, ft=file_type)
def category(input_category): """ PaginatedQuery 会通过 GET 请求的 page 参数返回该页的内容 """ menu_url = quote(request.path.encode('utf-8')) contents = Content.select(Category, Content)\ .join(Category)\ .where(Category.name == input_category, Content.status == 1) # 分页 page_object = PaginatedQuery(contents, paginate_by=PAGE_MAX, check_bounds=True) page_count = page_object.get_page_count() current_page = page_object.get_page() projects = page_object.get_object_list() for project in projects: collected, collected_project_id = get_collected_project_status( project.project_url) if collected: project.collected = collected project.collected_project_id = collected_project_id project.description = markdown2html(project.description) project.image_url = make_image_url(project.image_path) return render_template('home/category.html', projects=projects, menu_url=menu_url, page_title=input_category, category_url=quote(input_category.encode('utf-8')), page_count=page_count, current_page=current_page)
def list_users(): query = User.select().order_by(User.username) pg = PaginatedQuery(query, paginate_by=10, page_var='page', check_bounds=True) page = pg.get_page() page_count = pg.get_page_count() users = pg.get_object_list() return render_template('user/list_users.html', users=users, page=page, page_count=page_count)
def test_paginated_query(self): query = User.select().order_by(User.username) paginated_query = PaginatedQuery(query, 4) with self.app.test_request_context('/?page=2'): self.assertEqual(paginated_query.get_page(), 2) self.assertEqual(paginated_query.get_page_count(), 3) users = paginated_query.get_object_list() self.assertEqual([user.username for user in users], ['u04', 'u05', 'u06', 'u07']) with self.app.test_request_context('/'): self.assertEqual(paginated_query.get_page(), 1) for value in ['1', '0', '-1', 'xxx']: with self.app.test_request_context('/?page=%s' % value): self.assertEqual(paginated_query.get_page(), 1)
def test_paginated_query(self): query = User.select().order_by(User.username) paginated_query = PaginatedQuery(query, 4) with self.app.test_request_context('/?page=2'): self.assertEqual(paginated_query.get_page(), 2) self.assertEqual(paginated_query.get_page_count(), 3) users = paginated_query.get_object_list() self.assertEqual( [user.username for user in users], ['u04', 'u05', 'u06', 'u07']) with self.app.test_request_context('/'): self.assertEqual(paginated_query.get_page(), 1) for value in ['1', '0', '-1', 'xxx']: with self.app.test_request_context('/?page=%s' % value): self.assertEqual(paginated_query.get_page(), 1)
def __init__(self, page_queryset: PaginatedQuery, schema: Schema): self.page = page_queryset.get_page() self.count = page_queryset.query.count() self.page_nums = page_queryset.get_page_count() self.data = schema.dump(obj=page_queryset.get_object_list(), many=True).data self.result = OrderedDict([('count', self.count), ('page_nums', self.page_nums), ('next', self.get_next_url()), ('previous', self.get_previous_url()), ('results', self.data)])
def list_cvinfos(): query = CVInfo.select().order_by(CVInfo.name) pg = PaginatedQuery(query, paginate_by=10, page_var='page', check_bounds=True) page = pg.get_page() page_count = pg.get_page_count() cvinfos = pg.get_object_list() return render_template('cvinfo/list_cvinfos.html', cvinfos=cvinfos, page=page, page_count=page_count)
def paginate(): pagination = PaginatedQuery(Video.select().order_by(Video.id.desc()), 50) return 1, { 'pre': 50, 'page': pagination.get_page(), 'count': Video.select().count(), 'data': [{ **model_to_dict(video), 'code': None } for video in pagination.get_object_list()] }
def tags(): if 'q' in request.args: q = '%%%s%%' % request.args['q'] return 1, [model_to_dict(tag) for tag in Tag.select().where(Tag.name ** q).limit(10)] if 'list' in request.args: pagination = PaginatedQuery(Tag.select().order_by(Tag.id.desc()), 50) return 1, { 'pre': 50, 'page': pagination.get_page(), 'count': Tag.select().count(), 'data': [model_to_dict(video) for video in pagination.get_object_list()] } return render_template('tags.html')
def document_list(): """ Returns a paginated list of documents. Documents can be indexed by `POST`ing content, index(es) and, optionally, metadata. """ if request.method == "POST": data = parse_post(["content"], ["identifier", "index", "indexes", "metadata"]) indexes = validate_indexes(data) if indexes is None: error('You must specify either an "index" or "indexes".') document = Document.create(content=data["content"], identifier=data.get("identifier")) if data.get("metadata"): document.metadata = data["metadata"] for index in indexes: index.add_to_index(document) return jsonify( { "id": document.get_id(), "content": document.content, "indexes": [index.name for index in indexes], "metadata": document.metadata, } ) query = Document.all() # Allow filtering by index. if request.args.get("index"): query = query.join(IndexDocument, JOIN_LEFT_OUTER).join(Index).where(Index.name == request.args["index"]) if request.args.get("identifier"): query = query.where(Document.identifier == request.args["identifier"]) pq = PaginatedQuery( query, paginate_by=app.config["PAGINATE_BY"], page_var=app.config["PAGE_VAR"], check_bounds=False ) return jsonify( {"documents": _serialize_documents(pq.get_object_list()), "page": pq.get_page(), "pages": pq.get_page_count()} )
def document_list(): """ Returns a paginated list of documents. Documents can be indexed by `POST`ing content, index(es) and, optionally, metadata. """ if request.method == 'POST': data = parse_post(['content'], ['index', 'indexes', 'metadata']) indexes = validate_indexes(data) if indexes is None: error('You must specify either an "index" or "indexes".') document = Document.create(content=data['content']) if data.get('metadata'): document.metadata = data['metadata'] for index in indexes: index.add_to_index(document) return jsonify({ 'id': document.rowid, 'content': document.content, 'indexes': [index.name for index in indexes], 'metadata': document.metadata}) query = Document.all() # Allow filtering by index. if request.args.get('index'): query = (query .join(IndexDocument, JOIN_LEFT_OUTER) .join(Index) .where(Index.name == request.args['index'])) pq = PaginatedQuery( query, paginate_by=app.config['PAGINATE_BY'], page_var=app.config['PAGE_VAR'], check_bounds=False) return jsonify({ 'documents': _serialize_documents(pq.get_object_list()), 'page': pq.get_page(), 'pages': pq.get_page_count()})
def all_teas(): types = TeaType.select().where(TeaType.is_origin == False).order_by( TeaType.order) # noqa teas = PaginatedQuery((Tea.select(Tea, TeaVendor).join(TeaVendor)), paginate_by=app.config['ITEMS_PER_PAGE'], page_var='page', check_bounds=True) return render_template('tea_types.html', teas=teas, types=types, tea_type=None, all=True, pagination={ 'page': teas.get_page(), 'pages': teas.get_page_count() })
def by_type(tea_type_slug): tea_type = get_object_or_404(TeaType, TeaType.slug == tea_type_slug) types = TeaType.select().where( TeaType.is_origin == tea_type.is_origin).order_by(TeaType.order) teas = PaginatedQuery( (Tea.select(Tea, TeaVendor).join(TypeOfATea).join(TeaType).where( TypeOfATea.tea_type == tea_type).switch(Tea).join(TeaVendor)), paginate_by=app.config['ITEMS_PER_PAGE'], page_var='page', check_bounds=True) return render_template('tea_types.html', teas=teas, types=types, tea_type=tea_type, all=False, pagination={ 'page': teas.get_page(), 'pages': teas.get_page_count() })
def index_detail(index_name): """ Detail view for an index. This view returns a JSON object with the index's id, name, and a paginated list of associated documents. Existing indexes can be renamed using this view by `POST`-ing a `name`, or deleted by issuing a `DELETE` request. """ index = get_object_or_404(Index, Index.name == index_name) if request.method == 'POST': data = parse_post(['name']) index.name = data['name'] with database.atomic(): try: index.save() except IntegrityError: error('"%s" is already in use.' % index.name) elif request.method == 'DELETE': with database.atomic(): (IndexDocument .delete() .where(IndexDocument.index == index) .execute()) index.delete_instance() return jsonify({'success': True}) pq = PaginatedQuery( index.documents, paginate_by=app.config['PAGINATE_BY'], page_var=app.config['PAGE_VAR'], check_bounds=False) return jsonify({ 'id': index.id, 'name': index.name, 'documents': _serialize_documents(pq.get_object_list()), 'page': pq.get_page(), 'pages': pq.get_page_count()})
def by_vendor(vendor_slug): if vendor_slug is None: return redirect( url_for('by_vendor', vendor_slug=TeaVendor.select(TeaVendor.slug).order_by( TeaVendor.order).first().slug)) vendor = get_object_or_404(TeaVendor, TeaVendor.slug == vendor_slug) vendors = TeaVendor.select().order_by(TeaVendor.order) teas = PaginatedQuery((Tea.select( Tea, TeaVendor).join(TeaVendor).where(Tea.vendor == vendor)), paginate_by=app.config['ITEMS_PER_PAGE'], page_var='page', check_bounds=True) return render_template('tea_vendors.html', vendors=vendors, teas=teas, tea_vendor=vendor, pagination={ 'page': teas.get_page(), 'pages': teas.get_page_count() })
def category(input_category): """ PaginatedQuery 会通过 GET 请求的 page 参数返回该页的内容 """ menu_url = quote(request.path.encode('utf-8')) content_objects = Content.select(Category, Content).join(Category) \ .where(Category.name == input_category, Content.status == 1) page_object = PaginatedQuery(content_objects, paginate_by=app.config['PAGE_MAX'], check_bounds=True) project_objects = page_object.get_object_list() for project_object in project_objects: project_object.description = markdown2html(project_object.description) project_object.image_url = make_image_url(project_object.image_path) page_count = page_object.get_page_count() current_page = page_object.get_page() return render_template('content.html', projects=project_objects, menu_url=menu_url, content_type='category', page_title=input_category, category_url=quote(input_category.encode('utf-8')), page_count=page_count, current_page=current_page)
def attachment_search(): """ Search the index for attachments matching the given query. """ phrase = request.args.get('q', '') or None ranking, _ = validate_ranking() ordering = request.args.getlist('ordering') filters = extract_metadata_filters() # Allow filtering by index. idx_list = request.args.getlist('index') if idx_list: indexes = Index.select(Index.id).where(Index.name << idx_list) else: indexes = None query = Attachment.search( phrase or '*', indexes, ranking if phrase else None, ordering, force_star_all=True if not phrase else False, **filters) pq = PaginatedQuery( query.naive(), paginate_by=app.config['PAGINATE_BY'], page_var=app.config['PAGE_VAR'], check_bounds=False) response = [] for attachment in pq.get_object_list(): data = { 'document_id': attachment.document_id, 'filename': attachment.filename, 'hash': attachment.hash, 'id': attachment.id, 'identifier': attachment.identifier, 'mimetype': attachment.mimetype, 'timestamp': attachment.timestamp.strftime('%Y-%m-%d %H:%M:%S'), } if phrase: data['score'] = attachment.score url_params = { 'document_id': data['document_id'], 'pk': data['filename']} if app.config['AUTHENTICATION']: url_params['key'] = app.config['AUTHENTICATION'] data['data'] = url_for('attachment_download', **url_params) response.append(data) return jsonify({ 'attachment_count': Attachment.select().count(), 'attachments': response, 'filters': filters, 'ordering': ordering, 'page': pq.get_page(), 'pages': pq.get_page_count(), 'ranking': ranking, 'search_term': phrase, })