def ajax_list(self):
field = request.args.get('field')
prev_page = 0
next_page = 0
try:
models = path_to_models(self.model, field)
except AttributeError:
data = []
else:
rel_model = models.pop()
rel_field = rel_model._meta.fields[self.foreign_key_lookups[field]]
query = rel_model.select().order_by(rel_field)
query_string = request.args.get('query')
if query_string:
query = query.where(rel_field ** ('%%%s%%' % query_string))
pq = PaginatedQuery(query, self.filter_paginate_by)
current_page = pq.get_page()
if current_page > 1:
prev_page = current_page - 1
if current_page < pq.get_pages():
next_page = current_page + 1
data = [
{'id': obj.get_id(), 'repr': unicode(obj)} \
for obj in pq.get_list()
]
json_data = json.dumps({'prev_page': prev_page, 'next_page': next_page, 'object_list': data})
return Response(json_data, mimetype='application/json')
def ajax_list(self):
field_name = request.args.get('field')
prev_page = 0
next_page = 0
try:
models = path_to_models(self.model, field_name)
except AttributeError:
data = []
else:
field = self.model._meta.fields[field_name]
rel_model = models.pop()
rel_field = rel_model._meta.fields[self.foreign_key_lookups[field_name]]
query = rel_model.select().order_by(rel_field)
query_string = request.args.get('query')
if query_string:
query = query.where(rel_field ** ('%%%s%%' % query_string))
pq = PaginatedQuery(query, self.filter_paginate_by)
current_page = pq.get_page()
if current_page > 1:
prev_page = current_page - 1
if current_page < pq.get_pages():
next_page = current_page + 1
data = []
# if the field is nullable, include the "None" option at the top of the list
if field.null:
data.append({'id': '__None', 'repr': 'None'})
data.extend([{'id': obj.get_id(), 'repr': unicode(obj)} for obj in pq.get_list()])
json_data = json.dumps({'prev_page': prev_page, 'next_page': next_page, 'object_list': data})
return Response(json_data, mimetype='application/json')
def object_list(self):
query = self.get_query()
query = self.apply_ordering(query)
# create a QueryFilter object with our current query
query_filter = self.get_query_filter(query)
# process the filters from the request
filtered_query = query_filter.get_filtered_query()
try:
paginate_by = int(request.args.get('limit', self.paginate_by))
except ValueError:
paginate_by = self.paginate_by
else:
paginate_by = min(paginate_by, self.paginate_by) # restrict
pq = PaginatedQuery(filtered_query, paginate_by)
meta_data = self.get_request_metadata(pq)
query_dict = self.serialize_query(pq.get_list())
return self.response({
'meta': meta_data,
'objects': query_dict,
})
def ajax_list(self):
field = request.args.get("field")
prev_page = 0
next_page = 0
try:
models = path_to_models(self.model, field)
except AttributeError:
data = []
else:
rel_model = models.pop()
rel_field = self.foreign_key_lookups[field]
query = (
rel_model.select()
.where(**{"%s__icontains" % rel_field: request.args.get("query", "")})
.order_by(rel_field)
)
pq = PaginatedQuery(query, self.filter_paginate_by)
current_page = pq.get_page()
if current_page > 1:
prev_page = current_page - 1
if current_page < pq.get_pages():
next_page = current_page + 1
data = [{"id": obj.get_pk(), "repr": unicode(obj)} for obj in pq.get_list()]
json_data = json.dumps({"prev_page": prev_page, "next_page": next_page, "object_list": data})
return Response(json_data, mimetype="application/json")
def ajax_list(self):
field = request.args.get('field')
prev_page = 0
next_page = 0
try:
models = path_to_models(self.model, field)
except AttributeError:
data = []
else:
rel_model = models.pop()
rel_field = self.foreign_key_lookups[field]
query = rel_model.select().where(**{
'%s__icontains'% rel_field: request.args.get('query', ''),
}).order_by(rel_field)
pq = PaginatedQuery(query, self.filter_paginate_by)
current_page = pq.get_page()
if current_page > 1:
prev_page = current_page - 1
if current_page < pq.get_pages():
next_page = current_page + 1
data = [
{'id': obj.get_pk(), 'repr': unicode(obj)} \
for obj in pq.get_list()
]
json_data = json.dumps({'prev_page': prev_page, 'next_page': next_page, 'object_list': data})
return Response(json_data, mimetype='application/json')
def paginated_object_list(self, filtered_query):
paginate_by = self.get_paginate_by()
pq = PaginatedQuery(filtered_query, paginate_by)
meta_data = self.get_request_metadata(pq)
query_dict = self.serialize_query(pq.get_list())
meta_data['data'] = query_dict
return self.response(meta_data)
def paginated_object_list(self, filtered_query):
paginate_by = self.get_paginate_by()
pq = PaginatedQuery(filtered_query, paginate_by)
meta_data = self.get_request_metadata(pq)
query_dict = self.serialize_query(pq.get_list())
return self.response({
'meta': meta_data,
'objects': query_dict,
})
def details(id, page=20):
actor = Schedule.select().where(Schedule.id == id).get()
actor_requests = Request.select().where(Request.url_id == id).order_by(Request.insert_date.desc())
pages = PaginatedQuery(actor_requests, page)
content = pages.get_list()
stats = {}
stats['site_changes'] = actor_requests.select(Request.content_len).distinct().count()
stats['total_hits'] = actor_requests.count()
stats['ok_hits'] = actor_requests.select(Request.id).where(Request.status_code == '200').count()
stats['avg_response_time'] = (sum([row.response_time for row in actor_requests])/stats['total_hits'])
return render_template('details.html', actor=actor, actor_requests=content, pages=pages, stats=stats)
def paginated_object_list(self, filtered_query):
try:
paginate_by = int(request.args.get("limit", self.paginate_by))
except ValueError:
paginate_by = self.paginate_by
else:
if self.paginate_by:
paginate_by = min(paginate_by, self.paginate_by) # restrict
pq = PaginatedQuery(filtered_query, paginate_by)
meta_data = self.get_request_metadata(pq)
query_dict = self.serialize_query(pq.get_list())
return self.response({"meta": meta_data, "objects": query_dict})
def index(self):
query = self.get_query()
ordering = request.args.get('ordering') or ''
query = self.apply_ordering(query, ordering)
# process the filters from the request
filter_form, query, cleaned, field_tree = self.process_filters(query)
# create a paginated query out of our filtered results
pq = PaginatedQuery(query, self.paginate_by)
if request.method == 'POST':
id_list = request.form.getlist('id')
if request.form['action'] == 'delete':
return redirect(
url_for(self.get_url_name('delete'), id=id_list))
else:
return redirect(
url_for(self.get_url_name('export'), id=id_list))
return render_template(self.templates['index'],
model_admin=self,
query=pq,
ordering=ordering,
filter_form=filter_form,
field_tree=field_tree,
active_filters=cleaned,
**self.get_extra_context())
def index(self):
query = self.get_query()
ordering = request.args.get('ordering') or self.default_ordering
query = self.apply_ordering(query, ordering)
# create a QueryFilter object with our current query
query_filter = self.get_query_filter(query)
# process the filters from the request
filtered_query = query_filter.get_filtered_query()
# create a paginated query out of our filtered results
pq = PaginatedQuery(filtered_query, self.paginate_by)
if request.method == 'POST':
id_list = request.form.getlist('id')
if request.form['action'] == 'delete':
return redirect(
url_for(self.get_url_name('delete'), id=id_list))
else:
return redirect(
url_for(self.get_url_name('export'), id__in=id_list))
return render_template(
'admin/models/index.html',
model_admin=self,
query=pq,
ordering=ordering,
query_filter=query_filter,
)
def ajax_list(self):
field_name = request.args.get('field')
prev_page = 0
next_page = 0
try:
models = path_to_models(self.model, field_name)
except AttributeError:
data = []
else:
field = self.model._meta.fields[field_name]
rel_model = models.pop()
rel_field = rel_model._meta.fields[
self.foreign_key_lookups[field_name]]
query = rel_model.select().order_by(rel_field)
query_string = request.args.get('query')
if query_string:
query = query.where(rel_field**('%%%s%%' % query_string))
pq = PaginatedQuery(query, self.filter_paginate_by)
current_page = pq.get_page()
if current_page > 1:
prev_page = current_page - 1
if current_page < pq.get_pages():
next_page = current_page + 1
data = []
# if the field is nullable, include the "None" option at the top of the list
if field.null:
data.append({'id': '__None', 'repr': 'None'})
data.extend([{
'id': obj._pk,
'repr': str(obj)
} for obj in pq.get_list()])
json_data = json.dumps(
{
'prev_page': prev_page,
'next_page': next_page,
'object_list': data
},
cls=StringifyingEncoder)
return Response(json_data, mimetype='application/json')
def user_detail(user_id):
teams = [t for t in Team.select() if can(auth.get_logged_in_user(),READ,t)]
user = get_object_or_404(User, User.id == user_id)
ensure(READ,user)
scores = Score.select().where(Score.user == user).order_by(Score.created_at.desc())
users = [u for u in User.select().where(User.team == user.team) if can(auth.get_logged_in_user(),READ,u)]
pq = PaginatedQuery(scores, 20)
last_date = datetime.now() - timedelta(days=5)
return render_template("index.html", active_user=user, teams=teams, users=users, pagination=pq, page=pq.get_page(), active_team = user.team, weeks = [w for w in Week.select().where(Week.end > last_date) if not has_score(w.score_set)])
def paginated_object_list(self, filtered_query):
try:
paginate_by = int(request.args.get('limit', self.paginate_by))
except ValueError:
paginate_by = self.paginate_by
else:
if self.paginate_by:
paginate_by = min(paginate_by, self.paginate_by) # restrict
pq = PaginatedQuery(filtered_query, paginate_by)
meta_data = self.get_request_metadata(pq)
query_dict = self.serialize_query(pq.get_list())
return self.response({
'meta': meta_data,
'objects': query_dict,
})
def index(self):
if request.method == 'POST':
id_list = request.form.getlist('id')
action = request.form['action']
if action == 'delete':
return redirect(
url_for(self.get_url_name('delete'), id=id_list))
elif action == 'export':
return redirect(
url_for(self.get_url_name('export'), id=id_list))
elif action in self.action_map:
id_list = request.form.getlist('id')
if not id_list:
flash('Please select one or more rows.', 'warning')
else:
action_obj = self.action_map[action]
maybe_response = action_obj.callback(id_list)
if isinstance(maybe_response, Response):
return maybe_response
else:
flash('Unknown action: "%s".' % action, 'danger')
return self._index_redirect()
session['%s.index' % self.get_admin_name()] = request.url
query = self.get_query()
ordering = request.args.get('ordering') or ''
query = self.apply_ordering(query, ordering)
# process the filters from the request
filter_form, query, cleaned, field_tree = self.process_filters(query)
# create a paginated query out of our filtered results
pq = PaginatedQuery(query, self.paginate_by)
return render_template(self.templates['index'],
model_admin=self,
query=pq,
ordering=ordering,
filter_form=filter_form,
field_tree=field_tree,
active_filters=cleaned,
**self.get_extra_context())
def _select(self, form, account, csv=False):
select_result = Invoice_model.select().join(Shop).join(Account).where(
Account.id == account.id)
if form.get('shop_id'):
select_result = select_result.where(Shop.id == form['shop_id'])
if form.get('invoice_id'):
select_result = select_result.where(
Invoice_model.id == form['invoice_id'])
if form.get('shop_invoice_id'):
select_result = select_result.where(
Invoice_model.shop_invoice_id == form['shop_invoice_id'])
if form.getlist('paymethod') and form.getlist('paymethod')[0] != '':
select_result = select_result.join(
InvoicePayway,
on=InvoicePayway.id == Invoice_model.payway).join(
PayMethod).where(PayMethod.id << form.getlist('paymethod'))
if form.getlist(
'shop_currency') and form.getlist('shop_currency')[0] != '':
select_result = select_result.where(
Invoice_model.shop_currency << form.getlist('shop_currency'))
if form.getlist('status') and form.getlist('status')[0] != '':
select_result = select_result.where(
Invoice_model.status << form.getlist('status'))
if form.getlist(
'ps_currency') and form.getlist('ps_currency')[0] != '':
select_result = select_result.where(
Invoice_model.ps_currency << form.getlist('ps_currency'))
if form.get('created_from'):
created_from = self._try_parse_datetime(form['created_from'])
select_result = select_result.where(
Invoice_model.created > created_from)
if form.get('created_to'):
created_to = self._try_parse_datetime(form["created_to"])
select_result = select_result.where(
Invoice_model.created < created_to)
if not csv:
pages_count = PaginatedQuery(
select_result.order_by(
Invoice_model.id.desc()).limit(SELECT_LIMIT),
RECORDS_PER_PAGE).get_pages()
return Struct(invoices=[
Invoice(inv) for inv in PaginatedQuery(
select_result.order_by(Invoice_model.id.desc()).limit(
SELECT_LIMIT), RECORDS_PER_PAGE).get_list()
],
pages_count=pages_count)
return [
Invoice(inv) for inv in select_result.order_by(
Invoice_model.id.desc()).limit(SELECT_LIMIT)
]
