def complete(request): if request.method == "POST": os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'choice.settings') django.setup() compType = request.POST["compType"] print 'type ' + compType matchupNames = request.POST["matchupNames"] choices = request.POST['choices'] TTChoose = request.POST["TTChoose"] Time = request.POST['Time'] username = request.POST['username'] familiarity = int(json.loads(request.POST["familiarity"])) print "familiarity", familiarity if get_real_ip(request) is not None: ip = get_real_ip(request) print 'ip: ', ip c = choiceData(username=username, compType=compType, matchupNames=matchupNames, choices=choices, TTChoose=TTChoose, CTime=Time, ip=ip, familiarity=familiarity) c.save() results = ['test1', 'test2'] # valid = validateHuman( ctype, num_ctype, next_ctype_index = get_next_ctype(compType) # set validation data for Amazon payment if ctype == "end": secret_code = set_user_info(username) context_dict = {'results': results, 'next_ctype': ctype, 'username': username, 'num_ctype': num_ctype, 'completed': next_ctype_index, 'secret_code': secret_code} return render(request, 'app/complete_ajax.html', context_dict) context_dict = {'results': results, 'next_ctype': ctype, 'username': username, 'num_ctype': num_ctype, 'completed': next_ctype_index} return render(request, 'app/complete_ajax.html', context_dict)
def log_activity(request, action_type, act_meta): if request.user.is_authenticated(): ActivityLog.objects.create(actor=request.user, actor_ip=get_real_ip(request), action_type=action_type, act_meta=act_meta) else: ActivityLog.objects.create(actor_ip=get_real_ip(request), action_type=action_type, act_meta=act_meta)
def login_logger(request, **kwargs): # no borrar nada de aqui user = User.objects.filter(username=request.user.username)[0] browser = get_user_agent(request) # TODO: mejorar esto despues if get_real_ip(request) is not None: UserLogger.objects.create(user=user, ip_address=get_real_ip(request), description=browser) if get_ip(request) is not None: UserLogger.objects.create(user=user, ip_address=get_ip(request), description=browser)
def post(self, request): username = request.POST.get('username').strip() password = request.POST.get('password') if username != "" and password != "": if username.find('@') != -1: username_list = username.split("@") name = username_list[0] domain = username_list[1] if domain.lower() == 'django': if not Manager.objects.filter(username=name).first(): message = 'ContextError' else: check_user = Manager.objects.filter( username=name).first() if check_user.password == password: message = 'Done' request.session.set_expiry(7200) request.session['manage'] = username.replace( '@', '_') request.session[ 'is_manager'] = check_user.is_manager else: message = 'ContextError' else: message = 'ContextError' else: message = 'ContextError' else: message = 'Empty' context = {'msg': message} if message == "ContextError": LoginAttempts( ip=str(get_real_ip(request)), name=username, password=password, browser_family=request.user_agent.browser.family, browser_version=request.user_agent.browser.version_string, os_family=request.user_agent.os.family, os_version=request.user_agent.os.version_string, device_family=request.user_agent.device.family, manage=True).save() elif message == "Done": username = username.replace('@', '_') user_agents = UserAgents.objects.filter(user=username, logout=False) if user_agents.first(): user_agents = user_agents.latest('id') UserAgents.objects.filter(pk=user_agents.id).update( logout=True, end_session=timezone.now()) UserAgents( ip=str(get_real_ip(request)), user=username, browser_family=request.user_agent.browser.family, browser_version=request.user_agent.browser.version_string, os_family=request.user_agent.os.family, os_version=request.user_agent.os.version_string, device_family=request.user_agent.device.family).save() context['url'] = reverse('Dashboard:HomePage') return JsonResponse(context)
def log_error(request, error_code, error_type, error_meta): if request: if request.user.is_authenticated(): ErrorLog.objects.create(error_code=error_code, error_type=error_type, error_meta=error_meta, actor=request.user, actor_ip=get_real_ip(request)) else: ErrorLog.objects.create(error_code=error_code, error_type=error_type, error_meta=error_meta, actor_ip=get_real_ip(request)) else: ErrorLog.objects.create(error_code=error_code, error_type=error_type, error_meta=error_meta, actor_ip=None)
def unit_resources_pdf(request, slug, unit_slug): merger = PdfFileMerger() unit = get_object_or_404(Unit, curriculum__slug=slug, slug=unit_slug) for lesson in unit.lessons.exclude(keywords__keyword__slug="optional"): lesson_string = render_to_string("curricula/lesson_title.html", {'unit': unit, 'lesson': lesson}, request=request) lesson_page = pdfkit.from_string(lesson_string, False, options=settings.WKHTMLTOPDF_CMD_OPTIONS, configuration=pdfkit_config) lesson_page_pdf = StringIO(lesson_page) merger.append(PdfFileReader(lesson_page_pdf)) for resource in lesson.resources.all(): if resource.gd: try: remotePDF = urlopen(Request(resource.gd_pdf())).read() memoryPDF = StringIO(remotePDF) localPDF = PdfFileReader(memoryPDF) merger.append(localPDF) except Exception: attachments = [ { 'color': 'danger', 'title': 'URL', 'text': resource.url, }, { 'color': 'danger', 'title': 'Related Lesson', 'text': lesson.get_absolute_url(), }, ] ip = get_real_ip(request) slack_message('slack/message.slack', { 'message': "tried and failed to publish resource %s - %s (pk %s). " "Check to ensure that it's a publicly accessible Google Doc" % (resource.name, resource.type, resource.pk), 'user': request.user.get_username() or ip, }, attachments) return HttpResponse('PDF Generation Failed', status=500) response = HttpResponse(content_type='application/pdf') merger.write(response) response['Content-Disposition'] = 'inline;filename=unit%s_resources.pdf' % unit.number ip = get_real_ip(request) slack_message('slack/message.slack', { 'message': 'created a resource PDF from %s %s' % (slug, unit_slug), 'user': request.user.get_username() or ip, }) return response
def loginview(request, target): if request.method == 'POST': form = LoginForm(request.POST) if not form.is_valid(): # All validation rules pass form = LoginForm() context = {'form': form, 'error': 'Invalid form'} return scirius_render(request, 'accounts/login.html', context) username = form.cleaned_data['username'] password = form.cleaned_data['password'] user = authenticate(username=username, password=password) if user is not None: if user.is_active: login(request, user) try: sciriususer = SciriusUser.objects.get(user=user) except SciriusUser.DoesNotExist: sciriususer = SciriusUser.objects.create(user=user, timezone='UTC') if not form.cleaned_data['persistent']: request.session.set_expiry(0) logger = logging.getLogger('authentication') logger.info("Successful login for '%s' from '%s'", username, get_real_ip(request)) from rules.models import UserAction UserAction.create(action_type='login', user=user, force_insert=True) return redirect("/" + target) else: form = LoginForm() context = {'form': form, 'error': 'Disabled account'} logger = logging.getLogger('authentication') logger.error( "Invalid login attempt for disabled account '%s' from '%s'", username, get_real_ip(request)) return scirius_render(request, 'accounts/login.html', context) else: form = LoginForm() context = {'form': form, 'error': 'Invalid login'} logger = logging.getLogger('authentication') logger.error("Invalid login attempt for '%s' from '%s'", username, get_real_ip(request)) return scirius_render(request, 'accounts/login.html', context) else: form = LoginForm() context = {'form': form} return scirius_render(request, 'accounts/login.html', context)
def get_action_count(request, action): """ Get the raw count of actions a certain IP address has done """ authenticated = request.user.is_authenticated() if action == Limiter.PASTE_UPLOAD and settings.MAX_PASTE_UPLOADS_PER_USER == -1 and \ settings.MAX_PASTE_UPLOADS_PER_GUEST == -1: return 0 elif action == Limiter.PASTE_EDIT and settings.MAX_PASTE_EDITS_PER_USER == -1: return 0 elif action == Limiter.COMMENT and settings.MAX_COMMENTS_PER_USER == -1: return 0 count = 0 con = get_redis_connection("persistent") ip = get_real_ip(request) if action == Limiter.PASTE_UPLOAD: count = con.get("paste_upload_count:%s" % ip) elif action == Limiter.PASTE_EDIT: count = con.get("paste_edit_count:%s" % ip) elif action == Limiter.COMMENT: count = con.get("comment_count:%s" % ip) if count == None: return 0 else: return int(count)
def test_private_remote_address(self): request = HttpRequest() request.META = { 'REMOTE_ADDR': 'fe80::02ba', } ip = get_real_ip(request) self.assertEqual(ip, None)
def actualiza(request,uuid): if request.method == 'POST': data = json.loads(request.body) print 'actualiza..',data if Usuarios.objects.filter(uuid=uuid).count() >0 : _u=Usuarios.objects.get(uuid=uuid) _u.lat=data['position']['lat'] _u.lng=data['position']['lng'] _u.modelo_celular=data['model'] _u.version_celular=data['tipo'] _u.ip= get_real_ip(request) _u.save() c= simplejson.dumps('ok') return HttpResponse(c, content_type="application/json")
def wsAutenticarUnificado(request): respuestaRaw = {'success': False, 'data': {}} validacionProtocolo = validarProtocoloPeticion(request) if not validacionProtocolo['success']: return responder(validacionProtocolo) requestRaw = request.POST['request'] peticion = json.loads(requestRaw) if peticion["tipoIngreso"] == "fleetBiWeb": # si la peticion es desde la sistema web ip = get_real_ip(request) if ip is not None: # we have a real, public ip address for user direccionIp = ip else: # we don't have a real, public ip address for user direccionIp = "localhost" peticion["direccionIp"] = direccionIp validacionPeticion = validacionWsAutenticarUnificado(peticion) if not validacionPeticion['success']: return responder(validacionPeticion) respuestaRaw = autenticacion.autenticarUnificado(peticion) return responder(respuestaRaw)
def __init__(self, poll, request=None, data=None, **kwargs): super(VoteForm, self).__init__(data, **kwargs) self.poll = poll self.request = request self.fields['question'].queryset = poll.questions.all() if request: self.ip = get_real_ip(self.request) or get_ip(self.request)
def process_request(self, request): """ Identify the country by IP address. Store country code in session. """ new_ip_address = get_real_ip(request) old_ip_address = request.session.get('ip_address', None) if not new_ip_address and old_ip_address: del request.session['ip_address'] del request.session['country_code'] elif new_ip_address != old_ip_address: reader = geoip2.database.Reader(settings.GEOIP_PATH) try: response = reader.country(new_ip_address) # pylint: disable=no-member country_code = response.country.iso_code except geoip2.errors.AddressNotFoundError: country_code = "" request.session['country_code'] = country_code request.session['ip_address'] = new_ip_address log.debug(u'Country code for IP: %s is set to %s', new_ip_address, country_code) reader.close()
def get_next(request): vertices = json.loads(request.GET.get('vertices')) vertex_ranks = request.GET.getlist('vertex_ranks[]') vertex_indices = [int(_) for _ in request.GET.getlist('vertex_indices[]')] reflection, expansion, contraction = simplex_executor.get_next_points( np.array(vertices, dtype=np.float), np.array(vertex_ranks), ) for i in range(len(vertices)): Rank.objects.create( rank=vertex_ranks[i], index=vertex_indices[i], iteration=request.GET.get('iteration'), type='vertex', ) for point, type_ in zip( [reflection, expansion, contraction], ['reflection', 'expansion', 'contraction']): Job.objects.create( ipAddr=get_real_ip(request), value=json.dumps(point.tolist()), type=type_, ) return JsonResponse({ 'reflection': reflection.tolist(), 'expansion': expansion.tolist(), 'contraction': contraction.tolist(), })
def new_sms(request): """ Create a new SMS message ready to send """ # Get the IP address of the client ip_address = get_real_ip(request) if settings.DEBUG and ip_address is None: ip_address = "127.0.0.1" if ip_address is None: return Response(status=status.HTTP_401_UNAUTHORIZED) # Make the API a little more friendly by accepting numbers in strange formats # and trying to fix them up. if 'to' in request.data: new_to = re.sub('[^0-9]','', request.data['to']) if len(new_to) is 10: new_to = '1' + new_to new_to = '+' + new_to request.data['to'] = new_to serializer = PrivateSmsSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) sms = serializer.save(ip_address=ip_address) public_serializer = PublicSmsSerializer(sms) return Response(public_serializer.data, status=status.HTTP_201_CREATED)
def process_request(self, request): request.location = {} if not settings.DEBUG: ip_address = get_real_ip(request) else: # We'll set it to an LA based IP address if in debug mode ip_address = get_ip(request) if not ip_address: return None try: geodb_client = database.Reader( settings.GEOIP_PATH + '/GeoLite2-City.mmdb') except: return None try: response = geodb_client.city(ip_address) except: return None request.location = { 'latitude': response.location.latitude, 'longitude': response.location.longitude }
def ipaddr(self): """ Get the IP Address of the form submitter via the request. """ if not hasattr(self, '_ipaddr'): self._ipaddr = get_real_ip(self.request) or get_ip(self.request) return self._ipaddr
def _validate_signature(self, project, request): secret_key = request.GET.get("key", None) if secret_key is None: return False if not hasattr(project, "modules_config"): return False if project.modules_config.config is None: return False project_secret = project.modules_config.config.get("bitbucket", {}).get( "secret", "") if not project_secret: return False bitbucket_config = project.modules_config.config.get("bitbucket", {}) valid_origin_ips = bitbucket_config.get( "valid_origin_ips", settings.BITBUCKET_VALID_ORIGIN_IPS) origin_ip = get_real_ip(request) if valid_origin_ips and (not origin_ip or not origin_ip in valid_origin_ips): return False return project_secret == secret_key
def report(request): j = Job.objects.filter(secret_hash = request.GET.get('secret', None), ip_allocated = get_real_ip(request)).first() # If wrong secret hash or job allocated to someone else or reported already if not j or j.date_reported != None: print ("Report rejected:", request.GET.get('secret', None)) return HttpResponse('') j.date_reported = datetime.today() j.cpu_time = float(request.GET.get('cpu', 0.0)) j.results = request.GET.get('res', '') j.save() # Parse the result and create result key value pair objects for r in [x for x in request.GET.get('res', u'').split(u' ') if x != u'']: x = r.split(u':') kvr = KeyValueResult(job = j, key = x[0], value = x[1]) kvr.save() return HttpResponse('')
def allocate(request): # Always work on the latest config c = Config.objects.order_by('-date_activated').first() if c == None: return HttpResponse("0 0 0 0 0 0 0") # Get job who is allocation candidate # TODO: Prevent reallocating older than X hours, can use in code as the result of query in oldest anyway j = Job.objects.filter(date_reported = None, config = c).order_by('date_allocated').first() if not j: return HttpResponse("0 0 0 0 0 0 0") # Jobs are allowed to be reallocated only after a configured amount of time without response if j.date_allocated != None: d1_ts = time.mktime(j.date_allocated.timetuple()) d2_ts = time.mktime(datetime.today().timetuple()) if int(d2_ts-d1_ts) / 60 < j.config.minutes_before_realloc: return HttpResponse("0 0 0 0 0 0 0") # Actual allocation j.secret_hash = gen_random_word(j.config.secret_hash_length) j.ip_allocated = get_real_ip(request) j.date_allocated = datetime.today() j.save() # Write response return HttpResponse("%s %s %s %d %d %d %d" % (j.config.client_version, j.secret_hash, j.config.algo_id, j.config.n, j.config.n0, j.low_id, j.high_id))
def guardadatosmovil(request): if request.method == 'POST': id=request.user.id modelo_celular = json.loads(request.body)['model'] version_celular = json.loads(request.body)['tipo'] uuid = json.loads(request.body)['uuid'] print 'Guardando...',modelo_celular,version_celular if Usuarios.objects.filter(uuid=uuid): so = Usuarios.objects.get(uuid=uuid) so.modelo_celular = modelo_celular so.version_celular = version_celular so.ip= get_real_ip(request) so.fecha=datetime.datetime.today() so.save() c= simplejson.dumps({'u':'ok'}) return HttpResponse(c, content_type="application/json")
def github_logout(request): """Handle Github logout.""" access_token = request.session.pop('access_token', '') handle = request.session.pop('handle', '') redirect_uri = request.GET.get('redirect_uri', '/') geolocation_data = {} ip_address = '24.210.224.38' if settings.DEBUG else get_real_ip(request) if ip_address: geolocation_data = get_location_from_ip(ip_address) if access_token: revoke_token(access_token) request.session.pop('access_token_last_validated') try: # If the profile exists, clear the github access token. profile = Profile.objects.get(handle=handle) profile.github_access_token = '' profile.save() # record a useraction for this UserAction.objects.create(profile=profile, action='Logout', metadata={}, ip_address=ip_address, location_data=geolocation_data) except Profile.DoesNotExist: pass request.session.modified = True response = redirect(redirect_uri) response.set_cookie('last_github_auth_mutation', int(time.time())) return response
def create(self, request, feedtype, feedname=None): try: if feedname is None: raise Exception("Feedname is missing") ipaddr = get_real_ip(request) if ipaddr is None: ipaddr = get_ip(request) if ipaddr is None: raise Exception( "There had been a problem retrieving the IP address for the user." ) usr = FeedUser.objects.get( username=feedname) # If fails, raise an Exception return super(SubManager, self).create(user=usr, ipaddress=ipaddr, feedtype=feedtype, visit_hour=datetime.datetime.now().hour) except Exception as e: #return {'status': False, 'error': str(e)} return None
def contact(request): if request.method == 'POST': # If the form has been submitted... contact_request_form = ContactRequestForm( request.POST) # A form bound to the POST data if contact_request_form.is_valid(): # All validation rules pass contact_request = contact_request_form.save(commit=False) contact_request.url = request.POST.get('current_path', '') contact_request.ip_address = ip.get_real_ip( request) if not settings.DEBUG else ip.get_ip( request) # Inspired by http://stackoverflow.com/a/16203978 contact_request.save() process_contact_requests(contact_request.pk) messages.success( request, 'Thanks for your message. You\'ll hear from us soon!') return redirect(contact_request.url or 'home') # Redirect after POST else: contact_request_form = ContactRequestForm( initial={ 'current_path': request.GET.get('current_path', request.build_absolute_uri()) }) # An unbound form template_name = 'contact_request/contact_modal_form.html' if request.is_ajax( ) else 'contact_request/contact_page.html' return render(request, template_name, { 'contact_request_form': contact_request_form, 'noindex': True, })
def store_request(self): if not settings.APPLICATION_MONITORING: return if not settings.APPLICATION_MONITOR_STUFF_USERS and self.request.user.is_staff: return user_request = models.Request() user_request.server_name = self.request.META.get('SERVER_NAME', '') user_request.server_host = self.request.META.get('HTTP_HOST', '') user_request.user_username = self.request.user.username user_request.user_is_staff = self.request.user.is_staff user_request.user_is_active = self.request.user.is_active user_request.client_name = self.request.META.get('USER', '') user_request.client_agent = self.request.META.get('HTTP_USER_AGENT', '') user_request.client_ip = self.request.META.get('REMOTE_ADDR', '') real_ip = get_real_ip(self.request) if real_ip is None: real_ip = get_ip(self.request) user_request.client_real_ip = real_ip user_request.scheme = self.request.scheme user_request.method = self.request.method user_request.data = self.request.REQUEST user_request.is_ajax = self.request.is_ajax() user_request.from_page = self.request.META.get('HTTP_REFERER', '') user_request.to_page = self.request.path user_request.to_page_query = self.request.META.get('QUERY_STRING', '') user_request.save() return user_request
def contact(request): if request.method == 'POST': form = ContactForm(request.POST) # Если форма заполнена корректно, сохраняем все введённые пользователем значения if form.is_valid(): subject = form.cleaned_data['subject'] sender = form.cleaned_data['sender'] message = form.cleaned_data['message'] message_to_user = message client_address = get_real_ip(request) message += '\n\n' + u'email отправителя: ' + sender + '\n' + u'ip отправителя: ' + client_address copy = form.cleaned_data['copy'] recipient = ['*****@*****.**'] u_recipient = [] # Если пользователь захотел получить копию себе, добавляем его в список получателей if copy: u_recipient.append(sender) try: send_mail(subject, message, '*****@*****.**', recipient) send_mail(subject, message_to_user, '*****@*****.**', u_recipient) except BadHeaderError: # Защита от уязвимости return HttpResponse('Invalid header found') # Переходим на другую страницу, если сообщение отправлено return HttpResponse(u"Ваше письмо отправлено!") else: # Заполняем форму form = ContactForm() # Отправляем форму на страницу return render(request, 'foto/contact.html', {'form': form})
def pvs_report_v1(request): '''HTTP POST method for pvs to report it information for pvcloud and pvcloud echo the pvs_info for pvs''' pvs_ip = get_real_ip(request) if pvs_ip == None: logger.warning('can not get pvs ip address!') else: logger.info('pvs report event from ip: %s' % pvs_ip) pvs_encrypt_data = request.POST.get('data', None) pvs_data = {} if pvs_encrypt_data == None: logger.warning('no pvs encrypt data exist!') else: pvs_data = signing.loads(pvs_encrypt_data, PVS_SECRET_KEY) logger.debug('pvs report data with keys: %s' % str(pvs_data.keys())) pvs_info = {} pvs_info['ip'] = pvs_ip pvs_info['data'] = pvs_data pvs_report_data_update(pvs_info) response = HttpResponse(content_type='text/plain') response.content = json.dumps(pvs_info, indent=2) return response
def view_page(request, char_id): con = get_redis_connection("persistent") page = cache.get("page:%s" % char_id) if page is None: try: page = Page.objects.get(char_id=char_id) cache.set("page:%s" % char_id, page, 600) except ObjectDoesNotExist: return render(request, "view_page/does_not_exist.html") elif not page: return render(request, "view_page/does_not_exist.html") page.dialoglog = json.loads(page.dialoglog) image_path = "../static/img/hs2/%s.gif" % page.image # Has the user voted ip = get_real_ip(request) voted = True if con.get("voted:%s:%s" % (ip, char_id)) else False return render( request, "view_page/view_page.html", {"page": page, "image_path": image_path, "voted": voted})
def cache_key(request): ip = get_real_ip(request) if ip is None: ip = get_ip(request) if ip is None: ip = "" return "failed_attempt_{}".format(ip)
def serve(self, request): context = super(BlogPage, self).get_context(request) if request.method == 'POST': form = CommentForm(request.POST) if form.is_valid(): comment = form.save(commit=False) if not comment.name: comment.name = "anonymous" comment.page_id = self.id comment.approved = False comment.post_as_administrator = False comment.ip_address = get_real_ip(request) comment.save() return redirect(self.url) else: form = CommentForm() context['page'] = self context['form'] = form context['comments'] = self.comments context['comment_count'] = self.comment_count return render(request, self.template, context)
def test_missing_x_forwarded_missing_real_ip_mix_case(self): request = HttpRequest() request.META = { 'REMOTE_ADDR': '74DC::02BA', } ip = get_real_ip(request) self.assertEqual(ip, "74dc::02ba")
def ip(self, request): """ Retrieve ip from request """ ip = get_real_ip(request) or 'undefined' debug_logger.debug("IP request from : " + ip) return Response({'ip': ip})
def process_request(self, request): """ Inspects requests, get all the relavant data from different part of our data warehouse. Args: request (obj): django default request object Returns: doc (dict): dictionary object """ ip = get_real_ip(request) or settings.CENSUS_MOCK_IP ip2geo = self.get_ip_traits(ip) doc = dict() doc['ip2geo'] = ip2geo doc['ip'] = ip doc = self.parse_request_meta(request, doc) if ip2geo: country = ip2geo['country']['iso_code'] city = ip2geo['city']['names']['en'] postcode = ip2geo['postal']['code'] location = ip2geo['location'] else: country = city = postcode = None doc['census'] = self.get_census_data(country, postcode, city, location, ip) return doc
def get(self, request, *args, **kwargs): """ A base view for displaying a single object """ alias = self.kwargs.get('slug').replace(' ', '') try: self.object = self.queryset.get(alias=alias) except Post.DoesNotExist: referer = request.META.get("HTTP_REFERER") logger.error(u'ref[%s]访问不存在的文章:[%s]', referer, alias) context = super(PostDetailView, self).get_context_data(**kwargs) return render(request, '404.html', context) ip = get_real_ip(request) if ip is None: ip = get_ip(request) visited_ips = cache.get(self.object.id, []) if ip not in visited_ips: Post.objects.filter(id=self.object.id).update( view_times=F('view_times') + 1) visited_ips.append(ip) # set timeout a hour cache.set(self.object.id, visited_ips, 24 * 60) context = self.get_context_data(object=self.object) return self.render_to_response(context)
def determine_session(self): if not self.request.session.exists(self.request.session.session_key): self.request.session.create() self.request.session.model.objects.filter( session_key=self.request.session.session_key).update( session_data={'ip_address': get_real_ip(self.request)}) return self.request.session
def do_track_page_view(self, headers, reqtime=None, title=None, userid=None, session_key=None, status_code=None, fail_silently=PIWIK_FAIL_SILENTLY): """ Actually record the page view with Piwik: do the actual work with kwargs from self.get_track_kwargs """ request = FakeRequest(headers) pt = PiwikTracker(PIWIK_SITEID, request) pt.set_api_url(PIWIK_URL) pt.set_token_auth(PIWIK_TOKEN) pt.set_ip(get_real_ip(request)) if session_key: visitor_id = hashlib.sha512(session_key).hexdigest()[0:PiwikTracker.LENGTH_VISITOR_ID] pt.set_visitor_id(visitor_id) if reqtime: dt = datetime.datetime.fromtimestamp(reqtime, pytz.utc) pt.set_force_visit_date_time(dt) if userid: pt.set_custom_variable(1, 'userid', userid, scope='visit') if status_code: pt.set_custom_variable(2, 'status_code', status_code, scope='page') if PIWIK_FORCE_HOST: pt._set_host(PIWIK_FORCE_HOST) try: pt.do_track_page_view(title) except urllib_errors: if not fail_silently: raise
def test_missing_x_forwarded_missing_real_ip(self): request = HttpRequest() request.META = { 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request) self.assertEqual(ip, "177.139.233.133")
def process_request(self, request): session_key = request.COOKIES.get(settings.SESSION_COOKIE_NAME) request.session = self.SessionStore(ip=get_real_ip(request) or get_ip(request), user_agent=request.META.get( 'HTTP_USER_AGENT', ''), session_key=session_key)
def vote(request, char_id): """ Vote a page up """ con = get_redis_connection("persistent") page = cache.get("page:%s" % char_id) if page is None: try: page = Page.objects.get(char_id=char_id) cache.set("page:%s" % char_id, page) except ObjectDoesNotExist: return render(request, "view_page/does_not_exist.html") elif not page: return render(request, "view_page/does_not_exist.html") # Has the user already voted ip = get_real_ip(request) if con.get("voted:%s:%s" % (ip, char_id)): # Visitor has already voted, just redirect him/her return redirect("view_page", char_id=char_id) else: page.score += 1 page.saved = True page.save() con.setex("voted:%s:%s" % (ip, char_id), 86400, True) cache.set("page:%s" % char_id, page, 600) return redirect("view_page", char_id=char_id)
def view_page(request, char_id): con = get_redis_connection("persistent") page = cache.get("page:%s" % char_id) if page is None: try: page = Page.objects.get(char_id=char_id) cache.set("page:%s" % char_id, page, 600) except ObjectDoesNotExist: return render(request, "view_page/does_not_exist.html") elif not page: return render(request, "view_page/does_not_exist.html") page.dialoglog = json.loads(page.dialoglog) image_path = "../static/img/hs2/%s.gif" % page.image # Has the user voted ip = get_real_ip(request) voted = True if con.get("voted:%s:%s" % (ip, char_id)) else False return render(request, "view_page/view_page.html", { "page": page, "image_path": image_path, "voted": voted })
def get_weather(request): """Return weather of location from IP address. https://pypi.python.org/pypi/django-ipware https://pypi.python.org/pypi/pygeoip https://pypi.python.org/pypi/python-forecastio """ ip = get_real_ip(request) if ip is not None: gi = GeoIP(settings.GEOIP_DATABASE, MEMORY_CACHE) record = gi.record_by_addr(ip) if record is not None: try: latitude = record['latitude'] longitude = record['longitude'] except KeyError: return None try: forecast = forecastio.load_forecast(settings.DARKSKY_API_KEY, latitude, longitude) currently = forecast.currently() except Exception: return None return { 'icon': weather_icons.get(currently.icon, None), 'summary': currently.summary.lower(), 'temperature': int(currently.temperature), 'city': record.get('city', None), 'country': record.get('country_name', None), } else: return None else: return None
def handle_location_request(request): """Handle determining location data from request IP.""" ip_address = '24.210.224.38' if settings.DEBUG else get_real_ip(request) geolocation_data = {} if ip_address: geolocation_data = get_location_from_ip(ip_address) return geolocation_data, ip_address
def test_x_forwarded_for_multiple_right_most_ip_private(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': '192.168.255.182, 198.84.193.157, 10.0.0.0, 127.0.0.1, 177.139.233.139', 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request, right_most_proxy=True) self.assertEqual(ip, "177.139.233.139")
def test_private_x_forward_for_ip_addr(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': '127.0.0.1', 'REMOTE_ADDR': '', } ip = get_real_ip(request) self.assertEqual(ip, None)
def test_x_forwarded_for_singleton_hyphen_as_delimiter(self): request = HttpRequest() request.META = { 'X-FORWARDED-FOR': '177.139.233.139', 'REMOTE-ADDR': '177.139.233.133', } ip = get_real_ip(request) self.assertEqual(ip, "177.139.233.139")
def test_empty_x_forwarded_for_private_x_real_ip_fallback_on_remote_addr(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': '', 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request) self.assertEqual(ip, "177.139.233.133")
def test_bad_x_forwarded_for_fallback_on_x_real_ip(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': 'unknown 177.139.233.139', 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request) self.assertEqual(ip, "177.139.233.133")
def test_x_forwarded_for_singleton_private_address(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': '192.168.255.182', 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request) self.assertEqual(ip, "177.139.233.133")
def test_x_forwarded_for_singleton(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': '177.139.233.139', 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request) self.assertEqual(ip, "177.139.233.139")
def test_x_forwarded_for_multiple_bad_address(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': 'unknown, 192.168.255.182, 10.0.0.0, 127.0.0.1, 198.84.193.157, 177.139.233.139', 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request) self.assertEqual(ip, "198.84.193.157")