def test_thread_safety(self):
exceptions = []
def threaded_view(resp_queue, view, request):
import time; time.sleep(2)
try:
inst = view(request)
resp_queue.put(request.GET['name'])
except Exception as e:
exceptions.append(e)
raise
class ThreadedSearchView(SearchView):
def __call__(self, request):
print("Name: %s" % request.GET['name'])
return super(ThreadedSearchView, self).__call__(request)
view = search_view_factory(view_class=ThreadedSearchView)
resp_queue = queue.Queue()
request_1 = HttpRequest()
request_1.GET = {'name': 'foo'}
request_2 = HttpRequest()
request_2.GET = {'name': 'bar'}
th1 = Thread(target=threaded_view, args=(resp_queue, view, request_1))
th2 = Thread(target=threaded_view, args=(resp_queue, view, request_2))
th1.start()
th2.start()
th1.join()
th2.join()
foo = resp_queue.get()
bar = resp_queue.get()
self.assertNotEqual(foo, bar)
def setUp(self):
request1 = HttpRequest()
request1.GET = QueryDict('')
self.context1 = RequestContext(request1)
request2 = HttpRequest()
request2.GET = QueryDict('foo=bar')
self.context2 = RequestContext(request2)
def execute_subscription(sched_id, force_run=False, today=None):
"""Handles creating the report PDF and sending the email.
(A future optimzation could re-use the PDF if multiple Subscriptions of
the same report are running at the same time.)
'today' defaults to current day, but you can set different dates for testing.
This accepts the ID instead of the object itself in order to handle concurrancy issues.
(It would seem to make sense to put this method with the Subscription model, however it leads to
some circular imports so it was cleaner to break it out into a utility function)."""
#Locks record until this function completes
sched_obj = Subscription.objects.select_for_update().get(pk=sched_id)
#check whether we should send
if not force_run:
if not sched_obj.should_send(today=today):
return False
sched_obj.last_scheduled_run = timezone.localtime(timezone.now())
if not getattr(settings, 'MR_REPORTS_WKHTMLTOPDF_PATH','') and getattr(settings, 'BASE_PATH',''):
sched_obj.last_run_succeeded = False
sched_obj.save()
raise ValueError("PDF generation not available. Please add and set 'MR_REPORTS_WKHTMLTOPDF_PATH', and 'BASE_PATH' in your settings.py file.")
#Generate PDF
mock_request = HttpRequest()
mock_request.method = 'GET'
if sched_obj.report_parameters:
mock_request.GET = QueryDict(sched_obj.report_parameters.lstrip('?'))
else:
#If the report has parameters and none are provided, provide dummy GET data
if Parameter.objects.filter(dataset__report=sched_obj.report):
mock_request.GET = QueryDict('use_defaults')
response = render_report(mock_request, report_id=sched_obj.report.pk, format='pdf')
#Send email
full_url = settings.BASE_PATH.rstrip('/') + sched_obj.report.get_absolute_url()
message = """\
Greetings,<br><br>
This is a snapshot of the report '%s'.<br><br>
Go here to view the realtime version of the report and/or change your subscription: <br>
<a href="%s">%s</a>
<br><br>
""" % (sched_obj.report.title, full_url, full_url)
message += sched_obj.email_body_extra
subject = 'Scheduled Report - ' + sched_obj.email_subject
text_content = re.sub(r'<[^>]+>','',message)
html_content = message
msg = EmailMultiAlternatives(subject, text_content, sched_obj.send_to.email, [sched_obj.send_to.email])
msg.attach_alternative(html_content, "text/html")
msg.attach(sched_obj.report.filename()+'.pdf', response.content, response['Content-Type'])
msg.send()
sched_obj.last_run_succeeded = True
sched_obj.save()
return True
def test_items_per_page_tag(self):
with self.settings(PAGINATOR_LIMITS=[10, 25, 50]):
request = HttpRequest()
default_limit = settings.PAGINATOR_LIMITS[0]
default_limit_link = ('<a href="?limit={limit}&offset=0"><span class="hidden">'
'view </span>{limit}'.format(limit=default_limit))
request.GET = QueryDict('', mutable=False)
template = Template(
"{% load pagination_tags %}{% items_per_page request %}")
result = template.render(RequestContext(request, {}))
self.assertIn('<a href="?limit=50&offset=0"><span class="hidden">view </span>50', result)
self.assertNotIn(default_limit_link, result)
request.GET = QueryDict('limit=50', mutable=False)
result = template.render(RequestContext(request, {}))
self.assertNotIn(
'<a href="?limit=50" title="View 50 items per page">50</a>',
result)
self.assertIn(default_limit_link, result)
# test offset
# offset=10, limit=10 -> offset=0, limit=25
# offset=20, limit=10 -> offset=0, limit=25
# offset=30, limit=10 -> offset=25, limit=25
template = Template(
"{% load pagination_tags %}{% items_per_page request %}")
request.GET = QueryDict('limit=10&offset=10', mutable=False)
result = template.render(RequestContext(request, {}))
self.assertNotIn('offset=10', result)
self.assertIn('offset=0', result)
request.GET = QueryDict('limit=10&offset=30', mutable=False)
result = template.render(RequestContext(request, {}))
self.assertNotIn('offset=10', result)
self.assertIn('offset=25', result)
def test_top_level_jsonp(self):
api = Api()
api.register(NoteResource())
api.register(UserResource())
request = HttpRequest()
request.META = {"HTTP_ACCEPT": "text/javascript"}
request.GET = {"callback": "foo"}
resp = api.top_level(request)
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp["content-type"].split(";")[0], "text/javascript")
self.assertEqual(
resp.content.decode("utf-8"),
'foo({"notes": {"list_endpoint": "/api/v1/notes/", "schema": "/api/v1/notes/schema/"}, "users": {"list_endpoint": "/api/v1/users/", "schema": "/api/v1/users/schema/"}})',
)
request = HttpRequest()
request.META = {"HTTP_ACCEPT": "text/javascript"}
request.GET = {"callback": ""}
try:
resp = api.top_level(request)
self.fail("Broken callback didn't fail!")
except BadRequest:
# Regression: We expect this, which is fine, but this used to
# be an import error.
pass
def test_general(self):
"""
Tests the basics: missing referrer, query string etc.
"""
handler = SearchTermHandler(search_terms='alice')
handler.prepare()
req = HttpRequest()
self.assertFalse(handler.check(req))
for ref, result in [
('http://www.google.co.uk/search?not_the_right_param=alice', False),
('gibberish', False),
('', False),
('http://www.example.com/no_query_string/', False),
]:
req.GET = {'r': urllib.quote_plus(ref)}
self.assertTrue(result == handler.check(req), msg='%s should have tested %s' % (ref, result))
#check wildcards aren't possible
handler = SearchTermHandler(search_terms='b*ob frank')
handler.prepare()
for t, result in [ ('baaaaob', False),
('bbbbbbob', False),
]:
req.GET = {'r': urllib.quote_plus('http://www.google.co.uk/search?q=' + t)}
self.assertTrue(result == handler.check(req), msg='%s should have tested %s' % (t, result))
def test_auth_required_error(self):
user = User(first_name='vivek', last_name='chand',
username='******')
user.save()
request = HttpRequest()
request.META = {
'SERVER_NAME': 'testserver',
'SERVER_PORT': 80,
'REMOTE_ADDR': '6457.255.345.123',
}
request.GET = {
'state': xsrfutil.generate_token(settings.SECRET_KEY, user),
}
request.GET = {
'error': 'access_denied',
}
request.user = user
response = auth_required(request)
self.assertEqual(
response.content, 'Access Denied:No code was supplied in the query parameters.')
self.assertEqual(response.status_code, 400)
user.delete()
def test_workflow_04(self):
msgt('(4) Try with HttpRequest - GET')
msg('(a) Try form with HttpRequest object')
h = HttpRequest()
h.GET = self.expected_params
f1 = CheckForExistingLayerForm(h.GET)
self.assertEqual(f1.is_valid(), True)
msg('(b) Try signature validity check - break assertion by sending dict, not HttpRequest')
self.assertRaises(AssertionError, f1.is_signature_valid_check_get, h.GET)
msg('(c) Try signature check with invalid data--no signature key')
h_bad_data = HttpRequest()
h_bad_data.GET = self.test_data
self.assertEqual(f1.is_signature_valid_check_get(h_bad_data), False)
msg('(d) Try signature check with invalid data--bad signature key')
h_bad_data2 = HttpRequest()
h_bad_data2.GET = self.expected_params_bad_signature
self.assertEqual(f1.is_signature_valid_check_get(h_bad_data2), False)
msg('(e) Try signature check with valid data')
self.assertEqual(f1.is_signature_valid_check_get(h), True)
msg('(f) cleaned data.')
self.assertEqual(f1.cleaned_data, self.expected_clean_data)
def test_general(self):
handler = ReferralHandler(url='http://www.example.com')
handler.prepare()
req = HttpRequest()
self.assertFalse(handler.check(req))
for u, result in [(None, False),
('', False),
('http://www.example.com', True),
('http://www.example.com/some_other_folder/index.html', True),
('http://www.exAMPle.com', True),
('http://www.example.co', False),
]:
req.GET = {'r': urllib.quote_plus(u) if u else None}
self.assertTrue(handler.check(req) == result, msg='%s should have returned %s' % (u, result))
handler = ReferralHandler(url='http://www.example.com/ad_result/landing.html')
handler.prepare()
for u, result in [('http://www.example.com', False),
('http://www.example.com/ad_result/landing.html', True),
('http://www.example.com/ad_result/landing.html?gclid=ssdafasefdDFGD3f', True),
]:
req.GET = {'r': urllib.quote_plus(u) if u else None}
self.assertTrue(handler.check(req) == result, msg='%s should have returned %s' % (u, result))
def test_determine_format(self):
serializer = Serializer()
request = HttpRequest()
# Default.
self.assertEqual(determine_format(request, serializer), 'application/json')
# Test forcing the ``format`` parameter.
request.GET = {'format': 'json'}
self.assertEqual(determine_format(request, serializer), 'application/json')
request.GET = {'format': 'jsonp'}
self.assertEqual(determine_format(request, serializer), 'text/javascript')
request.GET = {'format': 'xml'}
self.assertEqual(determine_format(request, serializer), 'application/xml')
request.GET = {'format': 'yaml'}
self.assertEqual(determine_format(request, serializer), 'text/yaml')
request.GET = {'format': 'foo'}
self.assertEqual(determine_format(request, serializer), 'application/json')
# Test the ``Accept`` header.
request.META = {'HTTP_ACCEPT': 'application/json'}
self.assertEqual(determine_format(request, serializer), 'application/json')
request.META = {'HTTP_ACCEPT': 'text/javascript'}
self.assertEqual(determine_format(request, serializer), 'text/javascript')
request.META = {'HTTP_ACCEPT': 'application/xml'}
self.assertEqual(determine_format(request, serializer), 'application/xml')
request.META = {'HTTP_ACCEPT': 'text/yaml'}
self.assertEqual(determine_format(request, serializer), 'text/yaml')
request.META = {'HTTP_ACCEPT': 'text/html'}
self.assertEqual(determine_format(request, serializer), 'text/html')
request.META = {'HTTP_ACCEPT': '*/*'}
self.assertEqual(determine_format(request, serializer), 'application/json')
request.META = {'HTTP_ACCEPT': 'application/json,application/xml;q=0.9,*/*;q=0.8'}
self.assertEqual(determine_format(request, serializer), 'application/json')
request.META = {'HTTP_ACCEPT': 'text/plain,application/xml,application/json;q=0.9,*/*;q=0.8'}
self.assertEqual(determine_format(request, serializer), 'application/xml')
request.META = {'HTTP_ACCEPT': 'application/json; charset=UTF-8'}
self.assertEqual(determine_format(request, serializer), 'application/json')
request.META = {'HTTP_ACCEPT': 'text/javascript,application/json'}
self.assertEqual(determine_format(request, serializer), 'application/json')
def test_determine_format(self):
request = HttpRequest()
resource = UnimplementedDetailResource()
# Default.
self.assertEqual(
resource.determine_format(request), 'application/json')
# Test forcing the ``format`` parameter.
request.GET = {'format': 'json'}
self.assertEqual(
resource.determine_format(request), 'application/json')
request.GET = {'format': 'jsonp'}
self.assertEqual(resource.determine_format(request), 'text/javascript')
request.GET = {'format': 'xml'}
self.assertEqual(resource.determine_format(request), 'application/xml')
request.GET = {'format': 'yaml'}
self.assertEqual(resource.determine_format(request), 'text/yaml')
request.GET = {'format': 'foo'}
self.assertEqual(
resource.determine_format(request), 'application/json')
# Test the ``Accept`` header.
request.META = {'HTTP_ACCEPT': 'application/json'}
self.assertEqual(
resource.determine_format(request), 'application/json')
request.META = {'HTTP_ACCEPT': 'text/javascript'}
self.assertEqual(resource.determine_format(request), 'text/javascript')
request.META = {'HTTP_ACCEPT': 'application/xml'}
self.assertEqual(resource.determine_format(request), 'application/xml')
request.META = {'HTTP_ACCEPT': 'text/yaml'}
self.assertEqual(resource.determine_format(request), 'text/yaml')
request.META = {'HTTP_ACCEPT': 'text/html'}
self.assertEqual(resource.determine_format(request), 'text/html')
request.META = {
'HTTP_ACCEPT': 'application/json,application/xml;q=0.9,*/*;q=0.8'}
self.assertEqual(
resource.determine_format(request), 'application/json')
request.META = {
'HTTP_ACCEPT': \
'text/plain,application/xml,application/json;q=0.9,*/*;q=0.8'}
self.assertEqual(resource.determine_format(request), 'application/xml')
def test_access(self):
# anonymous - always denied
anon = AnonymousUser()
self.assertFalse(auth.archive_access(anon, 'marbl'))
# superuser - always allowed
testadmin = authenticate(username='******', password='******')
self.assertTrue(auth.archive_access(testadmin, 'marbl'))
# no associated archives
peon = authenticate(username='******', password='******')
self.assertFalse(auth.archive_access(peon, 'marbl'))
# associated with an archive
marbl = authenticate(username='******', password='******')
self.assertTrue(auth.archive_access(marbl, 'marbl'))
self.assertFalse(auth.archive_access(marbl, 'eua'))
# archive id from request
req = HttpRequest()
req.GET = {'archive': 'marbl'}
self.assertTrue(auth.archive_access(marbl, request=req))
# should raise an exception when archive is not specified as
# param or request param
self.assertRaises(Exception, auth.archive_access, marbl)
def test_auth_required_get_or_create_throws_None(self, mock_requests_get, mock_step2_exchange):
mock_requests_get.return_value = {
'name': 'Vivek Chand', 'email': '*****@*****.**'}
user = User(first_name='vivek', last_name='chand',
username='******')
user.save()
oauth2_response = {
'access_token': '5435rwesdfsd!!qw4324321eqw23@!@###asdasd',
'id_token': {'id': '42342423432423'}, 'and_some_more': 'blah_blah_blah'}
class credential:
token_response = oauth2_response
invalid = False
mock_step2_exchange.return_value = credential()
request = HttpRequest()
request.META = {
'SERVER_NAME': 'testserver',
'SERVER_PORT': 80,
'REMOTE_ADDR': '6457.255.345.123',
}
request.GET = {
'state': xsrfutil.generate_token(settings.SECRET_KEY, user),
}
request.user = user
response = auth_required(request)
self.assertEqual(response.status_code, 400)
user.delete()
def __call_view__(self, reversed, urlconf):
url_resolution = resolve(reversed, urlconf)
request = HttpRequest()
request.path = reversed
request.method = "GET"
request.GET = {}
return url_resolution.func(request, *url_resolution.args, **url_resolution.kwargs)
def test_login_begin_has_credential(self, login_success_handler, mock_get):
login_success_handler.return_value = HttpResponseRedirect('/somewhere')
user = User(first_name='vivek',
last_name='chand',
username='******')
user.save()
oauth2_response = {
'access_token': '5435rwesdfsd!!qw4324321eqw23@!@###asdasd',
'id_token': {'id': '42342423432423'},
'and_some_more': 'blah_blah_blah'}
class credential:
token_response = oauth2_response
invalid = False
mock_get.return_value = credential()
request = HttpRequest()
request.META = {
'SERVER_NAME': 'testserver',
'SERVER_PORT': 80,
'REMOTE_ADDR': '6457.255.345.123',
}
request.GET = {
'domain': 'vivekchand.info'
}
request.user = user
redirect_response = login_begin(request)
self.assertEqual(redirect_response.status_code, 302)
self.assertTrue(redirect_response.get('Location'), '/somewhere')
user.delete()
def test_check_throttling(self):
resource = ThrottledNoteResource()
request = HttpRequest()
request.GET = {'format': 'json'}
request.method = 'GET'
# Not throttled.
resp = resource.dispatch('list', request)
self.assertEqual(resp.status_code, 200)
self.assertEqual(len(cache.get('noaddr_nohost_accesses')), 1)
# Not throttled.
resp = resource.dispatch('list', request)
self.assertEqual(resp.status_code, 200)
self.assertEqual(len(cache.get('noaddr_nohost_accesses')), 2)
# Throttled.
resp = resource.dispatch('list', request)
self.assertEqual(resp.status_code, 403)
self.assertEqual(len(cache.get('noaddr_nohost_accesses')), 2)
# Throttled.
resp = resource.dispatch('list', request)
self.assertEqual(resp.status_code, 403)
self.assertEqual(len(cache.get('noaddr_nohost_accesses')), 2)
def get_xform_ids(self, request):
if 'select_all' in self.request.POST:
# Altough evaluating form_ids and sending to task would be cleaner,
# heavier calls should be in an async task instead
import six.moves.urllib.request, six.moves.urllib.parse, six.moves.urllib.error
form_query_string = six.moves.urllib.parse.unquote(self.request.POST.get('select_all'))
from django.http import HttpRequest, QueryDict
from django_otp.middleware import OTPMiddleware
_request = HttpRequest()
_request.couch_user = request.couch_user
_request.user = request.couch_user.get_django_user()
_request.domain = self.domain
_request.couch_user.current_domain = self.domain
_request.can_access_all_locations = request.couch_user.has_permission(self.domain,
'access_all_locations')
_request.session = request.session
_request.GET = QueryDict(form_query_string)
OTPMiddleware().process_request(_request)
dispatcher = EditDataInterfaceDispatcher()
xform_ids = dispatcher.dispatch(
_request,
render_as='form_ids',
domain=self.domain,
report_slug=BulkFormManagementInterface.slug,
skip_permissions_check=True,
)
else:
xform_ids = self.request.POST.getlist('xform_ids')
return xform_ids
def decode_request(value):
"""
Decodes a request JSONish value to a HttpRequest object.
"""
request = HttpRequest()
request.GET = CustomQueryDict(value['get'])
request.POST = CustomQueryDict(value['post'])
request.COOKIES = value['cookies']
request.path = value['path']
request.method = value['method']
request.reply_channel = value['reply_channel']
# Channels requests are more high-level than the dumping ground that is
# META; re-combine back into it
request.META = {
"REQUEST_METHOD": value["method"],
"SERVER_NAME": value["server"][0],
"SERVER_PORT": value["server"][1],
"REMOTE_ADDR": value["client"][0],
"REMOTE_HOST": value["client"][0], # Not the DNS name, hopefully fine.
}
for header, header_value in value.get("headers", {}).items():
request.META["HTTP_%s" % header.upper()] = header_value
# We don't support non-/ script roots
request.path_info = value['path']
return request
def fapesp(request, mem):
m = get_object_or_404(MemorandoResposta, pk=mem)
corpos = []
anexos = []
incluidos = {}
if m.anexa_relatorio:
from patrimonio.views import por_termo
from django.contrib.auth.models import User
from django.http import HttpRequest
new_request = HttpRequest()
new_request.user = User.objects.get(email='*****@*****.**')
new_request.GET = {'termo': m.memorando.termo.id, 'agilis': 1, 'modalidade': 1}
new_request.META = {}
response = por_termo(new_request, 1)
anexos.append((response.content, u'Lista patrimonial do processo %s' % m.memorando.termo, 2))
for c in m.corpo_set.all():
if c.anexo:
anexos.append((os.path.join(settings.MEDIA_ROOT, c.anexo.name), u'Pergunta %s' % c.pergunta.numero, 1))
if c.pergunta.numero in incluidos.keys():
corpos[incluidos[c.pergunta.numero]]['respostas'].append(c.resposta)
else:
incluidos.update({c.pergunta.numero: len(corpos)})
corpos.append({'numero': c.pergunta.numero, 'pergunta': c.pergunta.questao, 'respostas': [c.resposta]})
return render_to_pdfxhtml2pdf('memorando/fapesp.pdf', {'m': m, 'corpos': corpos}, request=request,
filename='memorando_%s.pdf' % m.data.strftime('%d_%m_%Y'), attachments=anexos)
def get_report_content(self):
"""
Get the report's HTML content as rendered by the static view format.
"""
try:
if self.report is None:
return _("The report used to create this scheduled report is no"
" longer available on CommCare HQ. Please delete this"
" scheduled report and create a new one using an available"
" report.")
except Exception:
pass
from django.http import HttpRequest, QueryDict
request = HttpRequest()
request.couch_user = self.owner
request.user = self.owner.get_django_user()
request.domain = self.domain
request.couch_user.current_domain = self.domain
request.GET = QueryDict(self.query_string + '&filterSet=true')
try:
response = self._dispatcher.dispatch(request, render_as='email',
**self.view_kwargs)
return json.loads(response.content)['report']
except Exception:
notify_exception(None, "Error generating report")
return _("An error occurred while generating this report.")
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 = utils.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/bookkeeper_email.html', email_context)
email_content_plaintext = render_to_string(
'accounting/bookkeeper_email_plaintext.html', 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("%B %Y"),
email,
email_content,
email_from=settings.DEFAULT_FROM_EMAIL,
text_content=email_content_plaintext,
file_attachments=[excel_attachment],
)
logger.info(
"[BILLING] Sent Bookkeeper Invoice Summary for %(month)s "
"to %(emails)s." % {
'month': first_of_month.strftime("%B %Y"),
'emails': ", ".join(emails)
})
def test_force_switch(self):
"""
If enabled, you can force a switch to be a specific value.
"""
# Request params
OVERRIDE = ("__switcher_force=i.am.enabled:False&" +
"__switcher_force=i.am.disabled:True")
request = HttpRequest()
request.GET = QueryDict(OVERRIDE)
# Not testing POST
request.REQUEST = request.GET
with override_settings(SWITCHER_ALLOW_FORCE=False):
self.assertIs(switch_is_enabled("i.am.enabled", request), True)
self.assertIs(switch_is_enabled("i.am.disabled", request), False)
with override_settings(SWITCHER_ALLOW_FORCE=True):
self.assertIs(switch_is_enabled("i.am.enabled", request), False)
self.assertIs(switch_is_enabled("i.am.disabled", request), True)
# Cookies
request = HttpRequest()
request.COOKIES = {
'__switcher_force_i.am.enabled': 'False',
'__switcher_force_i.am.disabled': 'True'
}
with override_settings(SWITCHER_ALLOW_FORCE=False):
self.assertIs(switch_is_enabled("i.am.enabled", request), True)
self.assertIs(switch_is_enabled("i.am.disabled", request), False)
with override_settings(SWITCHER_ALLOW_FORCE=True):
self.assertIs(switch_is_enabled("i.am.enabled", request), False)
self.assertIs(switch_is_enabled("i.am.disabled", request), True)
def direct_get_response (url, request=None):
"""
Hack to load a view contents without going through the (local) server, work
around for local (testing) server blockage when called form another request
request is optional, but NB the default one is really minimal and may be
missing many things a view may require (like a REQUEST object)... so better
to pass a real request object
Returns response object (resp.content is content in bytes)
"""
if request == None:
request = HttpRequest()
request.user = django.contrib.auth.models.AnonymousUser()
request.REQUEST = {}
request.POST = {}
request.GET = {}
# de-absolutize the URL
rurl = urlparse.urlparse(url).path
(func, args, kwargs) = resolve(rurl)
try:
return func(request, *args, **kwargs)
except Exception, e:
print("aacore.utils.direct_get_response: Exception:", e)
def handle(self, *args, **options):
directory = os.path.join(settings.MEDIA_ROOT, 'sitemaps')
if not os.path.exists(directory):
os.mkdir(directory)
# make fake request
r = HttpRequest()
# do the sitemap index
response = index(r, sitemaps)
f = open(os.path.join(directory, 'sitemap.xml'), 'w')
f.write(response.content)
f.close()
# do all of the individual sitemaps
maps = re.findall(r'<loc>(.*?)</loc>', response.content)
for map in maps:
url = urlparse.urlparse(map)
r.GET = dict(urlparse.parse_qsl(url.query))
section = url.path.split("-").pop().split(".").pop(0)
filename = os.path.join(directory, url.path[1:])
if ('p' in r.GET):
filename += "_p_%s" % r.GET['p']
response = sitemap(r, sitemaps, section)
f = open(filename, 'w')
f.write(response.content)
f.close()
def test_httprequest_repr(self):
request = HttpRequest()
request.path = "/somepath/"
request.GET = {"get-key": "get-value"}
request.POST = {"post-key": "post-value"}
request.COOKIES = {"post-key": "post-value"}
request.META = {"post-key": "post-value"}
self.assertEqual(
repr(request),
str_prefix(
"<HttpRequest\npath:/somepath/,\nGET:{%(_)s'get-key': %(_)s'get-value'},\nPOST:{%(_)s'post-key': %(_)s'post-value'},\nCOOKIES:{%(_)s'post-key': %(_)s'post-value'},\nMETA:{%(_)s'post-key': %(_)s'post-value'}>"
),
)
self.assertEqual(build_request_repr(request), repr(request))
self.assertEqual(
build_request_repr(
request,
path_override="/otherpath/",
GET_override={"a": "b"},
POST_override={"c": "d"},
COOKIES_override={"e": "f"},
META_override={"g": "h"},
),
str_prefix(
"<HttpRequest\npath:/otherpath/,\nGET:{%(_)s'a': %(_)s'b'},\nPOST:{%(_)s'c': %(_)s'd'},\nCOOKIES:{%(_)s'e': %(_)s'f'},\nMETA:{%(_)s'g': %(_)s'h'}>"
),
)
def test_api_with_mock_data_with_two_filters_json_count(self):
request = HttpRequest()
request.GET = QueryDict('min=11&max=21')
found = resolve('/api')
response = found.func(request,data=self.data)
json_data = json.loads(response.content)
self.assertEqual(len(json_data),1)
def test_switch_is_enabled_tag(self):
t = Template("{% load switcher_tags %}"
"{% switch_is_enabled 'i.am.enabled' as switch %}"
"{% if switch %}enabled{% else %}disabled{% endif %}")
c = Context({})
result = t.render(c)
self.assertEqual('enabled', result)
t = Template("{% load switcher_tags %}"
"{% switch_is_enabled 'i.am.disabled' as switch %}"
"{% if switch %}enabled{% else %}disabled{% endif %}")
c = Context({})
result = t.render(c)
self.assertEqual('disabled', result)
# Ensure that the request object is being respected
OVERRIDE = ("__switcher_force=i.am.enabled:False&" +
"__switcher_force=i.am.disabled:True")
request = HttpRequest()
request.GET = QueryDict(OVERRIDE)
request.REQUEST = request.GET
t = Template("{% load switcher_tags %}"
"{% switch_is_enabled 'i.am.enabled' request=request as switch1 %}"
"{% switch_is_enabled 'i.am.disabled' request=request as switch2 %}"
"{% if switch1 %}enabled{% else %}disabled{% endif %}"
"/"
"{% if switch2 %}enabled{% else %}disabled{% endif %}")
c = RequestContext(request, processors=(request_processor,))
with override_settings(SWITCHER_ALLOW_FORCE=True):
result = t.render(c)
self.assertEqual('disabled/enabled', result)
def test_wpr_connector_decode_request_error (self):
req = HttpRequest()
req.GET = {'movil':'699998877', 'texto':'CANDELARIA AVISO', 'alias':'CANDELARIA', \
'msg':'AVISO', 'ticket':'1', 'numcorto':'4404', 'mcc':'', }
con = WPRConnector()
dec = con.decode(req)
self.assertEqual (dec, None)
def test_top_level_include_schema_content(self):
api = Api()
note_resource = NoteResource()
user_resource = UserResource()
api.register(note_resource)
api.register(user_resource)
request = HttpRequest()
request.GET = {'fullschema': 'true'}
resp = api.top_level(request)
self.assertEqual(resp.status_code, 200)
content = json.loads(resp.content.decode('utf-8'))
content['notes']['schema'] = adjust_schema(content['notes']['schema'])
content['users']['schema'] = adjust_schema(content['users']['schema'])
dummy_request = HttpRequest()
dummy_request.method = 'GET'
notes_schema = adjust_schema(json.loads(note_resource.get_schema(dummy_request).content.decode('utf-8')))
user_schema = adjust_schema(json.loads(user_resource.get_schema(dummy_request).content.decode('utf-8')))
self.assertEqual(content['notes']['list_endpoint'], '/api/v1/notes/')
self.assertEqual(content['notes']['schema'], notes_schema)
self.assertEqual(content['users']['list_endpoint'], '/api/v1/users/')
self.assertEqual(content['users']['schema'], user_schema)
def test_redirect_search_with_unrecognized_facet_raises_404(self):
querystring = \
'sort=-updated_at&selected_facets=imtkfidycqszgfdb&page=60'
request = HttpRequest()
request.GET = QueryDict(querystring)
with self.assertRaises(Http404):
redirect_ask_search(request)
def pdf_as_file(path, date=None):
request = HttpRequest()
request.method = 'GET'
if date:
date_string = date.strftime('%Y-%m-%d')
request.GET = {'date': date_string}
request.META['SERVER_NAME'] = settings.DJANGO_HOST
request.META['SERVER_PORT'] = settings.DJANGO_PORT
html = generate_forums_pdf_template_as_string(request)
try:
pdf = requests.post(settings.PDF_GENERATOR_URL,
data={'html': html},
timeout=10)
except (requests.ConnectionError, requests.ReadTimeout) as e:
return None
with open(path, 'wb') as file:
file.write(pdf.content)
return path
def test_patch_to_one(self):
resource = FullCategoryResource()
cat1 = Category.objects.create(name='Dad')
cat2 = Category.objects.create(parent=cat1, name='Child')
request = HttpRequest()
request.GET = {'format': 'json'}
request.method = 'PATCH'
request._read_started = False
data = {'name': 'Kid'}
request._raw_post_data = request._body = json.dumps(data)
self.assertEqual(cat2.name, 'Child')
resp = resource.patch_detail(request, pk=cat2.pk)
self.assertEqual(resp.status_code, 202)
cat2 = Category.objects.get(pk=2)
self.assertEqual(cat2.name, 'Kid')
def get_ids_from_url(query_string, domain, couch_user):
from django.http import HttpRequest, QueryDict
_request = HttpRequest()
_request.couch_user = couch_user
_request.user = couch_user.get_django_user()
_request.domain = domain
_request.couch_user.current_domain = domain
_request.GET = QueryDict(query_string)
dispatcher = EditDataInterfaceDispatcher()
return dispatcher.dispatch(
_request,
render_as='form_ids',
domain=domain,
report_slug=BulkFormManagementInterface.slug,
skip_permissions_check=True,
)
def make_request(self, user=None, auth=None, method=None):
request = HttpRequest()
if method:
request.method = method
request.META["REMOTE_ADDR"] = "127.0.0.1"
request.META["SERVER_NAME"] = "testserver"
request.META["SERVER_PORT"] = 80
request.GET = {}
request.POST = {}
# order matters here, session -> user -> other things
request.session = self.session
request.auth = auth
request.user = user or AnonymousUser()
request.superuser = Superuser(request)
request.is_superuser = lambda: request.superuser.is_active
request.successful_authenticator = None
return request
def test_url_replace(self):
query_key = 'search_word'
query_val = 'Python'
query_param = urllib.parse.urlencode({query_key: query_val})
request = HttpRequest()
request.method = 'GET'
request.GET = QueryDict(query_param)
field = 'page'
value = 2
get_param = url_replace(request, field, value)
expected_get_param = urllib.parse.urlencode({
query_key: query_val,
field: value
})
self.assertEqual(get_param, expected_get_param)
def test_awsreportview_with_units_success(self, mock_handler):
"""Test unit conversion succeeds in aws report."""
mock_handler.return_value.execute_query.return_value = self.report
params = {'filter': {'resolution': 'daily',
'time_scope_value': -1,
'time_scope_units': 'month'},
'group_by': {'account': ['*']}}
user = User.objects.get(
username=self.user_data['username']
)
django_request = HttpRequest()
qd = QueryDict(mutable=True)
qd.update(params)
django_request.GET = qd
request = Request(django_request)
request.user = user
response = AWSCostView().get(request)
self.assertIsInstance(response, Response)
def test_from_request(self):
start_date = datetime(2013, 7, 21, 0, 0, 0)
end_date = datetime(2013, 7, 15, 0, 0, 0)
request = HttpRequest()
query_string = urlencode({
'startdate': start_date.isoformat(),
'enddate': end_date.isoformat()}
)
request.GET = QueryDict(query_string)
datespan_in_request()
@self.datespan_decorator
def dummy(req):
return getattr(req, 'datespan', None)
datespan = dummy(request)
self.assertIsNotNone(datespan)
self.assertIsInstance(datespan, DateSpan)
self.assertEqual(datespan.enddate, end_date)
self.assertEqual(datespan.startdate, start_date)
def save_queryset_for_user(request):
# print request.POST
user = request.user
qserializer = QSerializer(base64=True)
query_params = unicode(request.POST.get('query').split('?')[-1])
query_dict = QueryDict(query_params.encode('utf8'), encoding='utf8')
fake_request = HttpRequest()
fake_request.GET = query_dict
# print query_dict
params_dict = get_parsed_request(query_dict)
q_object = parse_to_q_object(query_dict, params_dict)
dumped_queryset = qserializer.dumps(q_object)
# print dumped_queryset
title = request.POST.get('title')
description = request.POST.get('description')
q_object_date = filter_by_date(fake_request)
# print q_object_date
date_range = qserializer.dumps(q_object_date)
order_by = json.dumps(get_order_by(fake_request))
# print title, description, date_range, order_by
us, created = UserSearch.objects.get_or_create(user=user, title=title)
if not created and us.user != request.user:
return HttpResponse(content=json.dumps({'message': 'failure'}),
content_type="application/json")
raise Exception('User is not allowed to edit this query!')
# print us
us.queryset = dumped_queryset
us.path = request.POST.get('query')
us.order_by = order_by
us.date_range = date_range
us.description = description
us.save()
print us.queryset_dict
return HttpResponse(content=json.dumps({'message': 'success'}),
content_type="application/json")
def get_signin_request(post_dic):
signin_request = HttpRequest()
query_dict = QueryDict("")
query_dict_post = query_dict.copy() # Make it mutable
query_dict_get = query_dict.copy() # Make it mutable
query_dict_post.update(post_dic)
signin_request.POST = query_dict_post
signin_request.GET = query_dict_get
# Set session (fails without)
# http://stackoverflow.com/questions/16865947/django-httprequest-object-has-no-attribute-session
engine = import_module(settings.SESSION_ENGINE)
session_key = None
signin_request.session = engine.SessionStore(session_key)
signin_request.SERVER_NAME = ""
return signin_request
def test_httprequest_repr(self):
request = HttpRequest()
request.path = u'/somepath/'
request.GET = {u'get-key': u'get-value'}
request.POST = {u'post-key': u'post-value'}
request.COOKIES = {u'post-key': u'post-value'}
request.META = {u'post-key': u'post-value'}
self.assertEqual(
repr(request),
u"<HttpRequest\npath:/somepath/,\nGET:{u'get-key': u'get-value'},\nPOST:{u'post-key': u'post-value'},\nCOOKIES:{u'post-key': u'post-value'},\nMETA:{u'post-key': u'post-value'}>"
)
self.assertEqual(build_request_repr(request), repr(request))
self.assertEqual(
build_request_repr(request,
path_override='/otherpath/',
GET_override={u'a': u'b'},
POST_override={u'c': u'd'},
COOKIES_override={u'e': u'f'},
META_override={u'g': u'h'}),
u"<HttpRequest\npath:/otherpath/,\nGET:{u'a': u'b'},\nPOST:{u'c': u'd'},\nCOOKIES:{u'e': u'f'},\nMETA:{u'g': u'h'}>"
)
def test_costview_with_units_success(self, mock_handler):
"""Test unit conversion succeeds in GCPCostView."""
mock_handler.return_value.execute_query.return_value = self.report
params = {
"group_by[account]": "*",
"filter[resolution]": "monthly",
"filter[time_scope_value]": "-1",
"filter[time_scope_units]": "month",
"SERVER_NAME": "",
}
user = User.objects.get(username=self.user_data["username"])
django_request = HttpRequest()
qd = QueryDict(mutable=True)
qd.update(params)
django_request.GET = qd
request = Request(django_request)
request.user = user
response = GCPCostView().get(request)
self.assertIsInstance(response, Response)
def test_generic_report_with_units_success(self, mock_handler):
"""Test unit conversion succeeds in generic report."""
mock_handler.return_value.execute_query.return_value = self.report
params = {
'group_by[account]': '*',
'filter[resolution]': 'monthly',
'filter[time_scope_value]': '-1',
'filter[time_scope_units]': 'month',
'units': 'byte',
'SERVER_NAME': ''
}
user = User.objects.get(username=self.user_data['username'])
django_request = HttpRequest()
qd = QueryDict(mutable=True)
qd.update(params)
django_request.GET = qd
request = Request(django_request)
request.user = user
response = _generic_report(request, provider='aws', report='costs')
self.assertIsInstance(response, Response)
def test_costview_with_units_success(self, mock_handler):
"""Test unit conversion succeeds in AzureCostView."""
mock_handler.return_value.execute_query.return_value = self.report
params = {
'group_by[subscription_guid]': '*',
'filter[resolution]': 'monthly',
'filter[time_scope_value]': '-1',
'filter[time_scope_units]': 'month',
'units': 'byte',
'SERVER_NAME': ''
}
user = User.objects.get(username=self.user_data['username'])
django_request = HttpRequest()
qd = QueryDict(mutable=True)
qd.update(params)
django_request.GET = qd
request = Request(django_request)
request.user = user
response = AzureCostView().get(request)
self.assertIsInstance(response, Response)
def test_generic_report_ocp_mem_success(self, mock_handler):
"""Test OCP memory generic report."""
mock_handler.return_value.execute_query.return_value = self.report_ocp_mem
params = {
'group_by[account]': '*',
'filter[resolution]': 'monthly',
'filter[time_scope_value]': '-1',
'filter[time_scope_units]': 'month'
}
user = User.objects.get(
username=self.user_data['username']
)
django_request = HttpRequest()
qd = QueryDict(mutable=True)
qd.update(params)
django_request.GET = qd
request = Request(django_request)
request.user = user
response = _generic_report(request, report='memory', provider='ocp')
self.assertIsInstance(response, Response)
def middleware(request: HttpRequest) -> HttpResponse:
try:
if request.path.startswith('/__change_tenant__/'):
select_tenant(request, request.path.split('/')[2])
if request.session.get('active_tenant'):
return HttpResponse(TENANT_CHANGED % request.session)
return HttpResponse(TENANT_CLEARED)
if request.GET.get('__tenant') is not None:
select_tenant(request, request.GET['__tenant'])
data = request.GET.copy()
data.pop('__tenant')
if request.method == 'GET':
if data:
return redirect(request.path + '?' + data.urlencode())
return redirect(request.path)
request.GET = data
elif 'HTTP_X_CHANGE_TENANT' in request.META:
select_tenant(request, request.META['HTTP_X_CHANGE_TENANT'])
except Forbidden:
return HttpResponseForbidden(UNABLE_TO_CHANGE_TENANT)
return get_response(request)
def test_generic_report_ocp_cpu_success(self, mock_handler):
"""Test OCP cpu generic report."""
mock_handler.return_value.execute_query.return_value = self.report_ocp_cpu
params = {
'group_by[account]': '*',
'filter[resolution]': 'monthly',
'filter[time_scope_value]': '-1',
'filter[time_scope_units]': 'month'
}
user = User.objects.get(username=self.user_data['username'])
django_request = HttpRequest()
qd = QueryDict(mutable=True)
qd.update(params)
django_request.GET = qd
request = Request(django_request)
request.user = user
extras = {'report_type': 'cpu'}
response = _generic_report(request, QueryParamSerializer,
OCPReportQueryHandler, **extras)
self.assertIsInstance(response, Response)
def _make_shib_enrollment_request(request):
"""
Need this hack function because shibboleth logins don't happen over POST
but change_enrollment expects its request to be a POST, with
enrollment_action and course_id POST parameters.
"""
enroll_request = HttpRequest()
enroll_request.user = request.user
enroll_request.session = request.session
enroll_request.method = "POST"
# copy() also makes GET and POST mutable
# See https://docs.djangoproject.com/en/dev/ref/request-response/#django.http.QueryDict.update
enroll_request.GET = request.GET.copy()
enroll_request.POST = request.POST.copy()
# also have to copy these GET parameters over to POST
if "enrollment_action" not in enroll_request.POST and "enrollment_action" in enroll_request.GET:
enroll_request.POST.setdefault('enrollment_action', enroll_request.GET.get('enrollment_action'))
if "course_id" not in enroll_request.POST and "course_id" in enroll_request.GET:
enroll_request.POST.setdefault('course_id', enroll_request.GET.get('course_id'))
return enroll_request
def grade():
print('========== Start background grading ==========')
try:
tasks = Task.objects.all()
print('%d tasks detected.' % len(tasks))
except:
print('No tasks. Abort.')
return
request = HttpRequest()
for task in tasks:
print('Execute grade api for project_id %d...' % task.project_id)
request.session = {'space': task.space, 'token': task.token}
request.GET = {'force': 1, 'background': 1}
try:
compute_grade(request, task.project_id)
except:
print('Something error happened.')
task.delete()
print('End.')
print('==============================================')
def test_httprequest_repr(self):
request = HttpRequest()
request.path = '/somepath/'
request.GET = {'get-key': 'get-value'}
request.POST = {'post-key': 'post-value'}
request.COOKIES = {'post-key': 'post-value'}
request.META = {'post-key': 'post-value'}
self.assertEqual(
repr(request),
str_prefix(
"<HttpRequest\npath:/somepath/,\nGET:{%(_)s'get-key': %(_)s'get-value'},\nPOST:{%(_)s'post-key': %(_)s'post-value'},\nCOOKIES:{%(_)s'post-key': %(_)s'post-value'},\nMETA:{%(_)s'post-key': %(_)s'post-value'}>"
))
self.assertEqual(build_request_repr(request), repr(request))
self.assertEqual(
build_request_repr(request,
path_override='/otherpath/',
GET_override={'a': 'b'},
POST_override={'c': 'd'},
COOKIES_override={'e': 'f'},
META_override={'g': 'h'}),
str_prefix(
"<HttpRequest\npath:/otherpath/,\nGET:{%(_)s'a': %(_)s'b'},\nPOST:{%(_)s'c': %(_)s'd'},\nCOOKIES:{%(_)s'e': %(_)s'f'},\nMETA:{%(_)s'g': %(_)s'h'}>"
))
def _export_report(self, emails, title):
from corehq.apps.reports.standard.deployments import ApplicationStatusReport
for report_config in self.configs:
mock_request = HttpRequest()
mock_request.couch_user = self.owner
mock_request.user = self.owner.get_django_user()
mock_request.domain = self.domain
mock_request.couch_user.current_domain = self.domain
mock_request.couch_user.language = self.language
mock_request.method = 'GET'
mock_request.bypass_two_factor = True
mock_query_string_parts = [
report_config.query_string, 'filterSet=true'
]
mock_request.GET = QueryDict('&'.join(mock_query_string_parts))
request_data = vars(mock_request)
request_data['couch_user'] = mock_request.couch_user.userID
if report_config.report_slug != ApplicationStatusReport.slug:
# ApplicationStatusReport doesn't have date filter
date_range = report_config.get_date_range()
start_date = datetime.strptime(date_range['startdate'],
'%Y-%m-%d')
end_date = datetime.strptime(date_range['enddate'], '%Y-%m-%d')
datespan = DateSpan(start_date, end_date)
request_data['datespan'] = datespan
full_request = {
'request': request_data,
'domain': request_data['domain'],
'context': {},
'request_params': json_request(request_data['GET'])
}
export_all_rows_task(report_config.report, full_request, emails,
title)
def test_top_level_include_schema_content(self):
api = Api()
note_resource = NoteResource()
user_resource = UserResource()
api.register(note_resource)
api.register(user_resource)
request = HttpRequest()
request.GET = {'fullschema': 'true'}
resp = api.top_level(request)
self.assertEqual(resp.status_code, 200)
content = json.loads(resp.content.decode('utf-8'))
content['notes']['schema'] = adjust_schema(content['notes']['schema'])
content['users']['schema'] = adjust_schema(content['users']['schema'])
dummy_request = HttpRequest()
dummy_request.method = 'GET'
notes_schema = adjust_schema(
json.loads(
note_resource.get_schema(dummy_request).content.decode(
'utf-8')))
user_schema = adjust_schema(
json.loads(
user_resource.get_schema(dummy_request).content.decode(
'utf-8')))
self.assertEqual(content['notes']['list_endpoint'], '/api/v1/notes/')
self.assertEqual(content['notes']['schema'], notes_schema)
self.assertEqual(content['users']['list_endpoint'], '/api/v1/users/')
self.assertEqual(content['users']['schema'], user_schema)
def test_hash_request(self):
# Requests with the same parameters should hash to the same values,
# regardless of HTTP method.
target_qd = QueryDict('&target=randomWalk(%27random%20walk%27)'
'&target=randomWalk(%27random%20walk2%27)'
'&target=randomWalk(%27random%20walk3%27)')
empty_qd = QueryDict('')
post_request = HttpRequest()
post_request.POST = target_qd.copy()
post_request.GET = empty_qd.copy()
get_request = HttpRequest()
get_request.GET = target_qd.copy()
get_request.POST = empty_qd.copy()
self.assertEqual(hashRequest(get_request), hashRequest(post_request))
# Check that POST parameters are included in cache key calculations
post_request_with_params = HttpRequest()
post_request_with_params.GET = empty_qd.copy()
post_request_with_params.POST = target_qd.copy()
empty_post_request = HttpRequest()
empty_post_request.GET = empty_qd.copy()
empty_post_request.POST = empty_qd.copy()
self.assertNotEqual(hashRequest(post_request_with_params),
hashRequest(empty_post_request))
# Check that changing the order of the parameters has no impact on the
# cache key
request_params = HttpRequest()
request_qd = QueryDict('&foo=1&bar=2')
request_params.GET = request_qd.copy()
request_params.POST = empty_qd.copy()
reverse_request_params = HttpRequest()
reverse_request_qd = QueryDict('&bar=2&foo=1')
reverse_request_params.GET = reverse_request_qd.copy()
reverse_request_params.POST = empty_qd.copy()
self.assertEqual(hashRequest(request_params),
hashRequest(reverse_request_params))
def _get_and_send_report(self, language, emails):
from corehq.apps.reports.views import get_scheduled_report_response, render_full_report_notification
with localize(language):
title = (_(DEFAULT_REPORT_NOTIF_SUBJECT) if self.email_subject
== DEFAULT_REPORT_NOTIF_SUBJECT else self.email_subject)
attach_excel = getattr(self, 'attach_excel', False)
try:
content, excel_files = get_scheduled_report_response(
self.owner,
self.domain,
self._id,
attach_excel=attach_excel,
send_only_active=True)
# Will be False if ALL the ReportConfigs in the ReportNotification
# have a start_date in the future.
if content is False:
return
for email in emails:
body = render_full_report_notification(
None, content, email, self).content
send_html_email_async(
title,
email,
body,
email_from=settings.DEFAULT_FROM_EMAIL,
file_attachments=excel_files,
smtp_exception_skip_list=LARGE_FILE_SIZE_ERROR_CODES)
except Exception as er:
notify_exception(
None,
message=
"Encountered error while generating report or sending email",
details={
'subject': title,
'recipients': str(emails),
'error': er,
})
if getattr(er, 'smtp_code',
None) in LARGE_FILE_SIZE_ERROR_CODES or type(
er) == ESError:
# If the email doesn't work because it is too large to fit in the HTML body,
# send it as an excel attachment, by creating a mock request with the right data.
for report_config in self.configs:
mock_request = HttpRequest()
mock_request.couch_user = self.owner
mock_request.user = self.owner.get_django_user()
mock_request.domain = self.domain
mock_request.couch_user.current_domain = self.domain
mock_request.couch_user.language = self.language
mock_request.method = 'GET'
mock_request.bypass_two_factor = True
mock_query_string_parts = [
report_config.query_string, 'filterSet=true'
]
if report_config.is_configurable_report:
mock_query_string_parts.append(
urlencode(report_config.filters, True))
mock_query_string_parts.append(
urlencode(report_config.get_date_range(),
True))
mock_request.GET = QueryDict(
'&'.join(mock_query_string_parts))
date_range = report_config.get_date_range()
start_date = datetime.strptime(date_range['startdate'],
'%Y-%m-%d')
end_date = datetime.strptime(date_range['enddate'],
'%Y-%m-%d')
datespan = DateSpan(start_date, end_date)
request_data = vars(mock_request)
request_data[
'couch_user'] = mock_request.couch_user.userID
request_data['datespan'] = datespan
full_request = {
'request': request_data,
'domain': request_data['domain'],
'context': {},
'request_params': json_request(request_data['GET'])
}
export_all_rows_task(report_config.report,
full_request, emails, title)
def get_report_content(self, lang, attach_excel=False):
"""
Get the report's HTML content as rendered by the static view format.
"""
from corehq.apps.locations.middleware import LocationAccessMiddleware
try:
if self.report is None:
return ReportContent(
_("The report used to create this scheduled report is no"
" longer available on CommCare HQ. Please delete this"
" scheduled report and create a new one using an available"
" report."),
None,
)
except Exception:
pass
if getattr(self.report, 'is_deprecated', False):
return ReportContent(
self.report.deprecation_email_message or
_("[DEPRECATED] %s report has been deprecated and will stop working soon. "
"Please update your saved reports email settings if needed."
% self.report.name),
None,
)
mock_request = HttpRequest()
mock_request.couch_user = self.owner
mock_request.user = self.owner.get_django_user()
mock_request.domain = self.domain
mock_request.couch_user.current_domain = self.domain
mock_request.couch_user.language = lang
mock_request.method = 'GET'
mock_request.bypass_two_factor = True
mock_query_string_parts = [self.query_string, 'filterSet=true']
if self.is_configurable_report:
mock_query_string_parts.append(urlencode(self.filters, True))
mock_query_string_parts.append(
urlencode(self.get_date_range(), True))
mock_request.GET = QueryDict('&'.join(mock_query_string_parts))
# Make sure the request gets processed by PRBAC Middleware
CCHQPRBACMiddleware.apply_prbac(mock_request)
LocationAccessMiddleware.apply_location_access(mock_request)
try:
dispatch_func = functools.partial(
self._dispatcher.__class__.as_view(), mock_request,
**self.view_kwargs)
email_response = dispatch_func(render_as='email')
if email_response.status_code == 302:
return ReportContent(
_("We are sorry, but your saved report '%(config_name)s' "
"is no longer accessible because the owner %(username)s "
"is no longer active.") % {
'config_name': self.name,
'username': self.owner.username
},
None,
)
try:
content_json = json.loads(email_response.content)
except ValueError:
email_text = email_response.content
else:
email_text = content_json['report']
excel_attachment = dispatch_func(
render_as='excel') if attach_excel else None
return ReportContent(email_text, excel_attachment)
except PermissionDenied:
return ReportContent(
_("We are sorry, but your saved report '%(config_name)s' "
"is no longer accessible because your subscription does "
"not allow Custom Reporting. Please talk to your Project "
"Administrator about enabling Custom Reports. If you "
"want CommCare HQ to stop sending this message, please "
"visit %(saved_reports_url)s to remove this "
"Emailed Report.") % {
'config_name':
self.name,
'saved_reports_url':
absolute_reverse('saved_reports',
args=[mock_request.domain]),
},
None,
)
except Http404:
return ReportContent(
_("We are sorry, but your saved report '%(config_name)s' "
"can not be generated since you do not have the correct permissions. "
"Please talk to your Project Administrator about getting permissions for this"
"report.") % {
'config_name': self.name,
},
None,
)
except UnsupportedSavedReportError:
return ReportContent(
_("We are sorry, but your saved report '%(config_name)s' "
"is no longer available. If you think this is a mistake, please report an issue."
) % {
'config_name': self.name,
},
None,
)
def send_email_report(self, recipient_emails, domain, report_slug, report_type,
request_data, once, cleaned_data):
"""
Function invokes send_HTML_email to email the html text report.
If the report is too large to fit into email then a download link is
sent via email to download report
:Parameter recipient_list:
list of recipient to whom email is to be sent
:Parameter domain:
domain name
:Parameter report_slug:
report slug
:Parameter report_type:
type of the report
:Parameter request_data:
Dict containing request data
:Parameter once
boolean argument specifying whether the report is once off report
or scheduled report
:Parameter cleaned_data:
Dict containing cleaned data from the submitted form
"""
from corehq.apps.reports.views import _render_report_configs, render_full_report_notification
user_id = request_data['couch_user']
couch_user = CouchUser.get_by_user_id(user_id)
mock_request = HttpRequest()
mock_request.method = 'GET'
mock_request.GET = request_data['GET']
config = ReportConfig()
# see ReportConfig.query_string()
object.__setattr__(config, '_id', 'dummy')
config.name = _("Emailed report")
config.report_type = report_type
config.report_slug = report_slug
config.owner_id = user_id
config.domain = domain
config.start_date = request_data['datespan'].startdate.date()
if request_data['datespan'].enddate:
config.date_range = 'range'
config.end_date = request_data['datespan'].enddate.date()
else:
config.date_range = 'since'
GET = dict(six.iterlists(request_data['GET']))
exclude = [
'startdate', 'enddate', 'subject', 'send_to_owner', 'notes',
'recipient_emails'
]
filters = {}
for field in GET:
if field not in exclude:
filters[field] = GET.get(field)
config.filters = filters
subject = cleaned_data['subject'] or _("Email report from CommCare HQ")
content = _render_report_configs(mock_request, [config],
domain,
user_id,
couch_user,
True,
lang=couch_user.language,
notes=cleaned_data['notes'],
once=once)[0]
body = render_full_report_notification(None, content).content
try:
for recipient in recipient_emails:
send_HTML_email(
subject,
recipient,
body,
email_from=settings.DEFAULT_FROM_EMAIL,
smtp_exception_skip_list=LARGE_FILE_SIZE_ERROR_CODES)
except Exception as er:
if getattr(er, 'smtp_code', None) in LARGE_FILE_SIZE_ERROR_CODES:
# If the smtp server rejects the email because of its large size.
# Then sends the report download link in the email.
report_state = {
'request': request_data,
'request_params': json_request(request_data['GET']),
'domain': domain,
'context': {},
}
export_all_rows_task(config.report,
report_state,
recipient_list=recipient_emails)
else:
self.retry(exc=er)
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/bookkeeper_email.html',
email_context)
email_content_plaintext = render_to_string(
'accounting/bookkeeper_email_plaintext.html', 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)
})
from django.http import HttpRequest
from scenic.models import *
r = HttpRequest()
r.GET = {
'deviceid': 'asdfasdfasdfasd',
'device_id': 'asdfasd',
'lat': '32',
'lng': '33',
'title': 'tei',
'trueheading': '23',
'magheading': '42'
}
def testContent():
return ScenicContent.getor(r)
def testUser():
u = User.getor(r)
g = GeoPt.getor(r)
th = getVal(r, 'trueheading')
mh = getVal(r, 'magheading')
return UserPicture(user=u,
geopt=g,
title='asdfasdfasdfa',
trueHeading=th,
magHeading=mh)
def test_index_without_session_id(self):
self._setup_emulator()
request = HttpRequest()
request.GET = QueryDict('items[]=foo')
response = userconfig.index(request)
self.assertEquals(response.status_code, httplib.BAD_REQUEST)
def get_report_content(self, lang, attach_excel=False):
"""
Get the report's HTML content as rendered by the static view format.
"""
try:
if self.report is None:
return ReportContent(
_("The report used to create this scheduled report is no"
" longer available on CommCare HQ. Please delete this"
" scheduled report and create a new one using an available"
" report."),
None,
)
except Exception:
pass
from django.http import HttpRequest, QueryDict
mock_request = HttpRequest()
mock_request.couch_user = self.owner
mock_request.user = self.owner.get_django_user()
mock_request.domain = self.domain
mock_request.couch_user.current_domain = self.domain
mock_request.couch_user.language = lang
mock_request.method = 'GET'
mock_query_string_parts = [self.query_string, 'filterSet=true']
if self.is_configurable_report:
mock_query_string_parts.append(urlencode(self.filters, True))
mock_query_string_parts.append(
urlencode(self.get_date_range(), True))
mock_request.GET = QueryDict('&'.join(mock_query_string_parts))
# Make sure the request gets processed by PRBAC Middleware
CCHQPRBACMiddleware.apply_prbac(mock_request)
try:
dispatch_func = functools.partial(
self._dispatcher.__class__.as_view(), mock_request,
**self.view_kwargs)
email_response = dispatch_func(render_as='email')
if email_response.status_code == 302:
return ReportContent(
_("We are sorry, but your saved report '%(config_name)s' "
"is no longer accessible because the owner %(username)s "
"is no longer active.") % {
'config_name': self.name,
'username': self.owner.username
},
None,
)
return ReportContent(
json.loads(email_response.content)['report'],
dispatch_func(render_as='excel') if attach_excel else None,
)
except PermissionDenied:
return ReportContent(
_("We are sorry, but your saved report '%(config_name)s' "
"is no longer accessible because your subscription does "
"not allow Custom Reporting. Please talk to your Project "
"Administrator about enabling Custom Reports. If you "
"want CommCare HQ to stop sending this message, please "
"visit %(saved_reports_url)s to remove this "
"Emailed Report.") % {
'config_name':
self.name,
'saved_reports_url':
absolute_reverse('saved_reports',
args=[mock_request.domain]),
},
None,
)
except Http404:
return ReportContent(
_("We are sorry, but your saved report '%(config_name)s' "
"can not be generated since you do not have the correct permissions. "
"Please talk to your Project Administrator about getting permissions for this"
"report.") % {
'config_name': self.name,
},
None,
)
except UnsupportedSavedReportError:
return ReportContent(
_("We are sorry, but your saved report '%(config_name)s' "
"is no longer available. If you think this is a mistake, please report an issue."
) % {
'config_name': self.name,
},
None,
)
except Exception:
notify_exception(None,
"Error generating report: {}".format(
self.report_slug),
details={
'domain': self.domain,
'user': self.owner.username,
'report': self.report_slug,
'report config': self.get_id
})
return ReportContent(
_("An error occurred while generating this report."), None)
def test_determine_format(self):
serializer = Serializer()
request = HttpRequest()
# Default.
self.assertEqual(determine_format(request, serializer),
'application/json')
# Test forcing the ``format`` parameter.
request.GET = {'format': 'json'}
self.assertEqual(determine_format(request, serializer),
'application/json')
request.GET = {'format': 'jsonp'}
self.assertEqual(determine_format(request, serializer),
'text/javascript')
request.GET = {'format': 'xml'}
self.assertEqual(determine_format(request, serializer),
'application/xml')
request.GET = {'format': 'yaml'}
self.assertEqual(determine_format(request, serializer), 'text/yaml')
request.GET = {'format': 'plist'}
self.assertEqual(determine_format(request, serializer),
'application/x-plist')
request.GET = {'format': 'foo'}
self.assertEqual(determine_format(request, serializer),
'application/json')
# Test the ``Accept`` header.
request.META = {'HTTP_ACCEPT': 'application/json'}
self.assertEqual(determine_format(request, serializer),
'application/json')
request.META = {'HTTP_ACCEPT': 'text/javascript'}
self.assertEqual(determine_format(request, serializer),
'text/javascript')
request.META = {'HTTP_ACCEPT': 'application/xml'}
self.assertEqual(determine_format(request, serializer),
'application/xml')
request.META = {'HTTP_ACCEPT': 'text/yaml'}
self.assertEqual(determine_format(request, serializer), 'text/yaml')
request.META = {'HTTP_ACCEPT': 'application/x-plist'}
self.assertEqual(determine_format(request, serializer),
'application/x-plist')
request.META = {'HTTP_ACCEPT': 'text/html'}
self.assertEqual(determine_format(request, serializer), 'text/html')
request.META = {'HTTP_ACCEPT': '*/*'}
self.assertEqual(determine_format(request, serializer),
'application/json')
request.META = {
'HTTP_ACCEPT': 'application/json,application/xml;q=0.9,*/*;q=0.8'
}
self.assertEqual(determine_format(request, serializer),
'application/json')
request.META = {
'HTTP_ACCEPT':
'text/plain,application/xml,application/json;q=0.9,*/*;q=0.8'
}
self.assertEqual(determine_format(request, serializer),
'application/xml')
request.META = {'HTTP_ACCEPT': 'application/json; charset=UTF-8'}
self.assertEqual(determine_format(request, serializer),
'application/json')
request.META = {'HTTP_ACCEPT': 'text/javascript,application/json'}
self.assertEqual(determine_format(request, serializer),
'application/json')
