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')