def confirm(request): if not request.user.is_authenticated: return HttpResponseRedirect(reverse("register")) donation = request.GET.get("donation") total = 1 if not donation else int(donation) + 1 cancel_url = ( "{}?donation={}".format(reverse("confirm"), donation) if donation else reverse("confirm") ) success_url = ( "{}?donation={}".format(reverse("memberships_settings"), donation) if donation else reverse("memberships_settings") ) stripe_gateway = StripeGateway() session_id = stripe_gateway.create_checkout_session( member=request.user.member, success_url=request.build_absolute_uri(success_url), cancel_url=request.build_absolute_uri(cancel_url), ) return render( request, "memberships/confirm.html", { "donation": donation, "total": total, "stripe_public_key": settings.STRIPE_PUBLIC_KEY, "stripe_session_id": session_id, "recaptcha_site_key": settings.RECAPTCHA_SITE_KEY, }, )
def get(self, request, path, head=False, *args, **kwargs): if not self.resource.exists: raise Http404("Resource doesn't exists") if not path.endswith("/") and self.resource.is_collection: return HttpResponseRedirect(request.build_absolute_uri() + "/") if path.endswith("/") and self.resource.is_object: return HttpResponseRedirect( request.build_absolute_uri().rstrip("/")) response = HttpResponse() if head: response['Content-Length'] = 0 if not self.has_access(self.resource, 'read'): return self.no_access() if self.resource.is_object: response['Content-Type'] = self.resource.content_type response['ETag'] = self.resource.getetag if not head: response['Content-Length'] = self.resource.getcontentlength response.content = self.resource.read() elif not head: response = render_to_response( self.template_name, dict(resource=self.resource, base_url=self.base_url)) response['Last-Modified'] = self.resource.getlastmodified return response
def paynow_payment(request): """This is the functions that initiates the payment process""" if request.method == 'POST': form = MobilePaymentForm(request.POST) if form.is_valid(): cleaned_data = form.cleaned_data # Generate unique Transaction ID transaction_id = generate_transaction_id() pinfo = dict() # Generate Urls to pass to Paynow. These are generated dynamicaly # and are absolute r = reverse('paynow:paynow_update', args=(transaction_id, )) pinfo['resulturl'] = request.build_absolute_uri(r) r = reverse('paynow:paynow_return', args=(transaction_id, )) pinfo['returnurl'] = request.build_absolute_uri(r) # Payment amount pinfo['amount'] = str(cleaned_data['amount']) # Payment reference pinfo['reference'] = transaction_id # refer to the project settin pinfo['id'] = str(settings.PAYNOW_INTEGRATION_ID) pinfo['additionalinfo'] = 'Payment from ' pinfo['additionalinfo'] += str(cleaned_data['cellphone']) if cleaned_data['reference'] != '': pinfo['additionalinfo'] += ' - ' + cleaned_data['reference'] # authemail can be blank. If set it is used in the login in # process on paynow pinfo['authemail'] = '' pinfo['status'] = 'Message' # Create the necessary query string using function query_string = paynow_create_url_query( pinfo, settings.PAYNOW_INTEGRATION_KEY) # do a request paynow_request = urllib.request.Request(settings.PAYNOW_INIT_URL) result = urllib.request.urlopen(paynow_request, query_string) result = result.read().decode('utf-8') if check_initiate_response(result, settings.PAYNOW_INTEGRATION_KEY): resp = parse_paynow_message(result) # save payment to database, and record as unpaid payment = PaynowPayment( user=request.user, status='unpaid', cellphone=str(cleaned_data['cellphone']), reference=pinfo['reference'], amount=cleaned_data['amount'], additionalinfo=cleaned_data['reference'], authemail=pinfo['authemail'], init_status=resp['status'], pollurl=resp['pollurl'], browserurl=resp['browserurl']) payment.save() # redirect browser to paynow site for payment return redirect(resp['browserurl'], permanent=True) else: msg = 'Error in processing payment. Please try again' messages.error(request, msg) return redirect(reverse('index'))
def callback_google_auth(request): """ Check if params is correct, get user credentials and return the redirect url """ if request.method != "GET": logger.error("Request method is not GET") return HttpResponse(status=400) if 'state' not in request.GET or 'code' not in request.GET or 'scope' not in request.GET: logger.debug("State, Code or Scope not found in request.GET") return HttpResponse(status=400) state = request.GET.get('state') CLIENT_CONFIG = utils_youtube.create_client_config() # This scope will allow the application to create and remove livestreams SCOPES = ['https://www.googleapis.com/auth/youtube.force-ssl'] # Use the client_secret.json file to identify the application requesting # authorization. The client ID (from that file) and access scopes are # required. try: flow = google_auth_oauthlib.flow.Flow.from_client_config( client_config=CLIENT_CONFIG, scopes=SCOPES, state=state) url_aux = request.build_absolute_uri(reverse('callback_google_auth')) flow.redirect_uri = url_aux.replace("http://", "https://") url_aux = request.build_absolute_uri() authorization_response = url_aux.replace("http://", "https://") flow.fetch_token(authorization_response=authorization_response) next_url = base64.b64decode(state).decode( 'utf-8') # decode Studio EOL URL # Store the credentials in the session. # ACTION ITEM for developers: # Store user's access and refresh tokens in your data store if # incorporating this code into your real app. credentials = flow.credentials except InvalidGrantError: logger.error( "Error with Exchange authorization code for refresh and access tokens, User {}".format( request.user )) return HttpResponse(status=400) # Load credentials from the session. credentials_dict = { 'token': credentials.token, 'refresh_token': credentials.refresh_token, 'token_uri': credentials.token_uri, 'scopes': credentials.scopes, 'expiry': str(credentials.expiry)} data = utils_youtube.check_permission_youtube(credentials_dict, request.user) EolGoogleAuth.objects.update_or_create( user=request.user, defaults={'credentials':json.dumps(credentials_dict), 'channel_enabled':data['channel'], 'livebroadcast_enabled':data['livestream'], 'custom_live_streaming_service': data['livestream_zoom']}) return HttpResponseRedirect(next_url)
def wrapper(request, *args, **kwargs): #decode jwt token request_path = request.build_absolute_uri() request_host = request.get_host() if request.is_secure: skip_length = 7 + len(request_host) request_path = request_path[skip_length:] else: skip_length = 6 + len(request_host) request_path = request_path[skip_length:] try: token = request.COOKIES['IdToken'] if token == '': redirect_path = "/login/?next=" + request_path return redirect(redirect_path) except: redirect_path = "/login/?next=" + request_path return redirect(redirect_path) status, claims = is_token_valid(token) if status: return f(request,claims['email'],idtoken=token,*args, **kwargs) else: redirect_path = "/login/?next=" + request_path return redirect(redirect_path)
def ows(request): params = {key.upper(): request.GET[key] for key in request.GET.keys()} url = "{0}?{1}".format(settings.GISQUICK_MAPSERVER_URL.rstrip("/"), request.environ['QUERY_STRING']) abs_project = abs_project_path(params.get('MAP')) url = set_query_parameters(url, {'MAP': abs_project}) owsrequest = urllib.request.Request(url) owsrequest.add_header("User-Agent", "Gisquick") resp_content = b"" with contextlib.closing(urllib.request.urlopen(owsrequest)) as resp: while True: data = resp.read() if not data: break resp_content += data if params.get('REQUEST', '') == 'GetCapabilities': resp_content = resp_content.replace( settings.GISQUICK_MAPSERVER_URL.encode(), request.build_absolute_uri(request.path).encode()) content_type = resp.getheader('Content-Type') status = resp.getcode() return HttpResponse(resp_content, content_type=content_type, status=status)
def zoom_api(request): """ GET REQUEST Generate refresh token from Zoom Api Update refresh token in models Redirect to Studio EOL """ # check method and params if request.method != "GET": return HttpResponse(status=400) if 'code' not in request.GET or 'redirect' not in request.GET: return HttpResponse(status=400) user = request.user authorization_code = request.GET.get('code') redirect = base64.b64decode(request.GET.get('redirect')).decode( 'utf-8') # decode Studio EOL URL redirect_uri = request.build_absolute_uri().split( '&code')[0] # build uri without code param #redirect_uri = redirect_uri.replace('http', 'https') token = get_refresh_token(authorization_code, redirect_uri) if 'error' in token: logger.error("Error get_refresh_token {}".format(token['error'])) return HttpResponse(status=400) _update_auth(user, token['refresh_token']) return HttpResponseRedirect(redirect)
def gettoken(request): auth_code = request.GET['code'] redirect_uri = request.build_absolute_uri( reverse('authorization:gettoken')) token = get_token_from_code(auth_code, redirect_uri) access_token = token['access_token'] info = get_me(access_token) mail = None if info['mail']: mail = info['mail'] else: mail = info['userPrincipalName'] username = mail.split('@')[0] if not User.objects.filter(username=username).exists(): user = User.objects.create_user(username, mail) user.first_name = info['displayName'] user.save() user = User.objects.get(username=username) request.session['mail'] = mail # info['mail'] request.session['fullName'] = info['displayName'] role = None if Student.objects.filter(student_id=user.id).exists(): role = 'student' elif Teacher.objects.filter(teacher_id=user.id).exists(): role = 'teacher' elif Methodist.objects.filter(methodist_id=user.id).exists(): role = 'methodist' request.session['role'] = role request.session['user_id'] = user.id if role == 'teacher': find_branches(user.id) return HttpResponseRedirect('../../')
def get_redirect_url(request): if getattr(s, 'REDIRECT_URL'): return s.REDIRECT_URL # Hack the request.GET if FLD not in request.GET: get = request.GET.copy() get.update({ FLD: request.build_absolute_uri(request.path_info) }) request.GET = get return urlquote("{request_url}?{query_string}".format( request_url=request.build_absolute_uri(r('ulogin_postback')), query_string=smart_unicode(urllib.parse.unquote(request.GET.urlencode())) ))
def post_share(request, post_id): # Retrieve post by id post = get_object_or_404(Post, id=post_id, status='published') sent = False if request.method == 'POST': # Form was submitted form = EmailPostForm(request.POST) if form.is_valid(): # Form fields passed validation cd = form.cleaned_data post_url = request.build_absolute_uri(post.get_absolute_url()) subject = '{} ({}) recommends you reading "{}"'.format( cd['name'], cd['email'], post.title) message = 'Read "{}" at {}\n\n{}\'s comments: {}'.format( post.title, post_url, cd['name'], cd['comments']) send_mail(subject, message, '*****@*****.**', [cd['to']]) sent = True create_action(request.user, 'shared via email a post titled ', post) return render(request, 'posts/share.html', { 'post': post, 'form': form, 'sent': sent, 'cd': cd }) # ... send email else: form = EmailPostForm() return render(request, 'posts/share.html', { 'post': post, 'form': form, 'sent': sent })
def home(request): if 'mail' in request.session: return HttpResponseRedirect('../') redirect_uri = request.build_absolute_uri( reverse('authorization:gettoken')) sign_in_url = get_signin_url(redirect_uri) context = {'signin_url': sign_in_url} return render(request, 'authorization/authorization.html', context)
def oidc_failed(request): if request.user.is_authenticated(): return HttpResponseRedirect('/') access_warn(request, "401 Unauthorized by oidc") return render("oidc_failed.mako", request, dict(uri=request.build_absolute_uri()), status=401)
def get_badge_url(request, releasewatch): if not releasewatch: return selector = encode_badge_selector(releasewatch) uri = reverse("badge_info", kwargs={"selector": selector}) params = [ ("label", "release"), ("query", "$.status"), ("maxAge", str(60 * 60 * 12)), # 12 hrs ("uri", request.build_absolute_uri(uri)), ("link", request.build_absolute_uri("/")), ] url = "%s?%s" % (BADGE_URL, urllib.parse.urlencode(params)) logger.info("%r selector, url: %r %r", releasewatch, selector, url) return url
def build_absolute_uri(request, url): """ 把相对地址转换成绝对地址 """ if not url: return "" if not url.startswith("http"): return request.build_absolute_uri(url) return url
def payments_send_confirmation(request, email): dashboard_url = request.build_absolute_uri(reverse("dashboard")) from tapiriik.web.email import generate_message_from_template, send_email message, plaintext_message = generate_message_from_template( "email/payment_confirm.html", {"url": dashboard_url}) send_email(email, "Thanks, %s!" % request.POST["first_name"], message, plaintext_message=plaintext_message)
def retrieve(self, request, img_uuid=None): res = get_one_entity.delay(img_uuid) task_res = res.get() domain = request.build_absolute_uri('/')[:-1] # file = open("/media/vect-"+img_uuid+".mesh") # return HttpResponse(str(file), content_type='application/octet-stream') with urllib.request.urlopen(domain+"/media/vect-"+img_uuid+".mesh") as url: s = url.read() return HttpResponse(s, content_type='application/octet-stream')
def get_google_credential(request): client_key = json.load(open('static/Portfolio/json/google.json')) flow = client.OAuth2WebServerFlow( client_id=client_key['web']['client_id'], client_secret=client_key['web']['client_secret'], scope='https://www.googleapis.com/auth/userinfo.profile', redirect_uri=request.build_absolute_uri(reverse('finish_google_auth')) ) return flow
def sso(request): payload = request.GET.get('sso') signature = request.GET.get('sig') if None in [payload, signature]: return HttpResponseBadRequest( 'No SSO payload or signature. Please contact support if this problem persists.' ) ## Validate the payload try: payload = urllib.parse.unquote(payload) decoded = base64.decodestring(payload) assert 'nonce' in decoded assert len(payload) > 0 except AssertionError: return HttpResponseBadRequest( 'Invalid payload. Please contact support if this problem persists.' ) key = str(settings.DISCOURSE_SSO_SECRET) # must not be unicode h = hmac.new(key, payload, digestmod=hashlib.sha256) this_signature = h.hexdigest() if this_signature != signature: return HttpResponseBadRequest( 'Invalid payload. Please contact support if this problem persists.' ) ## Build the return payload qs = parse_qs(decoded) params = { 'nonce': qs['nonce'][0], 'email': request.user.email, 'external_id': request.user.id, 'username': request.user.username, 'name': request.user.get_full_name(), 'avatar_url': request.build_absolute_uri(request.user.profile.photo.url), 'avatar_force_update': True, 'admin': request.user.is_staff, 'moderator': request.user.is_staff } return_payload = base64.encodestring(urllib.parse.urlencode(params)) h = hmac.new(key, return_payload, digestmod=hashlib.sha256) query_string = urllib.parse.urlencode({ 'sso': return_payload, 'sig': h.hexdigest() }) ## Redirect back to Discourse url = '%s/session/sso_login' % settings.DISCOURSE_BASE_URL return HttpResponseRedirect('%s?%s' % (url, query_string))
def payments_claim_initiate(request, user, email): payment = Payments.GetPayment(email=email) if payment is None: return False claim_code = Payments.GenerateClaimCode(user, payment) reclaim_url = request.build_absolute_uri(reverse("payments_claim_return", kwargs={"code": claim_code})) from tapiriik.web.email import generate_message_from_template, send_email message, plaintext_message = generate_message_from_template("email/payment_reclaim.html", {"url":reclaim_url}) send_email(email, "Reclaim your payment on tapiriik.sfrunners.club", message, plaintext_message=plaintext_message) return True
def parse_openid_response(request): """Parse an OpenID response from a Django request.""" # Short cut if there is no request parameters. #if len(request.REQUEST) == 0: # return None current_url = request.build_absolute_uri() consumer = make_consumer(request) return consumer.complete(dict(list(request.REQUEST.items())), current_url)
def autorization_pdf_maker(request, parcela_id): now = datetime.datetime.now() parcela = get_object_or_404(Parcela, id=parcela_id) html = render_to_string('parcelas/pdf_autorizacion.html', {'parcela': parcela, 'now': now}) response = HttpResponse(content_type='application/pdf') response['Content-Disposition'] = 'filename=parcela_{}.pdf'.format(parcela.id) weasyprint.HTML(string=html, base_url=request.build_absolute_uri()).write_pdf(response) return response
def payments_claim_initiate(request, user, email): payment = Payments.GetPayment(email=email) if payment is None: return False claim_code = Payments.GenerateClaimCode(user, payment) reclaim_url = request.build_absolute_uri(reverse("payments_claim_return", kwargs={"code": claim_code})) from tapiriik.web.email import generate_message_from_template, send_email message, plaintext_message = generate_message_from_template("email/payment_reclaim.html", {"url":reclaim_url}) send_email(email, "Reclaim your payment on tapiriik.com", message, plaintext_message=plaintext_message) return True
def start_meeting(request): """ Start a meeting with registrants (only hoster can do) """ # check method and params if request.method != "GET": return HttpResponse(status=400) if request.user.is_anonymous: logger.error("EolZoom: User is Anonymous") return HttpResponse(status=400) if 'code' not in request.GET or 'data' not in request.GET: return HttpResponse(status=400) user = request.user authorization_code = request.GET.get('code') # data with meeting_id and course_id (BASE64) data = base64.b64decode(request.GET.get('data')) args = json.loads(data.decode("utf-8")) aux = ['block_id', 'course_id', 'meeting_id', 'restricted_access', 'email_notification'] if not all([x in args for x in aux]): logger.error("EolZoom: Error with data: {}".format(args)) return HttpResponse(status=400) try: usage_key = UsageKey.from_string(args['block_id']) course_key = CourseKey.from_string(args['course_id']) except InvalidKeyError: logger.error("EolZoom: Error with course_id or usage_key, data: {}".format(args)) return HttpResponse(status=400) if type(args['restricted_access']) is not bool or type(args['email_notification']) is not bool: logger.error("EolZoom: Error with data(restricted_access or email_notification): {}".format(args)) return HttpResponse(status=400) try: meeting_id = args['meeting_id'] zoom_mapp = EolZoomMappingUserMeet.objects.get(meeting_id=meeting_id) if user != zoom_mapp.user: logger.error("EolZoom: Error in start_meeting, request.user != user_model.user, request.user: {}, user_model.user: {}".format(user, zoom_mapp.user)) return HttpResponse(status=400) zoom_mapp.course_key = usage_key.course_key zoom_mapp.restricted_access = args['restricted_access'] zoom_mapp.email_notification = args['email_notification'] zoom_mapp.usage_key = usage_key zoom_mapp.save() except EolZoomMappingUserMeet.DoesNotExist: logger.error("EolZoom: Error with EolZoomMappingUserMeet dont exists, meeting_id: {}".format(meeting_id)) return HttpResponse(status=400) redirect_uri = request.build_absolute_uri().split( '&code')[0] # build uri without code param #redirect_uri = redirect_uri.replace('http', 'https') token = get_refresh_token(authorization_code, redirect_uri) if 'error' in token: logger.error("Error get_refresh_token {}".format(token['error'])) return HttpResponse(status=400) _update_auth(user, token['refresh_token']) return HttpResponseRedirect(create_start_url(args['meeting_id']))
def get_request_key(request): """Ask tequla server for the key""" params = "urlaccess=" + request.build_absolute_uri( ) + "\nservice=" + settings.TEQUILA_SERVICE + "\nrequest=name,firstname,email,uniqueid" if settings.TEQUILA_ALLOW_GUEST: params += '\nallows=categorie=epfl-guests' f = urllib.request.urlopen( settings.TEQUILA_SERVER + '/cgi-bin/tequila/createrequest', params.encode()) return re.search('key=(.*)', f.read().decode()).group(1)
def wm_update(request, username): ''' Password Manager: store new user password in db ''' try: username = str(username) full_url = ''.join([request.build_absolute_uri()]) _get_user = web_manager_password.objects.create(site_url=full_url, account_name=str(username), account_password=encrypt_password(request.POST['fld_n_password'])) return HttpResponseRedirect(reverse_lazy("web_manager:manage_password", kwargs={'username':username})) except: return HttpResponseRedirect(reverse_lazy("web_manager:manage_password", username))
def login(self, request, user): """ Preserve badgr_app session data across Django login() boundary """ badgr_app = get_session_badgr_app(request) if badgr_app is None: url = request.build_absolute_uri() print(('Badgr app is none in login {}'.format(url))) ret = super(BadgrAccountAdapter, self).login(request, user) set_session_badgr_app(request, badgr_app) return ret
def get_pdfas_url(request, sign_data): values = { 'connector': 'onlinebku', 'invoke-app-url': request.build_absolute_uri(reverse('ecs.signature.views.sign_receive', kwargs={'pdf_id': sign_data.id})), 'invoke-app-url-target': '_top', 'invoke-app-error-url': request.build_absolute_uri(reverse('ecs.signature.views.sign_error', kwargs={'pdf_id': sign_data.id})), 'locale': 'DE', 'num-bytes': str(len(sign_data['pdf_data'])), 'sig_type': 'SIGNATURBLOCK_DE', 'pdf-url': request.build_absolute_uri(reverse('ecs.signature.views.sign_send', kwargs={'pdf_id': sign_data.id})), 'verify-level': 'intOnly', # Dies bedeutet, dass eine Signaturprüfung durchgeführt wird, allerdings ohne Zertifikatsprüfung. 'filename': sign_data['document_filename'], #'preview': 'false', #'mode': 'binary', #'inline': 'false', #'pdf-id': sign_data.id, } data = urllib.parse.urlencode({k: v.encode('utf-8') for k, v in values.items()}) return '{0}Sign?{1}'.format(settings.PDFAS_SERVICE, data)
def __init__(self, request, *args, **kwargs): super(DjangoError, self).__init__(*args, **kwargs) self.update({ 'url': request.build_absolute_uri(), 'type': 'django', }) try: self['user'] = json.dumps(self.get_user_info(request)) except Exception: logger.exception("Exception whilst reporting error to keyerror.com")
def redirect_weixin_login(self, request): """ 跳转到微信登录 """ url = urllib.parse.urlparse(request.build_absolute_uri()) path = weixin_settings.WEIXIN_LOGIN_URL query = urllib.parse.urlencode({'c_url': request.get_full_path()}) callback_url = urllib.parse.urlunsplit( (url.scheme, url.netloc, path, query, url.fragment)) state = self.set_weixin_oauth_state(request) redirect_uri = self.get_oauth_redirect_url(callback_url, state) return HttpResponseRedirect(redirect_uri)
def transform_usage_error(caller, self, request, *args, **kwargs): """ Can be used for both html and ajax requests, so only 'error' HTTP codes should be returned if an exception is encountered. """ dm = request.datamanager return_to_home_url = game_view_url("pychronia_game-homepage", datamanager=dm) return_to_home = HttpResponseRedirect(return_to_home_url) from ..authentication import TEMP_URL_USERNAME return_to_login_url = game_view_url("pychronia_game-login", datamanager=dm) return_to_login_next_url = request.build_absolute_uri() # we do a HACK to deal with in-url usernames (except UNIVERSAL_URL_USERNAME username, which stays as is) return_to_login_next_url = return_to_login_next_url.replace("/%s/" % dm.user.username, "/%s/" % TEMP_URL_USERNAME) return_to_login_qs = urllib.parse.urlencode(dict(next=return_to_login_next_url)) return_to_login = HttpResponseRedirect("%s?%s" % (return_to_login_url, return_to_login_qs)) assert urlresolvers.resolve(return_to_home_url) try: return caller(self, request, *args, **kwargs) except AccessDeniedError as e: if request.is_ajax(): return HttpResponseForbidden(repr(e)) if request.datamanager.user.is_impersonation: # Will mainly happen when we switch between two impersonations with different access rights, on a restricted page dm.user.add_warning(_("Currently impersonated user can't access view '%s'") % self.TITLE) else: dm.user.add_error(_("Access denied to page %s") % self.TITLE) dm.logger.warning("Access denied to page %s" % self.TITLE, exc_info=True) if not request.datamanager.user.impersonation_target and request.datamanager.user.is_anonymous: return return_to_login # special case for REAL anonymous users return return_to_home except (GameError, POSError) as e: if request.is_ajax(): return HttpResponseBadRequest(repr(e)) dm.logger.critical("Unexpected game error in %s" % self.NAME, exc_info=True) dm.user.add_error(_("An unexpected server error occurred, please retry (%s)") % ( e if dm.is_master() else _("contact webmaster if it persists"))) return return_to_home # else, we let 500 handler take are of all other (very abnormal) exceptions assert False
def render_openid_request(request, openid_request, return_to, trust_root=None): """Render an OpenID authentication request.""" if trust_root is None: trust_root = getattr(settings, 'OPENID_TRUST_ROOT', request.build_absolute_uri('/')) if openid_request.shouldSendRedirect(): redirect_url = openid_request.redirectURL(trust_root, return_to) return HttpResponseRedirect(redirect_url) else: form_html = openid_request.htmlMarkup( trust_root, return_to, form_tag_attrs={'id': 'openid_message'}) return HttpResponse(form_html, content_type='text/html;charset=UTF-8')
def view_post(request, slug): post = get_object_or_404(Blog, slug=slug) rest_url_a = "http://api.facebook.com/restserver.php?format=json&method=links.getStats&urls="+"http://"+post.url rest_url_b = rest_url_a.replace('http://www.heyandie.com/blog','http://www.heyandie.com/article') response_a = urllib.request.urlopen(rest_url_a) response_b = urllib.request.urlopen(rest_url_b) data_a = json.loads(response_a.read().decode('utf-8')) data_b = json.loads(response_b.read().decode('utf-8')) share_count = 0; if 0 in data_a: share_count += data_a[0]['total_count'] if 0 in data_b: share_count += data_b[0]['total_count'] og_tags = { 'fb:app_id': 224598357874885, 'og:type': 'article', 'article:publisher': 'https://facebook.com/andie.rabino', 'og:site_name': 'Andie Rabino', 'og:title': post.title, 'og:description': post.excerpt, 'og:url': request.build_absolute_uri(reverse('view_blog_post', kwargs={'slug':post.slug})), 'og:image': request.build_absolute_uri(reverse('index')) + post.image } title = post.title return render_to_response('blog/post.html', { 'og_tags': og_tags, 'post': post, 'title': title, 'posts': Blog.objects.exclude(id__in=(post.id,)).order_by('-posted')[:4], 'header_class': "header-white", 'share_count': share_count })
def oauth_session(request, state=None, token=None): """ Constructs the OAuth2 session object. """ if settings.DISCORD_REDIRECT_URI is not None: redirect_uri = MYURL+'discord/cb' else: redirect_uri = request.build_absolute_uri( reverse('discord_bind_callback')) scope = (['email','identify',] if settings.DISCORD_EMAIL_SCOPE else ['identity', 'guilds.join']) return OAuth2Session(settings.DISCORD_CLIENT_ID, redirect_uri=redirect_uri, scope=scope, token=token, state=state)
def sso(request): payload = request.GET.get('sso') signature = request.GET.get('sig') if None in [payload, signature]: return HttpResponseBadRequest('No SSO payload or signature. Please contact support if this problem persists.') ## Validate the payload try: payload = urllib.parse.unquote(payload) decoded = base64.decodestring(payload) assert 'nonce' in decoded assert len(payload) > 0 except AssertionError: return HttpResponseBadRequest('Invalid payload. Please contact support if this problem persists.') key = str(settings.DISCOURSE_SSO_SECRET) # must not be unicode h = hmac.new(key, payload, digestmod=hashlib.sha256) this_signature = h.hexdigest() if this_signature != signature: return HttpResponseBadRequest('Invalid payload. Please contact support if this problem persists.') ## Build the return payload qs = parse_qs(decoded) params = { 'nonce': qs['nonce'][0], 'email': request.user.email, 'external_id': request.user.id, 'username': request.user.username, 'name': request.user.get_full_name(), 'avatar_url': request.build_absolute_uri(request.user.profile.photo.url), 'avatar_force_update': True, 'admin': request.user.is_staff, 'moderator': request.user.is_staff } return_payload = base64.encodestring(urllib.parse.urlencode(params)) h = hmac.new(key, return_payload, digestmod=hashlib.sha256) query_string = urllib.parse.urlencode({'sso': return_payload, 'sig': h.hexdigest()}) ## Redirect back to Discourse url = '%s/session/sso_login' % settings.DISCOURSE_BASE_URL return HttpResponseRedirect('%s?%s' % (url, query_string))
def index(request): before = request.GET.get('before') after = request.GET.get('after') form = ImageForm({'before': before, 'after': after}) if form.is_valid(): before, after = form.generateImages() context = { 'before': before, 'after': after } else: example = reverse('homepage') context = { 'usage': True, 'example': request.build_absolute_uri(example) } return render(request, 'home.html', context)
def home(request): context = {} context['server'] = request.build_absolute_uri('/') verify_auth(request, context) try: if r.get('recent') == b'null' or r.get('recent') == None: context['cached'] = False item_req = urllib.request.Request('http://' + settings.EXP_API + ':8000/api/data/recent/6') item_json = urllib.request.urlopen(item_req).read().decode('utf-8') resp = json.loads(item_json) r.set('recent', item_json) else: context['cached'] = True resp = json.loads(r.get('recent').decode('utf-8')) except redis.ConnectionError: item_req = urllib.request.Request('http://' + settings.EXP_API + ':8000/api/data/recent/6') item_json = urllib.request.urlopen(item_req).read().decode('utf-8') resp = json.loads(item_json) context["items"] = resp["resp"]["items"] context["location"] = "home" return render(request, "index.html", context)
def index(request): if request.method == 'POST': dudas_form = DudasForm(request.POST) if dudas_form.is_valid(): nom = escape(dudas_form.cleaned_data['nombre']) tip = int(dudas_form.cleaned_data['tipo']) mail = escape(dudas_form.cleaned_data['email']) det = escape(dudas_form.cleaned_data['detalle']) # Enviar notificación TIPOS_DUDAS = ( ('-1', '-- Seleccione un tipo --'), ('0', 'Área comercial'), ('1', 'Área académica'), ('2', 'Registro y Control'), ('3', 'Área financiera'), ('4', 'Área de marketing'), ('5', 'Otras cuestiones')) path = request.build_absolute_uri(reverse('faq:index')) mensj = "Se ha recibido una nueva duda desde " + path +".\n\nNombre: " + nom + "\nCorreo electrónico: " + mail + "\nDetalle: " + det email_dest = '*****@*****.**' send_mail('Formación CRM - Duda de ' + TIPOS_DUDAS[tip+1][1], mensj, settings.DEFAULT_FROM_EMAIL, [email_dest], fail_silently=False) return render(request, 'faq/redirect.html') else: return render(request, 'faq/index.html', { 'dudas_form': dudas_form }) else: # GET dudas_form = DudasForm() fuente = get_object_or_404(FuentesJSON, nombre = "faq") response = urllib.request.urlopen(fuente.filename_fuente) preguntas = json.loads(response.read().decode('utf-8')) context = { 'dudas_form': dudas_form, 'preguntas': preguntas } return render(request, 'faq/index.html', context)
def payments_send_confirmation(request, email): dashboard_url = request.build_absolute_uri(reverse("dashboard")) from tapiriik.web.email import generate_message_from_template, send_email message, plaintext_message = generate_message_from_template("email/payment_confirm.html", {"url": dashboard_url}) send_email(email, "Thanks, %s!" % request.POST["first_name"], message, plaintext_message=plaintext_message)
def get_url(self, request): return request.build_absolute_uri() def get_redirect(self, request, url):