def test_soft_delete_coupon(self): # pylint: disable=E1101 self.add_coupon(self.course_key, True) coupon = Coupon(code='TestCode', description='testing', course_id=self.course_key, percentage_discount=12, created_by=self.user, is_active=True) coupon.save() self.assertEquals(coupon.__unicode__(), '[Coupon] code: TestCode course: MITx/999/Robot_Super_Course') admin = User.objects.create_user('Mark', '*****@*****.**', 'foo') admin.is_staff = True get_coupon = Coupon.objects.get(id=1) request = HttpRequest() request.user = admin setattr(request, 'session', 'session') # pylint: disable=E1101 messages = FallbackStorage(request) # pylint: disable=E1101 setattr(request, '_messages', messages) # pylint: disable=E1101 coupon_admin = SoftDeleteCouponAdmin(Coupon, AdminSite()) test_query_set = coupon_admin.queryset(request) test_actions = coupon_admin.get_actions(request) self.assertTrue('really_delete_selected' in test_actions['really_delete_selected']) self.assertEqual(get_coupon.is_active, True) coupon_admin.really_delete_selected(request, test_query_set) # pylint: disable=E1101 for coupon in test_query_set: self.assertEqual(coupon.is_active, False) coupon_admin.delete_model(request, get_coupon) # pylint: disable=E1101 self.assertEqual(get_coupon.is_active, False) coupon = Coupon(code='TestCode123', description='testing123', course_id=self.course_key, percentage_discount=22, created_by=self.user, is_active=True) coupon.save() test_query_set = coupon_admin.queryset(request) coupon_admin.really_delete_selected(request, test_query_set) # pylint: disable=E1101 for coupon in test_query_set: self.assertEqual(coupon.is_active, False)
def _build_report_and_view(self): # Create report data_source_config = DataSourceConfiguration( domain=self.domain, display_name='foo', referenced_doc_type='CommCareCase', table_id="woop_woop", configured_filter={ "type": "boolean_expression", "operator": "eq", "expression": { "type": "property_name", "property_name": "type" }, "property_value": self.case_type, }, configured_indicators=[ { "type": "expression", "expression": { "type": "property_name", "property_name": 'fruit' }, "column_id": 'indicator_col_id_fruit', "display_name": 'indicator_display_name_fruit', "datatype": "string" }, { "type": "expression", "expression": { "type": "property_name", "property_name": 'num1' }, "column_id": 'indicator_col_id_num1', "datatype": "integer" }, { "type": "expression", "expression": { "type": "property_name", "property_name": 'num2' }, "column_id": 'indicator_col_id_num2', "datatype": "integer" }, ], ) data_source_config.validate() data_source_config.save() self.addCleanup(data_source_config.delete) tasks.rebuild_indicators(data_source_config._id) adapter = get_indicator_adapter(data_source_config) adapter.refresh_table() report_config = ReportConfiguration( domain=self.domain, config_id=data_source_config._id, title='foo', aggregation_columns=['doc_id'], columns=[ { "type": "field", "display": "report_column_display_fruit", "field": 'indicator_col_id_fruit', 'column_id': 'report_column_col_id_fruit', 'aggregation': 'simple' }, { "type": "percent", "display": "report_column_display_percent", 'column_id': 'report_column_col_id_percent', 'format': 'percent', "denominator": { "type": "field", "aggregation": "sum", "field": "indicator_col_id_num1", "column_id": "report_column_col_id_percent_num1" }, "numerator": { "type": "field", "aggregation": "sum", "field": "indicator_col_id_num2", "column_id": "report_column_col_id_percent_num2" } }, ], ) report_config.save() self.addCleanup(report_config.delete) view = ConfigurableReport(request=HttpRequest()) view._domain = self.domain view._lang = "en" view._report_config_id = report_config._id return report_config, view
def test_redirect_custom_report(self): report, view = self._build_report_and_view() request = HttpRequest() self.assertFalse(view.should_redirect_to_paywall(request))
def test_set_with_xheader_right(self): self.settings_module.SECURE_PROXY_SSL_HEADER = ( 'HTTP_X_FORWARDED_PROTOCOL', 'https') req = HttpRequest() req.META['HTTP_X_FORWARDED_PROTOCOL'] = 'https' self.assertEqual(req.is_secure(), True)
def test_none(self): self.settings_module.SECURE_PROXY_SSL_HEADER = None req = HttpRequest() self.assertEqual(req.is_secure(), False)
def process_request(self, request: HttpRequest) -> None: request.user = SimpleLazyObject(lambda: get_user(request))
def test_akismet_spam(self): self.mock_akismet('true') self.assertTrue(is_spam('text', HttpRequest()))
def test_home_page_returns_correct_html(self): request = HttpRequest() response = home_page(request) html = response.content.decode('utf8') expected_html = render_to_string('home.html') self.assertEqual(html, expected_html)
def test_get_user(self): self.client.force_login(self.user) request = HttpRequest() request.session = self.client.session user = get_user(request) self.assertEqual(user, self.user)
def assertBackendInSession(self, backend): request = HttpRequest() request.session = self.client.session self.assertEqual(request.session[BACKEND_SESSION_KEY], backend)
def test_home_page_only_saves_items_when_neccessary(self): request = HttpRequest() home_page(request) self.assertEqual(Item.objects.count(), 0)
def test_home_page_returns_correct_html(self): request = HttpRequest() response = home_page(request) expected_html = render_to_string('home.html', {'new_item_text': 'A new list item'}) self.assertEqual(response.content.decode(), expected_html)
def test_home_page_returns_correct_html(self): request = HttpRequest() response = home_page(request) expected_html = render_to_string('home.html', {'form': ItemForm()}) self.assertMultiLineEqual(response.content.decode(), expected_html)
def test_coverage_data_view_provides_court_data(self): response = coverage_data(HttpRequest(), 'v2', 'ca9') self.assertEqual(response.status_code, 200) self.assertIsInstance(response, JsonResponse) self.assertContains(response, 'annual_counts') self.assertContains(response, 'total')
def collect_resource_instances_for_couch(self): """ Uses the data definition configs of a mobile survey object to search for resource instances relevant to a mobile survey. Takes a user object which is required for search. """ query = self.datadownloadconfig['custom'] resource_types = self.datadownloadconfig['resources'] all_instances = {} if query in ('', None) and len(resource_types) == 0: print "No resources or data query defined" else: request = HttpRequest() request.user = self.lasteditedby request.GET['mobiledownload'] = True request.GET['resourcecount'] = self.datadownloadconfig['count'] if query in ('', None): if len(self.bounds.coords) == 0: default_bounds = settings.DEFAULT_BOUNDS default_bounds['features'][0]['properties'][ 'inverted'] = False map_filter = json.dumps(default_bounds) else: map_filter = json.dumps({ u'type': u'FeatureCollection', 'features': [{ 'geometry': json.loads(self.bounds.json) }] }) try: for res_type in resource_types: instances = {} request.GET['resource-type-filter'] = json.dumps([{ 'graphid': res_type, 'inverted': False }]) request.GET['map-filter'] = map_filter request.GET['resourcecount'] = self.datadownloadconfig[ 'count'] self.append_to_instances(request, instances, res_type) if len(instances.keys()) < int( self.datadownloadconfig['count']): request.GET['map-filter'] = '{}' request.GET['resourcecount'] = int( self.datadownloadconfig['count']) - len( instances.keys()) self.append_to_instances(request, instances, res_type) for key, value in instances.iteritems(): all_instances[key] = value except KeyError: print 'no instances found in', search_res else: try: instances = {} parsed = urlparse.urlparse(query) urlparams = urlparse.parse_qs(parsed.query) for k, v in urlparams.iteritems(): request.GET[k] = v[0] search_res_json = search.search_results(request) search_res = JSONDeserializer().deserialize( search_res_json.content) for hit in search_res['results']['hits']['hits']: instances[hit['_source'] ['resourceinstanceid']] = hit['_source'] for key, value in instances.iteritems(): all_instances[key] = value except KeyError: print 'no instances found in', search_res return all_instances
def home_real(request: HttpRequest) -> HttpResponse: # Before we do any real work, check if the app is banned. client_user_agent = request.META.get("HTTP_USER_AGENT", "") (insecure_desktop_app, banned_desktop_app, auto_update_broken) = is_outdated_desktop_app(client_user_agent) if banned_desktop_app: return render( request, "zerver/insecure_desktop_app.html", context={ "auto_update_broken": auto_update_broken, }, ) (unsupported_browser, browser_name) = is_unsupported_browser(client_user_agent) if unsupported_browser: return render( request, "zerver/unsupported_browser.html", context={ "browser_name": browser_name, }, ) # We need to modify the session object every two weeks or it will expire. # This line makes reloading the page a sufficient action to keep the # session alive. request.session.modified = True if request.user.is_authenticated: user_profile = request.user realm = user_profile.realm # User is logged in and hence no longer `prefers_web_public_view`. if "prefers_web_public_view" in request.session.keys(): del request.session["prefers_web_public_view"] else: realm = get_valid_realm_from_request(request) # TODO: Ideally, we'd open Zulip directly as a spectator if # the URL had clicked a link to content on a web-public # stream. We could maybe do this by parsing `next`, but it's # not super convenient with Zulip's hash-based URL scheme. # The "Access without an account" button on the login page # submits a POST to this page with this hidden field set. if request.POST.get("prefers_web_public_view") == "true": request.session["prefers_web_public_view"] = True # We serve a redirect here, rather than serving a page, to # avoid browser "Confirm form resubmission" prompts on reload. redirect_to = get_safe_redirect_to(request.POST.get("next"), realm.uri) return redirect(redirect_to) # See the assert in `home` above for why this must be true. assert request.session.get("prefers_web_public_view") # For users who have selected public access, we load the # spectator experience. We fall through to the shared code # for loading the application, with user_profile=None encoding # that we're a spectator, not a logged-in user. user_profile = None update_last_reminder(user_profile) statsd.incr("views.home") # If a user hasn't signed the current Terms of Service, send them there if need_accept_tos(user_profile): return accounts_accept_terms(request) narrow, narrow_stream, narrow_topic = detect_narrowed_window( request, user_profile) if user_profile is not None: first_in_realm = realm_user_count(user_profile.realm) == 1 # If you are the only person in the realm and you didn't invite # anyone, we'll continue to encourage you to do so on the frontend. prompt_for_invites = (first_in_realm and not PreregistrationUser.objects.filter( referred_by=user_profile).count()) needs_tutorial = user_profile.tutorial_status == UserProfile.TUTORIAL_WAITING else: first_in_realm = False prompt_for_invites = False # The current tutorial doesn't super make sense for logged-out users. needs_tutorial = False queue_id, page_params = build_page_params_for_home_page_load( request=request, user_profile=user_profile, realm=realm, insecure_desktop_app=insecure_desktop_app, narrow=narrow, narrow_stream=narrow_stream, narrow_topic=narrow_topic, first_in_realm=first_in_realm, prompt_for_invites=prompt_for_invites, needs_tutorial=needs_tutorial, ) log_data = RequestNotes.get_notes(request).log_data assert log_data is not None log_data["extra"] = f"[{queue_id}]" csp_nonce = secrets.token_hex(24) user_permission_info = get_user_permission_info(user_profile) response = render( request, "zerver/app/index.html", context={ "user_profile": user_profile, "page_params": page_params, "csp_nonce": csp_nonce, "color_scheme": user_permission_info.color_scheme, }, ) patch_cache_control(response, no_cache=True, no_store=True, must_revalidate=True) return response
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 # 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 return request
def test_disabled(self): self.assertFalse(is_spam('text', HttpRequest()))
def maybe_send_to_registration( request: HttpRequest, email: str, full_name: str = '', mobile_flow_otp: Optional[str] = None, desktop_flow_otp: Optional[str] = None, is_signup: bool = False, password_required: bool = True, multiuse_object_key: str = '', full_name_validated: bool = False) -> HttpResponse: """Given a successful authentication for an email address (i.e. we've confirmed the user controls the email address) that does not currently have a Zulip account in the target realm, send them to the registration flow or the "continue to registration" flow, depending on is_signup, whether the email address can join the organization (checked in HomepageForm), and similar details. """ # In the desktop and mobile registration flows, the sign up # happens in the browser so the user can use their # already-logged-in social accounts. Then at the end, with the # user account created, we pass the appropriate data to the app # via e.g. a `zulip://` redirect. We store the OTP keys for the # mobile/desktop flow in the session with 1-hour expiry, because # we want this configuration of having a successful authentication # result in being logged into the app to persist if the user makes # mistakes while trying to authenticate (E.g. clicks the wrong # Google account, hits back, etc.) during a given browser session, # rather than just logging into the webapp in the target browser. # # We can't use our usual pre-account-creation state storage # approach of putting something in PreregistrationUser, because # that would apply to future registration attempts on other # devices, e.g. just creating an account on the web on their laptop. assert not (mobile_flow_otp and desktop_flow_otp) if mobile_flow_otp: set_expirable_session_var(request.session, 'registration_mobile_flow_otp', mobile_flow_otp, expiry_seconds=3600) elif desktop_flow_otp: set_expirable_session_var(request.session, 'registration_desktop_flow_otp', desktop_flow_otp, expiry_seconds=3600) if multiuse_object_key: from_multiuse_invite = True multiuse_obj = Confirmation.objects.get( confirmation_key=multiuse_object_key).content_object realm = multiuse_obj.realm invited_as = multiuse_obj.invited_as else: from_multiuse_invite = False multiuse_obj = None try: realm = get_realm(get_subdomain(request)) except Realm.DoesNotExist: realm = None invited_as = PreregistrationUser.INVITE_AS['MEMBER'] form = HomepageForm({'email': email}, realm=realm, from_multiuse_invite=from_multiuse_invite) if form.is_valid(): # If the email address is allowed to sign up for an account in # this organization, construct a PreregistrationUser and # Confirmation objects, and then send the user to account # creation or confirm-continue-registration depending on # is_signup. try: prereg_user = PreregistrationUser.objects.filter( email__iexact=email, realm=realm).latest("invited_at") # password_required and full_name data passed here as argument should take precedence # over the defaults with which the existing PreregistrationUser that we've just fetched # was created. prereg_user.password_required = password_required update_fields = ["password_required"] if full_name: prereg_user.full_name = full_name prereg_user.full_name_validated = full_name_validated update_fields.extend(["full_name", "full_name_validated"]) prereg_user.save(update_fields=update_fields) except PreregistrationUser.DoesNotExist: prereg_user = create_preregistration_user( email, request, password_required=password_required, full_name=full_name, full_name_validated=full_name_validated) if multiuse_obj is not None: request.session.modified = True streams_to_subscribe = list(multiuse_obj.streams.all()) prereg_user.streams.set(streams_to_subscribe) prereg_user.invited_as = invited_as prereg_user.save() # We want to create a confirmation link to create an account # in the current realm, i.e. one with a hostname of # realm.host. For the Apache REMOTE_USER_SSO auth code path, # this is preferable over realm.get_host() because the latter # contains the port number of the Apache instance and we want # to send the user back to nginx. But if we're in the realm # creation code path, there might not be a realm yet, so we # have to use request.get_host(). if realm is not None: host = realm.host else: host = request.get_host() confirmation_link = create_confirmation_link( prereg_user, host, Confirmation.USER_REGISTRATION) if is_signup: return redirect(confirmation_link) context = { 'email': email, 'continue_link': confirmation_link, 'full_name': full_name } return render(request, 'zerver/confirm_continue_registration.html', context=context) # This email address it not allowed to join this organization, so # just send the user back to the registration page. url = reverse('register') context = login_context(request) extra_context = { 'form': form, 'current_url': lambda: url, 'from_multiuse_invite': from_multiuse_invite, 'multiuse_object_key': multiuse_object_key, 'mobile_flow_otp': mobile_flow_otp, 'desktop_flow_otp': desktop_flow_otp } # type: Mapping[str, Any] context.update(extra_context) return render(request, 'zerver/accounts_home.html', context=context)
def test_akismet_nospam(self): self.mock_akismet('false') self.assertFalse(is_spam('text', HttpRequest()))
def setUp(self): request = HttpRequest() request.META = {'HTTP_HOST': 'example.com'} self.site = RequestSite(request)
def test_home_page_returns_correct_html(self): request = HttpRequest() response = home(request) self.assertIn(b'<h1>Contact Form</h1>', response.content)
def test_old_style_request(self): """The request has correct `site` attribute.""" middleware = CurrentSiteMiddleware() request = HttpRequest() middleware.process_request(request) self.assertEqual(request.site.id, settings.SITE_ID)
def test_set_without_xheader(self): self.settings_module.SECURE_PROXY_SSL_HEADER = ( 'HTTP_X_FORWARDED_PROTOCOL', 'https') req = HttpRequest() self.assertEqual(req.is_secure(), False)
def test_request(self): def get_response(request): return HttpResponse(str(request.site.id)) response = CurrentSiteMiddleware(get_response)(HttpRequest()) self.assertContains(response, settings.SITE_ID)
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 UploadFile(request): """上传文件""" if not request.method == "POST": return HttpResponse(json.dumps(u"{'state:'ERROR'}"), content_type="application/javascript") state = "SUCCESS" action = request.GET.get("action") # 上传文件 upload_field_name = { "uploadfile": "fileFieldName", "uploadimage": "imageFieldName", "uploadscrawl": "scrawlFieldName", "catchimage": "catcherFieldName", "uploadvideo": "videoFieldName", } UploadFieldName = request.GET.get( upload_field_name[action], USettings.UEditorUploadSettings.get(action, "upfile")) # 上传涂鸦,涂鸦是采用base64编码上传的,需要单独处理 if action == "uploadscrawl": upload_file_name = "scrawl.png" upload_file_size = 0 else: # 取得上传的文件 file = request.FILES.get(UploadFieldName, None) if file is None: return HttpResponse(json.dumps(u"{'state:'ERROR'}"), content_type="application/javascript") upload_file_name = file.name upload_file_size = file.size # 取得上传的文件的原始名称 upload_original_name, upload_original_ext = os.path.splitext( upload_file_name) # 文件类型检验 upload_allow_type = { "uploadfile": "fileAllowFiles", "uploadimage": "imageAllowFiles", "uploadvideo": "videoAllowFiles" } if action in upload_allow_type: allow_type = list( request.GET.get( upload_allow_type[action], USettings.UEditorUploadSettings.get(upload_allow_type[action], ""))) if upload_original_ext not in allow_type: state = u"服务器不允许上传%s类型的文件。" % upload_original_ext # 大小检验 upload_max_size = { "uploadfile": "filwMaxSize", "uploadimage": "imageMaxSize", "uploadscrawl": "scrawlMaxSize", "uploadvideo": "videoMaxSize" } max_size = int( request.GET.get( upload_max_size[action], USettings.UEditorUploadSettings.get(upload_max_size[action], 0))) if max_size != 0: from .utils import FileSize MF = FileSize(max_size) if upload_file_size > MF.size: state = u"上传文件大小不允许超过%s。" % MF.FriendValue # 检测保存路径是否存在,如果不存在则需要创建 upload_path_format = { "uploadfile": "filePathFormat", "uploadimage": "imagePathFormat", "uploadscrawl": "scrawlPathFormat", "uploadvideo": "videoPathFormat" } path_format_var = get_path_format_vars() path_format_var.update({ "basename": upload_original_name, "extname": upload_original_ext[1:], "filename": upload_file_name, }) # 取得输出文件的路径 OutputPathFormat, OutputPath, OutputFile = get_output_path( request, upload_path_format[action], path_format_var) # 所有检测完成后写入文件 if state == "SUCCESS": if action == "uploadscrawl": state = save_scrawl_file(request, os.path.join(OutputPath, OutputFile)) else: # 保存到文件中,如果保存错误,需要返回ERROR state = save_upload_file(file, os.path.join(OutputPath, OutputFile)) # 在django项目中配置你的产品域名 # project_url_config = USettings.gSettings.PROJECT_URL project_url_config = 'http://' + HttpRequest.get_host(request) # 返回数据 return_info = { # 保存后的文件名称 # 'url': urljoin(project_url_config+USettings.gSettings.MEDIA_URL, OutputPathFormat), 'url': urljoin(project_url_config + USettings.gSettings.MEDIA_URL, OutputPathFormat), # 原始文件名 'original': upload_file_name, 'type': upload_original_ext, # 上传状态,成功时返回SUCCESS,其他任何值将原样返回至图片上传框中 'state': state, 'size': upload_file_size } return HttpResponse(json.dumps(return_info, ensure_ascii=False), content_type="application/javascript")
def test_redirect_report_builder(self): report, view = self._build_report_and_view() report.report_meta.created_by_builder = True report.save() request = HttpRequest() self.assertTrue(view.should_redirect_to_paywall(request))
def test_default_argument_suppresses_exceptions(self): response = HttpResponse() response.set_signed_cookie("c", "hello") request = HttpRequest() request.COOKIES["c"] = response.cookies["c"].value[:-2] + "$$" self.assertIsNone(request.get_signed_cookie("c", default=None))
def getBaseState(request, area='', nowDate=''): if area is None and nowDate is None: return HttpRequest('parameters is not enough') try: d = datetime.strptime(nowDate, '%Y-%m-%d %H:%M') except Exception as err: # 为d赋值now时,注意需要加入时区 d = datetime.utcnow().replace(tzinfo=utc) # 好像是时区问题所以必须加8小时才行 # 此处暂时注释掉,不需要加8 # d = d.astimezone(pytz.UTC)+timedelta(hours=8) #bbxinfolist = BBXInfo.objects.all().filter(area=area) timelimit = d.__str__() lst = [] #for x in bbxinfolist: # dic = dict() # dic['code']=x.code # dic['name']=x.code # dt=x.bbxspacetempinfo_set.filter(nowdate__lte=timelimit).aggregate(Max('nowdate')) # if dt['nowdate__max'] is not None: # dic['state'] = dt['nowdate__max'] # dic['lastestTime'] = dt['nowdate__max'].strftime('%Y-%m-%d %H:%M:%S') # else: # dic['state']='invalid' # dic['lastestTime']='近期没有数据' # lst.append(dic) #不知道这么比是不是会有bug 直接用datetime比可能更稳一点 querySet = BBXSpaceTempInfo.objects.values('code').annotate( Max('nowdate')).filter(bid__area=area, nowdate__lte=timelimit) for x in querySet: dic = dict() dic['code'] = x['code'] dic['name'] = x['code'] if x['nowdate__max'] is not None: dic['state'] = x['nowdate__max'] dic['lastestTime'] = x['nowdate__max'].strftime( '%Y-%m-%d %H:%M:%S') else: dic['state'] = 'invalid' dic['lastesttime'] = '近期没有数据' lst.append(dic) ok_date = d - timedelta(hours=dateState_dict['normal']) late_date = d - timedelta(hours=dateState_dict['late']) notarrival_date = d - timedelta(hours=dateState_dict['noarrival']) #根据日期判断状态 for x in lst: state = x['state'] if state != 'invalid': #光用秒减的话int可能会溢出导致判断失败,所以加个days判断 if state <= notarrival_date: state = 'invalid' elif state < ok_date: if state < late_date: state = 'noarrival' else: state = 'late' else: state = 'ok' x['state'] = state return HttpResponse(json.dumps(lst), content_type="application/json")
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)