def test_mutable_copy(self):
"""A copy of a QueryDict is mutable."""
q = QueryDict(str('')).copy()
self.assertRaises(KeyError, q.__getitem__, "foo")
q['name'] = 'john'
self.assertEqual(q['name'], 'john')
def resultsearchrule(request, id=None):
if request.FILES:
uploaded_file = request.FILES['file']
str_text = ''
for line in uploaded_file:
str_text = str_text + line.decode(
) # "str_text" will be of `str` type
file_name_upload = str(request.FILES['file'])
with open(file_name_upload, 'w') as f:
f.write(str_text)
dict_file.update([(str(request.FILES['file']), file_name_upload)])
# do something
elif request.method == "POST":
response_data = {'result': {}}
fromJs = QueryDict(request.body)
listResult = []
if fromJs['content'] == "":
response_data = {"result": "Bạn chưa nhập dữ liệu."}
return render(request,
'first_app/resultsearchrule.html',
context={"result": str(response_data)})
else:
#reg = web.list_regular(fromJs['content'])
for name in dict_file:
file_name = name
list_command = open(file_name, 'r').readlines()
list_ip = fromJs['content']
# print(list_command)
result_func = web.search_rule(file_name, list_command, list_ip)
response_data['result'].update(result_func)
# pprint.pprint(response_data)
dict_file.clear()
THIS_FOLDER = os.path.dirname(
os.path.dirname(os.path.abspath(__file__)))
os.chdir(THIS_FOLDER)
my_folder = os.getcwd()
my_file_source = os.path.join(my_folder, file_name + '.csv')
with open(my_file_source, 'w', newline='') as file:
writer = csv.writer(file)
writer.writerow([
"Configuration", "Rule Type delete", "Device",
"Policy/Term name", "application", "Protocol",
"Source VLAN", "Source IP", "Source Port", "Dest VLAN",
"Dest IP", "Dest Port"
])
for filename in response_data['result']:
for dict_rule in response_data['result'][filename]:
for rule in response_data['result'][filename][
dict_rule]:
rule_detail = response_data['result'][filename][
dict_rule][rule]
conf = rule_detail['config']
rule_type_delete = dict_rule
device = filename
term_name = rule_detail['term']
application = rule_detail['application']
protocol = rule_detail['protocol']
source_vlan = rule_detail['fzone']
source_ip = rule_detail['sourceip']
dest_ip = rule_detail['destip']
dest_vlan = rule_detail['tzone']
source_port = rule_detail['sourceport']
dest_port = rule_detail['destport']
writer.writerow([
conf, device, term_name, application, protocol,
source_vlan, source_ip, source_port, dest_vlan,
dest_ip, dest_port
])
my_file_dest = os.path.join(my_folder, "static",
file_name + '.csv')
shutil.move(my_file_source, my_file_dest)
return render(request,
'first_app/resultsearchrule.html',
context={
"result": dict(response_data['result']),
"filename": file_name + ".csv"
})
return render(request, 'first_app/resultsearchrule.html')
def _make_query_url(url, query):
encoded = QueryDict('', mutable=True)
encoded.update(query)
return "%s?%s" % (url, encoded.urlencode())
def AssetsEditView(request, pk):
data = QueryDict(request.body)
jsondata = data.dict()
Assets.objects.filter(pk=pk).update(**jsondata)
return HttpResponse("编辑成功!")
def GET(self):
return QueryDict(self.META['QUERY_STRING'])
def post(self, request):
params = QueryDict(request.body)
if request.META.get('HTTP_X_FORWARDED_FOR'):
ip = request.META.get('HTTP_X_FORWARDED_FOR')
else:
ip = request.META.get('REMOTE_ADDR')
if ip in getattr(settings, 'BLOCKED_IPS', []):
return HttpResponseForbidden('<h1>Forbbidden</h1>')
user = ShangmiUser.objects.get(
pk=int(user_cache.get(params.get("token"))))
order_id = params.get('order_id')
amount = params.get("need")
log = UserPayLog.objects.get(id=order_id)
randuuid = uuid.uuid4()
nonce_str = str(randuuid).replace('-', '')
out_trade_no = log.wx_pay_num
# log.wx_pay_num = out_trade_no
# log.save()
url = 'https://api.mch.weixin.qq.com/pay/unifiedorder'
data = {}
data['body'] = 'ShangMi'.encode('utf-8')
data['mch_id'] = settings.MCHID
data['nonce_str'] = nonce_str
# data['device_info'] = 'WEB'
data['total_fee'] = str(int(amount))
data['spbill_create_ip'] = ip
# data['fee_type'] = 'CNY'
data['openid'] = user.openid
data['out_trade_no'] = out_trade_no
data['notify_url'] = 'https://sharemsg.cn/shangmi/api/v1/pay/notify'
data['appid'] = settings.PAY_APPID
data['trade_type'] = 'JSAPI'
data['sign'] = sign(data, settings.PAY_KEY)
template = """
<xml>
<appid>{appid}</appid>
<body>{body}</body>
<mch_id>{mch_id}</mch_id>
<nonce_str>{nonce_str}</nonce_str>
<notify_url>{notify_url}</notify_url>
<openid>{openid}</openid>
<out_trade_no>{out_trade_no}</out_trade_no>
<spbill_create_ip>{spbill_create_ip}</spbill_create_ip>
<total_fee>{total_fee}</total_fee>
<trade_type>{trade_type}</trade_type>
<sign>{sign}</sign>
</xml>
"""
content = template.format(**data)
headers = {'Content-Type': 'application/xml'}
raw = requests.post(url, data=content, headers=headers)
rdict = xml_response_to_dict(raw)
# print('=------',rdict, '--------------')
return_data = {}
if rdict['return_code'] == 'SUCCESS' and rdict[
'result_code'] == 'SUCCESS':
randuuid = uuid.uuid4()
nonce_str = str(randuuid).replace('-', '')
time_stamp = str(int(time.time()))
sign_data = {}
sign_data['appId'] = rdict['appid']
sign_data['nonceStr'] = nonce_str
sign_data['package'] = 'prepay_id=%s' % rdict['prepay_id']
sign_data['signType'] = 'MD5'
sign_data['timeStamp'] = time_stamp
paySign = sign(sign_data, settings.PAY_KEY)
return_data['appId'] = rdict['appid']
return_data['paySign'] = paySign
return_data['nonceStr'] = nonce_str
return_data['timeStamp'] = time_stamp
return_data['package'] = 'prepay_id=%s' % rdict['prepay_id']
return_data['signType'] = 'MD5'
return JsonResponse({'data': return_data, "code": 0})
else:
return JsonResponse({'code': 1, 'data': u'支付失败'})
def _build_POST(self, job_data):
return QueryDict(job_data['POST'].encode('utf8'))
def put(self, request, **kwargs):
webdata = QueryDict(request.body).dict()
print(webdata)
pk = kwargs.get('pk')
self.model.objects.filter(pk=pk).update(**webdata)
return JsonResponse({'status': 0})
def quiz_resultaat(request, quiz_id):
quiz = Quiz.objects.get(pk=quiz_id)
vragen_list = quiz.vraag_set.all()
user_antwoorden = []
max_score = 0
score = 0
q = QueryDict()
q = request.POST
user_antwoorden.extend(q.items())
user_antwoorden.pop(0)
user_antwoord_ids = [antwoord[0] for antwoord in user_antwoorden]
user_antwoord_ids = [id for id in user_antwoord_ids if str.isdigit(id)]
# Map list naar integers
user_antwoord_ids = list(map(int, user_antwoord_ids))
# Check of de vraag een ja/nee vraag is en indien ja, vervang vraag id naar antwoord id als het gegeven antwoord juist is.
for id in user_antwoord_ids:
for vraag in vragen_list:
if vraag.id == id and vraag.vraag_type == 'jaNee':
user_antwoord = request.POST.get(str(id))
juiste_antwoord = vraag.antwoord_set.get(antwoord_juist=True)
if user_antwoord.lower() == juiste_antwoord.antwoord_tekst.lower():
user_antwoord_ids.remove(id)
user_antwoord_ids.append(juiste_antwoord.id)
else:
user_antwoord_ids.remove(id)
juiste_antwoorden = Antwoord.objects.filter(antwoord_juist=True)
# Totale score berekenen per quiz.
for vraag in vragen_list:
juiste_antwoorden_per_quiz = vraag.antwoord_set.filter(antwoord_juist=True)
for antwoord in juiste_antwoorden_per_quiz:
max_score += antwoord.antwoord_score
def get_antwoord_ids():
list_ids = []
for vraag in vragen_list:
juiste_antwoorden = vraag.antwoord_set.filter(antwoord_juist=True)
for antwoord in juiste_antwoorden:
list_ids.append(antwoord.id)
return list_ids
juiste_antwoorden_ids = get_antwoord_ids()
# Vergelijken tussen gegeven antwoorden en de juiste antwoorden.
matches = set(user_antwoord_ids).intersection(juiste_antwoorden_ids)
for match in matches:
vraag = Antwoord.objects.get(id=match).vraag
juist_antwoord = Antwoord.objects.get(id=match)
if vraag.vraag_type == 'open':
user_value = q.get(str(match))
if user_value.lower() == juist_antwoord.antwoord_tekst.lower():
score += juist_antwoord.antwoord_score
else:
score += juist_antwoord.antwoord_score
return render(request, 'resultaat.html', {'user_score': score, 'max_score': max_score, 'max_score_helft': max_score / 2})
def test_immutable_get_with_default(self):
q = QueryDict(str(''))
self.assertEqual(q.get('foo', 'default'), 'default')
def post(self, request):
webdata = QueryDict(request.body).dict()
env = webdata.get('env')
qs = dbconf.objects.filter(env=env)
dbs = [obj.name for obj in qs]
return JsonResponse({'status': 0,'data':dbs})
def test_missing_key(self):
q = QueryDict(str(''))
self.assertRaises(KeyError, q.__getitem__, 'foo')
def test_update_from_querydict(self):
"""Regression test for #8278: QueryDict.update(QueryDict)"""
x = QueryDict(str("a=1&a=2"), mutable=True)
y = QueryDict(str("a=3&a=4"))
x.update(y)
self.assertEqual(x.getlist('a'), ['1', '2', '3', '4'])
def test_mutable_delete(self):
q = QueryDict(str('')).copy()
q['name'] = 'john'
del q['name']
self.assertFalse('name' in q)
def get_filters(self):
"""Parse querystring and returns a dict."""
return QueryDict(self.querystring, mutable=True)
except (urllib2.HTTPError, urllib2.URLError), e:
logger.warn('facebook encountered a timeout or error %s',
unicode(e))
attempts -= 1
if not attempts:
raise
finally:
if response_file:
response_file.close()
try:
parsed_response = json.loads(response)
logger.info('facebook send response %s' % parsed_response)
except Exception, e:
#using exception because we need to support multiple json libs :S
parsed_response = QueryDict(response, True)
logger.info('facebook send response %s' % parsed_response)
if parsed_response and isinstance(parsed_response, dict):
#of course we have two different syntaxes
if parsed_response.get('error'):
cls.raise_error(parsed_response['error']['type'],
parsed_response['error']['message'])
elif parsed_response.get('error_code'):
cls.raise_error(parsed_response['error_code'],
parsed_response['error_msg'])
return parsed_response
@classmethod
def raise_error(self, type, message):
def execute_directly(request,
query,
query_server=None,
design=None,
on_success_url=None,
on_success_params=None,
**kwargs):
"""
execute_directly(request, query_msg, tablename, design) -> HTTP response for execution
This method wraps around dbms.execute_query() to take care of the HTTP response
after the execution.
query
The HQL model Query object.
query_server
To which Query Server to submit the query.
Dictionary with keys: ['server_name', 'server_host', 'server_port'].
design
The design associated with the query.
on_success_url
Where to go after the query is done. The URL handler may expect an option "context" GET
param. (See ``watch_query``.) For advanced usage, on_success_url can be a function, in
which case the on complete URL is the return of:
on_success_url(history_obj) -> URL string
Defaults to the view results page.
on_success_params
Optional params to pass to the on_success_url (in additional to "context").
Note that this may throw a Beeswax exception.
"""
if design is not None:
authorized_get_design(request, design.id)
db = dbms.get(request.user, query_server)
database = query.query.get('database', 'default')
db.use(database)
query_history = db.execute_query(query, design)
watch_url = reverse(get_app_name(request) + ':watch_query_history',
kwargs={'query_history_id': query_history.id})
# Prepare the GET params for the watch_url
get_dict = QueryDict(None, mutable=True)
# (1) on_success_url
if on_success_url:
if callable(on_success_url):
on_success_url = on_success_url(query_history)
get_dict['on_success_url'] = on_success_url
# (2) misc
if on_success_params:
get_dict.update(on_success_params)
return format_preserving_redirect(request, watch_url, get_dict)
def _test(data, expected, **kwargs):
fs = FooFilterSet(data=QueryDict(data), queryset=[], **kwargs)
assert set(fs.get_specs()) == set(expected)
# By default List[anything] is treated for body
return {
"body": body,
}
client = NinjaClient(router)
@pytest.mark.parametrize(
# fmt: off
"path,kwargs,expected_response",
[
(
"/list1?query=1&query=2",
dict(data=QueryDict("form=3&form=4")),
{
"query": [1, 2],
"form": [3, 4]
},
),
(
"/list2?query=1&query=2",
dict(json=[5, 6]),
{
"query": [1, 2],
"body": [5, 6]
},
),
(
"/list3",
def test_from_querydict(self):
di = dict(a=1, b=[2, 3])
self.assertEqual(to_querydict(di), QueryDict("a=1&b=2&b=3"))
def handle_successful_payment(sender, **kwargs):
from course.models import Enrollment, Session, reset_classes_json
# these two errors occurred because of the donate button on the front page.
# they can be removed by checking for that
if not sender.txn_type == "cart":
# handled by membership.listeners
return
params = QueryDict(sender.query)
_uid = str(params.get('custom', None))
user, new_user = get_or_create_student(params)
user.active = True
user.save()
if params.get('invoice', None):
return handle_successful_store_payment(sender, user)
if not "num_cart_items" in params:
mail_admins("No cart items found for %s" % sender.txn_id, "")
return
item_count = int(params['num_cart_items'])
enrollments = []
error_sessions = []
fails = []
for i in range(1, item_count + 1):
pp_amount = float(params['mc_gross_%d' % i])
quantity = int(params['quantity%s' % i])
try:
session = Session.objects.get(id=int(params['item_number%d' %
(i, )]))
except Session.DoesNotExist:
fails.append(("Session not found", traceback.format_exc()))
continue
except ValueError:
fails.append(
("Non-integer session number", traceback.format_exc()))
continue
enrollment, new = Enrollment.objects.get_or_create(user=user,
session=session)
if enrollment.transaction_ids and (sender.txn_id
in enrollment.transaction_ids):
fails.append(
("Multiple transaction ids blocked for enrollment #%s" %
enrollment.id, ""))
continue
enrollment.transaction_ids = (enrollment.transaction_ids
or "") + sender.txn_id + "|"
NotifyCourse.objects.filter(user=user, course=session.course).delete()
if new:
enrollment.quantity = quantity
else:
enrollment.quantity += quantity
enrollment.save()
enrollments.append(enrollment)
price_multiplier = (100 - user.level.discount_percentage) / 100.
# We're ignoring people who overpay since this happens when a member doesn't login (no discount)
if pp_amount < price_multiplier * session.course.fee * int(quantity):
l = [
"PP cost: %s" % pp_amount,
"Expected Cost: %s" %
(price_multiplier * session.course.fee * int(quantity)),
"discount: %s" % user.level.discount_percentage,
"Session Fee: %s" % session.course.fee,
"Session Id: %s" % session.id,
"Quantity: %s" % enrollment.quantity,
"PP Email: %s" % sender.payer_email,
"U Email: %s" % user.email,
"u_id: %s" % _uid, #if this is none they won't get a discount
]
error_sessions.append("\n".join(l))
if enrollment.session.total_students > enrollment.session.course.max_students:
s = "Session #%s overfilled. Please see https://txrxlabs.org/admin/course/session/%s/"
mail_admins("My Course over floweth",
s % (enrollment.session.pk, enrollment.session.pk))
if fails:
body = "=======\n\n".join(["%s\n%s\n\n" % (s, b) for s, b in fails])
mail_admins("%s fails in purchasing process" % len(fails), body)
values = {
'enrollments': enrollments,
'user': user,
'new_user': new_user,
'settings': settings
}
if enrollments:
body = render_to_string("email/course_enrollment.html", values)
subject = "Course enrollment confirmation"
send_mail(subject, body, settings.DEFAULT_FROM_EMAIL, [user.email])
if error_sessions:
mail_admins("Enrollment Error", "\n\n".join(error_sessions))
reset_classes_json("classes reset during course enrollment")
def simple(request):
if request.method == 'POST':
# print(request.POST)
query_dict = QueryDict('', mutable=True)
query_dict.update(request.POST)
# тут забираю код с формы и оформляю его в виде .py файла
# print("RAW POST DATA: {}".format(request.POST['text']))
code = request.POST['text']
query_dict['text'] = code
# добавляем к возвращенному run_algorithm датафрейму вызов метода сохранения его в .json
code = code.strip() + ".to_json('perf.json')"
# pprint(code)
with open('temp.py', 'w', encoding='utf-8') as f:
f.write(code)
# выводит текущую рабочую директорию
# print(os.path.abspath(os.getcwd()))
# запускает python из среды zip и выполняет подготовленный скрипт
process = subprocess.Popen(
["..\Zipline\env\zip\Scripts\python.exe", "-W ignore", "temp.py"],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
data = process.communicate()
# выводы print() скрипта
output = "; ".join(str(data[0]).split(r'\r\n'))[2:-2]
form = SnippetForm(query_dict)
# form.save()
df = pd.read_json('perf.json')
# plot_div = plot([{'x': df.index, 'y': df[col], 'name': col} for col in df.columns], output_type='div')
plot_div = plot([{
'x': df.index,
'y': df['portfolio_value'],
'name': 'portfolio'
}],
output_type='div')
with open("plot_div", 'w') as f:
f.write(plot_div)
# pprint(plot_div)
# пример отрисовки графика с помощью plotly
# x_data = [0,1,2,3]
# y_data = [x**2 for x in x_data]
# plot_div = plot([Scatter(x=x_data, y=y_data,
# mode='lines', name='test',
# opacity=0.8, marker_color='green')],
# output_type='div')
# return render(request, "/editor", context={'plot_div': plot_div})
with open("plot_div", 'r') as f:
plot_div = f.read()
# pprint(plot_div)
return render(request,
"snippets.html",
context={
"form": form,
"snippets": "",
"output": output,
"plot_div": plot_div
})
else:
form = SnippetForm()
snippets = []
return render(
request,
"snippets.html",
{
"form": form,
# "snippets": Snippet.objects.all(),
"snippets": "",
"output": "",
"plot_div": ""
})
def check_course_access(course,
user,
action,
check_if_enrolled=False,
check_survey_complete=True):
"""
Check that the user has the access to perform the specified action
on the course (CourseDescriptor|CourseOverview).
check_if_enrolled: If true, additionally verifies that the user is enrolled.
check_survey_complete: If true, additionally verifies that the user has completed the survey.
"""
# Allow staff full access to the course even if not enrolled
if has_access(user, 'staff', course.id):
return
request = get_current_request()
check_content_start_date_for_masquerade_user(course.id, user, request,
course.start)
access_response = has_access(user, action, course, course.id)
if not access_response:
# Redirect if StartDateError
if isinstance(access_response, StartDateError):
start_date = strftime_localized(course.start, 'SHORT_DATE')
params = QueryDict(mutable=True)
params['notlive'] = start_date
raise CourseAccessRedirect(
'{dashboard_url}?{params}'.format(
dashboard_url=reverse('dashboard'),
params=params.urlencode()), access_response)
# Redirect if AuditExpiredError
if isinstance(access_response, AuditExpiredError):
params = QueryDict(mutable=True)
params[
'access_response_error'] = access_response.additional_context_user_message
raise CourseAccessRedirect(
'{dashboard_url}?{params}'.format(
dashboard_url=reverse('dashboard'),
params=params.urlencode()), access_response)
# Redirect if the user must answer a survey before entering the course.
if isinstance(access_response, MilestoneAccessError):
raise CourseAccessRedirect(
'{dashboard_url}'.format(dashboard_url=reverse('dashboard'), ),
access_response)
# Deliberately return a non-specific error message to avoid
# leaking info about access control settings
raise CoursewareAccessException(access_response)
if check_if_enrolled:
# If the user is not enrolled, redirect them to the about page
if not CourseEnrollment.is_enrolled(user, course.id):
raise CourseAccessRedirect(
reverse('about_course', args=[six.text_type(course.id)]))
# Redirect if the user must answer a survey before entering the course.
if check_survey_complete and action == 'load':
if is_survey_required_and_unanswered(user, course):
raise CourseAccessRedirect(
reverse('course_survey', args=[six.text_type(course.id)]))
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.language = "en"
self.base_valid_query = QueryDict("barcode_length=12&paper_size=a4")
def _parse_response(self, response):
"""Turn the PayPal response into a dict"""
q = QueryDict(response, encoding='UTF-8').dict()
return {k.lower(): v for k, v in q.items()}
def test_subtitle_letter(self):
query = QueryDict("paper_size=letter")
generator = LeftRightCardsResourceGenerator(query)
self.assertEqual(generator.subtitle, "letter")
def send_bookkeeper_email(month=None, year=None, emails=None):
today = datetime.date.today()
# now, make sure that we send out LAST month's invoices if we did
# not specify a month or year.
today = get_previous_month_date_range(today)[0]
month = month or today.month
year = year or today.year
from corehq.apps.accounting.interface import InvoiceInterface
request = HttpRequest()
params = urlencode((
('report_filter_statement_period_use_filter', 'on'),
('report_filter_statement_period_month', month),
('report_filter_statement_period_year', year),
))
request.GET = QueryDict(params)
request.couch_user = FakeUser(
domain="hqadmin",
username="******",
)
invoice = InvoiceInterface(request)
invoice.is_rendered_as_email = True
first_of_month = datetime.date(year, month, 1)
email_context = {
'month': first_of_month.strftime("%B"),
}
email_content = render_to_string('accounting/email/bookkeeper.html',
email_context)
email_content_plaintext = render_to_string(
'accounting/email/bookkeeper.txt', email_context)
format_dict = Format.FORMAT_DICT[Format.CSV]
excel_attachment = {
'title': 'Invoices_%(period)s.%(extension)s' % {
'period': first_of_month.strftime('%B_%Y'),
'extension': format_dict['extension'],
},
'mimetype': format_dict['mimetype'],
'file_obj': invoice.excel_response,
}
emails = emails or settings.BOOKKEEPER_CONTACT_EMAILS
for email in emails:
send_HTML_email(
"Invoices for %s" %
datetime.date(year, month, 1).strftime(USER_MONTH_FORMAT),
email,
email_content,
email_from=settings.DEFAULT_FROM_EMAIL,
text_content=email_content_plaintext,
file_attachments=[excel_attachment],
)
log_accounting_info(
"Sent Bookkeeper Invoice Summary for %(month)s "
"to %(emails)s." % {
'month': first_of_month.strftime(USER_MONTH_FORMAT),
'emails': ", ".join(emails)
})
def exercises(request, **kwargs):
"""
List of Exercises, Tagged exercises, and Exercises without problems.
matching search query or user selection
"""
#before = datetime.datetime.now()
if request.method != 'GET':
return HttpResponseNotAllowed(['GET'])
search_state = SearchState(
user_logged_in=request.user.is_authenticated(),
**kwargs
)
page_size = int(askbot_settings.DEFAULT_EXERCISES_PAGE_SIZE)
qs, meta_data = models.Thread.objects.run_advanced_search(
request_user=request.user, search_state=search_state
)
if meta_data['non_existing_tags']:
search_state = search_state.remove_tags(meta_data['non_existing_tags'])
paginator = Paginator(qs, page_size)
if paginator.num_pages < search_state.page:
search_state.page = 1
page = paginator.page(search_state.page)
page.object_list = list(page.object_list) # evaluate the queryset
# INFO: Because for the time being we need exercise posts and thread authors
# down the pipeline, we have to precache them in thread objects
models.Thread.objects.precache_view_data_hack(threads=page.object_list)
related_tags = Tag.objects.get_related_to_search(
threads=page.object_list,
ignored_tag_names=meta_data.get('ignored_tag_names',[])
)
tag_list_type = askbot_settings.TAG_LIST_FORMAT
if tag_list_type == 'cloud': #force cloud to sort by name
related_tags = sorted(related_tags, key = operator.attrgetter('name'))
contributors = list(
models.Thread.objects.get_thread_contributors(
thread_list=page.object_list
).only('id', 'username', 'gravatar')
)
paginator_context = {
'is_paginated' : (paginator.count > page_size),
'pages': paginator.num_pages,
'page': search_state.page,
'has_previous': page.has_previous(),
'has_next': page.has_next(),
'previous': page.previous_page_number(),
'next': page.next_page_number(),
'base_url' : search_state.query_string(),
'page_size' : page_size,
}
# We need to pass the rss feed url based
# on the search state to the template.
# We use QueryDict to get a querystring
# from dicts and arrays. Much cleaner
# than parsing and string formating.
rss_query_dict = QueryDict("").copy()
if search_state.query:
# We have search string in session - pass it to
# the QueryDict
rss_query_dict.update({"q": search_state.query})
if search_state.tags:
# We have tags in session - pass it to the
# QueryDict but as a list - we want tags+
rss_query_dict.setlist("tags", search_state.tags)
context_feed_url = '/%sfeeds/rss/?%s' % (settings.ASKBOT_URL, rss_query_dict.urlencode()) # Format the url with the QueryDict
reset_method_count = len(filter(None, [search_state.query, search_state.tags, meta_data.get('author_name', None)]))
if request.is_ajax():
q_count = paginator.count
exercise_counter = ungettext('%(q_num)s exercise', '%(q_num)s exercises', q_count)
exercise_counter = exercise_counter % {'q_num': humanize.intcomma(q_count),}
if q_count > page_size:
paginator_tpl = get_template('main_page/paginator.html', request)
paginator_html = paginator_tpl.render(Context({
'context': functions.setup_paginator(paginator_context),
'exercises_count': q_count,
'page_size' : page_size,
'search_state': search_state,
}))
else:
paginator_html = ''
exercises_tpl = get_template('main_page/exercises_loop.html', request)
exercises_html = exercises_tpl.render(Context({
'threads': page,
'search_state': search_state,
'reset_method_count': reset_method_count,
'request': request
}))
ajax_data = {
'query_data': {
'tags': search_state.tags,
'sort_order': search_state.sort,
'ask_query_string': search_state.ask_query_string(),
},
'paginator': paginator_html,
'exercise_counter': exercise_counter,
'faces': [],#[extra_tags.gravatar(contributor, 48) for contributor in contributors],
'feed_url': context_feed_url,
'query_string': search_state.query_string(),
'page_size' : page_size,
'exercises': exercises_html.replace('\n',''),
'non_existing_tags': meta_data['non_existing_tags']
}
ajax_data['related_tags'] = [{
'name': escape(tag.name),
'used_count': humanize.intcomma(tag.local_used_count)
} for tag in related_tags]
return HttpResponse(simplejson.dumps(ajax_data), mimetype = 'application/json')
else: # non-AJAX branch
template_data = {
'active_tab': 'exercises',
'author_name' : meta_data.get('author_name',None),
'contributors' : contributors,
'context' : paginator_context,
'is_without_problem' : False,#remove this from template
'interesting_tag_names': meta_data.get('interesting_tag_names', None),
'ignored_tag_names': meta_data.get('ignored_tag_names', None),
'subscribed_tag_names': meta_data.get('subscribed_tag_names', None),
'language_code': translation.get_language(),
'name_of_anonymous_user' : models.get_name_of_anonymous_user(),
'page_class': 'main-page',
'page_size': page_size,
'query': search_state.query,
'threads' : page,
'exercises_count' : paginator.count,
'reset_method_count': reset_method_count,
'scope': search_state.scope,
'show_sort_by_relevance': conf.should_show_sort_by_relevance(),
'search_tags' : search_state.tags,
'sort': search_state.sort,
'tab_id' : search_state.sort,
'tags' : related_tags,
'tag_list_type' : tag_list_type,
'font_size' : extra_tags.get_tag_font_size(related_tags),
'display_tag_filter_strategy_choices': conf.get_tag_display_filter_strategy_choices(),
'email_tag_filter_strategy_choices': const.TAG_EMAIL_FILTER_STRATEGY_CHOICES,
'update_avatar_data': schedules.should_update_avatar_data(request),
'query_string': search_state.query_string(),
'search_state': search_state,
'feed_url': context_feed_url,
}
return render_into_skin('main_page.html', template_data, request)
def assertRedirects(self,
response,
expected_url,
status_code=302,
target_status_code=200,
host=None,
msg_prefix=''):
"""Asserts that a response redirected to a specific URL, and that the
redirect URL can be loaded.
Note that assertRedirects won't work for external links since it uses
TestClient to do a request.
"""
if msg_prefix:
msg_prefix += ": "
if hasattr(response, 'redirect_chain'):
# The request was a followed redirect
self.assertTrue(
len(response.redirect_chain) > 0,
msg_prefix + "Response didn't redirect as expected: Response"
" code was %d (expected %d)" %
(response.status_code, status_code))
self.assertEqual(
response.redirect_chain[0][1], status_code,
msg_prefix + "Initial response didn't redirect as expected:"
" Response code was %d (expected %d)" %
(response.redirect_chain[0][1], status_code))
url, status_code = response.redirect_chain[-1]
self.assertEqual(
response.status_code, target_status_code,
msg_prefix + "Response didn't redirect as expected: Final"
" Response code was %d (expected %d)" %
(response.status_code, target_status_code))
else:
# Not a followed redirect
self.assertEqual(
response.status_code, status_code,
msg_prefix + "Response didn't redirect as expected: Response"
" code was %d (expected %d)" %
(response.status_code, status_code))
url = response['Location']
scheme, netloc, path, query, fragment = urlsplit(url)
redirect_response = response.client.get(path, QueryDict(query))
# Get the redirection page, using the same client that was used
# to obtain the original response.
self.assertEqual(
redirect_response.status_code, target_status_code,
msg_prefix + "Couldn't retrieve redirection page '%s':"
" response code was %d (expected %d)" %
(path, redirect_response.status_code, target_status_code))
e_scheme, e_netloc, e_path, e_query, e_fragment = urlsplit(
expected_url)
if not (e_scheme or e_netloc):
expected_url = urlunsplit(
('http', host or 'testserver', e_path, e_query, e_fragment))
self.assertEqual(
url, expected_url, msg_prefix +
"Response redirected to '%s', expected '%s'" % (url, expected_url))
def process_view(self, request, view_func, view_args, view_kwargs):
if request.method == 'PUT':
request.PUT = QueryDict(request.body)
else:
request.PUT = QueryDict('')
