def test_meta_singleton_proxy_count(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '177.139.233.139', } result = get_client_ip(request, proxy_count=1) self.assertEqual(result, (None, False))
def test_meta_error_only(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': 'unknown, 3ffe:1900:4545:3:200:f8ff:fe21:67cf, 74dc::02ba, 74dc::02bb', } result = get_client_ip(request) self.assertEqual(result, (None, False))
def test_meta_singleton(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '177.139.233.139', } result = get_client_ip(request) self.assertEqual(result, ("177.139.233.139", True))
def test_meta_proxy_trusted_ips_proxy_count_more_error(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '177.139.233.139, 198.84.193.157, 198.84.193.158', } result = get_client_ip(request, proxy_count=1, proxy_trusted_ips=['198.84.193.158']) self.assertEqual(result, (None, False))
def test_meta_proxy_trusted_ips(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '177.139.233.139, 198.84.193.157, 198.84.193.158', } result = get_client_ip(request, proxy_trusted_ips=['198.84.193.158']) self.assertEqual(result, ("177.139.233.139", True))
def test_100_block_private(self): request = HttpRequest() request.META = { 'HTTP_X_REAL_IP': '100.76.0.9', } ip = get_client_ip(request) self.assertEqual(ip, ("100.76.0.9", False))
def test_ipv6_encapsulation_of_ipv4_private(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '::ffff:127.0.0.1', } result = get_client_ip(request) self.assertEqual(result, ('127.0.0.1', False))
def test_meta_proxy_order_right_most(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf, 74dc::02ba, 74dc::02bb', } result = get_client_ip(request, proxy_order='right-most') self.assertEqual(result, ("74dc::02bb", True))
def test_100_high_range_public(self): request = HttpRequest() request.META = { 'HTTP_X_REAL_IP': '100.128.0.9', } ip = get_client_ip(request) self.assertEqual(ip, ("100.128.0.9", True))
def test_meta_singleton(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf', } result = get_client_ip(request) self.assertEqual(result, ("3ffe:1900:4545:3:200:f8ff:fe21:67cf", True))
def test_ipv6_encapsulation_of_ipv4_public(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '::ffff:177.139.233.139', } result = get_client_ip(request) self.assertEqual(result, ('177.139.233.139', True))
def save(self): request = self.context['request'] request_user = None if request.user and request.user.is_authenticated: request_user = request.user creds = APICredentials.get_credentials(request_user) request = PreQualificationRequest() request.customer_initiated = self.validated_data.get('customer_initiated', False) request.email = self.validated_data.get('email') request.first_name = self.validated_data['first_name'] request.middle_initial = self.validated_data.get('middle_initial') request.last_name = self.validated_data['last_name'] request.line1 = self.validated_data['line1'] request.line2 = self.validated_data.get('line2') request.city = self.validated_data['city'] request.state = self.validated_data['state'] request.postcode = self.validated_data['postcode'] request.credentials = creds request.ip_address, _ = get_client_ip(self.context['request']) request.save() if self.validated_data['response_id']: response = PreQualificationResponse() response.request = request response.status = self.validated_data['status'] response.message = '' response.offer_indicator = '' response.credit_limit = self.validated_data['credit_limit'] response.response_id = self.validated_data['response_id'] response.application_url = '' response.customer_response = PREQUAL_CUSTOMER_RESP_NONE response.save() return request
def test_meta_error_only(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': 'unknown, 177.139.233.139, 198.84.193.157, 198.84.193.158', } result = get_client_ip(request) self.assertEqual(result, (None, False))
def test_meta_proxy_trusted_ips_proxy_count_more_error(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf, 74dc::02ba, 74dc::02bb', } result = get_client_ip(request, proxy_count=1, proxy_trusted_ips=['74dc::02bb']) self.assertEqual(result, (None, False))
def save(self): request = self.context['request'] request_user = None if request.user and request.user.is_authenticated: request_user = request.user # Build application class and save record to DB to record the attempt Application = self.Meta.model app = Application(**self.validated_data) # Store the ip address of user sending the request app.ip_address, _ = get_client_ip(request) app.user = request_user app.submitting_user = request_user app.save() # Submit application to to Wells try: result = actions.submit_credit_application(app, current_user=request_user) except core_exceptions.CreditApplicationPending as e: pending = api_exceptions.CreditApplicationPending() pending.inquiry = e.inquiry raise pending except core_exceptions.CreditApplicationDenied: raise api_exceptions.CreditApplicationDenied() except DjangoValidationError as e: raise DRFValidationError({ 'non_field_errors': [e.message] }) return result
def test_meta_proxy_order_right_most(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '177.139.233.139, 198.84.193.157, 198.84.193.158', } result = get_client_ip(request, proxy_order='right-most') self.assertEqual(result, ("198.84.193.158", True))
def test_meta_singleton_private_fallback(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '10.0.0.0', 'HTTP_X_REAL_IP': '177.139.233.139', } result = get_client_ip(request) self.assertEqual(result, ("177.139.233.139", True))
def test_meta_error_first(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': 'unknown, 3ffe:1900:4545:3:200:f8ff:fe21:67cf, 74dc::02ba, 74dc::02bb', 'X_FORWARDED_FOR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf, 74dc::02ba, 74dc::02bb', } result = get_client_ip(request) self.assertEqual(result, ("3ffe:1900:4545:3:200:f8ff:fe21:67cf", True))
def test_meta_multi(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '177.139.233.139, 198.84.193.157, 198.84.193.158', 'REMOTE_ADDR': '177.139.233.133', } result = get_client_ip(request) self.assertEqual(result, ("177.139.233.139", True))
def test_best_matched_ip_private_precedence(self): request = HttpRequest() request.META = { 'HTTP_X_REAL_IP': '127.0.0.1', 'REMOTE_ADDR': '192.168.1.1', } ip = get_client_ip(request) self.assertEqual(ip, ("192.168.1.1", False))
def test_meta_error_first(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': 'unknown, 177.139.233.139, 198.84.193.157, 198.84.193.158', 'X_FORWARDED_FOR': '177.139.233.138, 198.84.193.157, 198.84.193.158', } result = get_client_ip(request) self.assertEqual(result, ("177.139.233.138", True))
def test_meta_multi(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf, 74dc::02ba, 74dc::02bb', 'REMOTE_ADDR': '74dc::02bc', } result = get_client_ip(request) self.assertEqual(result, ("3ffe:1900:4545:3:200:f8ff:fe21:67cf", True))
def test_meta_singleton_proxy_count_private(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '::1', 'HTTP_X_REAL_IP': '3ffe:1900:4545:3:200:f8ff:fe21:67cf', } result = get_client_ip(request, proxy_count=1) self.assertEqual(result, (None, False))
def test_best_matched_ip_public(self): request = HttpRequest() request.META = { 'HTTP_X_REAL_IP': '177.31.233.122', 'REMOTE_ADDR': '177.31.233.133', } ip = get_client_ip(request) self.assertEqual(ip, ("177.31.233.122", True))
def test_meta_multi_precedence_invalid_first(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': 'unknown, 10.0.0.1, 10.0.0.2', 'X_FORWARDED_FOR': '177.139.233.138, 198.84.193.157, 198.84.193.158', 'REMOTE_ADDR': '177.139.233.133', } result = get_client_ip(request) self.assertEqual(result, ("177.139.233.138", True))
def test_request_header_order_specific(self): request = HttpRequest() request.META = { 'HTTP_X_REAL_IP': '192.168.1.1', 'REMOTE_ADDR': '177.139.233.139', 'HTTP_X_FORWARDED_FOR': '177.139.233.139, 198.84.193.157, 198.84.193.158', } ip = get_client_ip(request, request_header_order=['HTTP_X_FORWARDED_FOR']) self.assertEqual(ip, ("177.139.233.139", True))
def test_request_header_order_multiple(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '177.139.233.139, 198.84.193.157, 198.84.193.158', 'X_FORWARDED_FOR': '177.139.233.138, 198.84.193.157, 198.84.193.158', 'REMOTE_ADDR': '177.139.233.133', } ip = get_client_ip(request, request_header_order=['X_FORWARDED_FOR', 'HTTP_X_FORWARDED_FOR']) self.assertEqual(ip, ("177.139.233.138", True))
def test_meta_multi_precedence_invalid_first(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': 'unknown, 2001:db8:, ::1', 'X_FORWARDED_FOR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf, 74dc::02ba, 74dc::02bb', 'REMOTE_ADDR': '74dc::02bc', } result = get_client_ip(request) self.assertEqual(result, ("3ffe:1900:4545:3:200:f8ff:fe21:67cf", True))
def create_from_request(self, request, service, **kwargs): kwargs.setdefault('user', request.user) if 'ip_address' not in kwargs: kwargs['ip_address'] = get_client_ip(request)[0] if 'geo_location' not in kwargs: try: kwargs['geo_location'] = get_geo_location_data_for_ip(kwargs['ip_address']) except Exception as e: # catch all exceptions here because we don't want any geo location related error # to make the whole login entry creation fail. logger.exception('Error getting geo location data for an IP: {}'.format(e)) return self.create(service=service, **kwargs)
def post(self, request, format=None): """ Create """ client_ip, is_routable = get_client_ip(self.request) serializer = InvoiceListCreateSerializer(data=request.data, context={ 'created_by': request.user, 'created_from': client_ip, 'created_from_is_public': is_routable, 'franchise': request.tenant }) serializer.is_valid(raise_exception=True) serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED)
def request(self, tpq, reduced_mapping, fragment, request, extended): tpf_url = urlparse(request.build_absolute_uri()) tpf_url = TPF_URL % (tpf_url.scheme, tpf_url.netloc, 'extended/') if extended else TPF_URL % (tpf_url.scheme, tpf_url.netloc, '') validiteToken = linkedin_verification_ip_token_date(request) result_set = None last_result = True total_nb_triples = len(reduced_mapping.mapping) if validiteToken: client_ip, is_routable = ipware.get_client_ip(request) json_data = open(USERS_FILE_PATH, 'r') users = json.load(json_data) ACCESS_TOKEN = users[client_ip]['token'] application = linkedin.LinkedInApplication(token=ACCESS_TOKEN) result_set = application.get_profile(selectors=['id', 'first-name', 'last-name', 'location', 'positions', 'num-connections', 'picture-url', 'educations', 'public-profile-url']) else: raise ValueError("Not authentified, go to: linkedin/authentification/") self._frament_fill_meta(tpq, fragment, last_result, total_nb_triples, total_nb_triples, request, tpf_url) return result_set
def post(self, request, format=None): client_ip, is_routable = get_client_ip(request) # must guard against possible None or blank value as client_ip if not client_ip: raise ImproperlyConfigured("cannot determine client_ip") device_info: DeviceInfo = DeviceInfo.from_dict(request.data) update_presence_for_device( client_ip=client_ip, device_id=device_info.device_id, device_info=device_info, ) messages = pull_messages_for_device(client_ip=client_ip, device_id=device_info.device_id) return Response({'messages': [m.asdict() for m in messages]})
def save(self): request = self.context['request'] # Save IPAdress of the user user_ipaddress, _ = get_client_ip(request) self.validated_data['ip_address'] = user_ipaddress prequal_request = super().save() request_user = None if request.user and request.user.is_authenticated: request_user = request.user return_url = reverse('wfrs-api-prequal-app-complete', request=request) try: actions.check_pre_qualification_status(prequal_request, return_url=return_url, current_user=request_user) except DjangoValidationError as e: raise DRFValidationError({ 'non_field_errors': [e.message] }) return prequal_request
def subscribe_to_newsletter(self, request, user, opt_in): client = MailChimp(mc_api=settings.MAILCHIMP_API_KEY, mc_user=settings.MAILCHIMP_USERNAME) user_ip, is_routable = get_client_ip(request) if opt_in: status = 'subscribed' else: status = 'unsubscribed' return client.lists.members.create( settings.MAILCHIMP_NEWSLETTER_ID, { 'email_address': user.email, 'status': status, 'merge_fields': { 'FNAME': user.first_name, 'LNAME': user.last_name, }, 'ip_signup': user_ip, })
def maybe_increase_download_counter(self, request): client_ip, is_routable = get_client_ip(request) if client_ip is None: return download_event, created = PackageVersionDownloadEvent.objects.get_or_create( version=self, source_ip=client_ip, ) if created: valid = True else: valid = download_event.count_downloads_and_return_validity() if valid: self.downloads += 1 self.save(update_fields=("downloads", ))
def get_redirect_url(self, *args, **kwargs): link: Link = get_object_or_404(Link, pk=kwargs["uuid"]) with transaction.atomic(): if link.visited_count <= settings.MAX_VISITED_COUNT: real_ip, is_routable = get_client_ip(self.request) response = requests.get( f"https://ipinfo.io/{real_ip}?token={settings.IPINFO_TOKEN}" ) Visit.objects.create(link=link, visitor_data=response.json(), real_ip=real_ip) Link.objects.filter(uuid=kwargs["uuid"]).update( visited_count=F("visited_count") + 1) return link.original_link
def volunteer(request): if request.method == 'POST': form = VolunteerForm(request.POST, request.FILES) if form.is_valid(): doctor = form.save(commit=False) doctor.ip_address = get_client_ip(request)[0] doctor.user_agent = request.META.get('HTTP_USER_AGENT') doctor.site = get_current_site(request) doctor.save() form.save_m2m() response = redirect('consultation') response.set_cookie('doctor_id', doctor.uuid, max_age=SIX_MONTHS) return response else: form = VolunteerForm() form.fields['self_certification_questions'].queryset = SelfCertificationQuestion.objects.filter(language=request.LANGUAGE_CODE) return render(request, 'clinic/volunteer_form.html', {'form': form})
def is_recaptcha_valid(request, field_name='recaptcha'): """ Verify if the response for the Google recaptcha is valid. """ if hasattr(request, 'data'): data = request.data else: data = request.POST return requests.post( 'https://www.google.com/recaptcha/api/siteverify', data={ 'secret': settings.GOOGLE['recaptcha']['secret'], 'response': data.get(field_name), 'remoteip': get_client_ip(request) }, verify=True ).json().get("success", False)
def ingress(request, service_uuid, identifier, tracker, payload): time = timezone.now() client_ip, is_routable = get_client_ip(request) location = request.META.get("HTTP_REFERER", "").strip() user_agent = request.META.get("HTTP_USER_AGENT", "").strip() dnt = request.META.get("HTTP_DNT", "0").strip() == "1" ingress_request.delay( service_uuid, tracker, time, payload, client_ip, location, user_agent, dnt=dnt, identifier=identifier, )
def post_draft(request): ip = get_client_ip(request)[0] form = SearchForm() slider = Slider.objects.filter(show=True) posts = Post.objects.exclude( published_date__lte=timezone.now()).order_by('-created_date') posts = posts.filter(author=request.user) genres = Category.objects.all() search_amount = Post.objects.published().count() context = { 'posts': posts, 'ip': ip, 'form': form, 'search_amount': search_amount, 'genres': genres, 'slider': slider, } return render(request, 'blogapp/post_list.html', context)
def index_view(request, url): now = timezone.now() if request.method == "POST": params = request.POST else: params = request.GET ip, is_routable = get_client_ip(request) username = params.get("username") password = params.get("password") parameters = repr(params)[12:-1] if len(parameters) < 3: parameters = "" if parameters: HoneypotLog.objects.create( date=now.date(), time=now.time(), source_ip=ip, url=url, username=username or "", password=password or "", params=parameters, ) if url.lower().endswith(".jpg") or url.lower().endswith(".jpeg"): return HttpResponse(get_bob("jpg"), content_type="image/jpeg") if url.lower().endswith(".png"): return HttpResponse(get_bob("png"), content_type="image/png") ctx = { "url": url, #"file": file, "username": username or "", } if username or password: ctx["error"] = "Wrong password or user unknown" return render(request, "honeypot/honeypot.html", ctx)
def disclaimer(request): patient_id = request.COOKIES.get('patient_id') if patient_id: return redirect('consultation') site = get_current_site(request) if request.method == 'POST': lang = Language.objects.get(ietf_tag=request.LANGUAGE_CODE) video = request.POST.get('video') == '1' patient = Patient(ip_address=get_client_ip(request)[0], language=lang, enable_video=video) patient.site = site patient.save() response = redirect('consultation') response.set_cookie('patient_id', patient.uuid, max_age=ONE_MONTH) return response else: obj = Disclaimer.objects.filter(site=site).first() return render(request, 'clinic/disclaimer.html', {'disclaimer': obj})
def get_form_kwargs(self): # Pass 'self.request' object to PostForm instance kwargs = super(MemberLoginView, self).get_form_kwargs() kwargs['recaptcha'] = False if member_settings.GOOGLE_RECAPTCHA_SESSION_KEY in self.request.session: kwargs['recaptcha'] = True try: ip_address = get_client_ip(self.request)[0] if ip_address not in ['127.0.0.1']: country = GeoIP2().country(ip_address) if country['country_code'] and country['country_code'].upper() not in settings.WHITE_COUNTRY_CODES: kwargs['recaptcha'] = True except AddressNotFoundError: pass return kwargs
def check_captcha(request): response = request.POST.get('g-recaptcha-response') if not response: return False secret = settings.G_CAPTCHA_SECRET remoteip, is_routable = get_client_ip(request) r = requests.post( settings.G_CAPTCHA_URL, data={ 'response': response, 'secret': secret, 'remoteip': remoteip } ).json() if r['success'] is True: return True return False
def __call__(self, request): from ipware import get_client_ip request_id = get_request_header( request, "x-request-id", "HTTP_X_REQUEST_ID" ) or str(uuid.uuid4()) correlation_id = get_request_header( request, "x-correlation-id", "HTTP_X_CORRELATION_ID" ) with structlog.threadlocal.tmp_bind(logger): logger.bind(request_id=request_id) self.bind_user_id(request), if correlation_id: logger.bind(correlation_id=correlation_id) ip, _ = get_client_ip(request) logger.bind(ip=ip) signals.bind_extra_request_metadata.send( sender=self.__class__, request=request, logger=logger ) logger.info( "request_started", request=request, user_agent=request.META.get("HTTP_USER_AGENT"), ) self._raised_exception = False response = self.get_response(request) if not self._raised_exception: self.bind_user_id(request), signals.bind_extra_request_finished_metadata.send( sender=self.__class__, request=request, logger=logger, response=response, ) logger.info( "request_finished", code=response.status_code, request=request ) return response
def put(self, request, pk=None): """ Update """ client_ip, is_routable = get_client_ip(self.request) order = get_object_or_404(WorkOrder, pk=pk) self.check_object_permissions(request, order) # Validate permissions. serializer = WorkOrderRetrieveUpdateDestroySerializer( order, data=request.data, context={ 'last_modified_by': request.user, 'last_modified_from': client_ip, 'last_modified_from_is_public': is_routable, 'franchise': request.tenant }) serializer.is_valid(raise_exception=True) serializer.save() return Response(serializer.data, status=status.HTTP_200_OK)
def ratelimit_key(group, request): req_article = getattr(request, 'req_article', None) if bool(req_article): client_ip = getattr(request, 'client_ip', None) is_routable = getattr(request, 'is_routable', None) else: # 获取访客端IP client_ip, is_routable = get_client_ip(request) # 获取请求参数中的博文ID req_article = getattr(request, request.method.upper(), request.POST).get('article', None) # 判断博文ID有效性 if not (bool(req_article) and req_article.isdigit()): req_article = None # 附加属性到request,让后续的视图函数中可以使用 setattr(request, 'req_article', req_article) setattr(request, 'client_ip', client_ip) setattr(request, 'is_routable', is_routable) return '{0}-{1}-{2}'.format(client_ip, group, req_article)
def get(self, request, format=None): from django.contrib.gis.geoip2 import GeoIP2 import os from backend.settings import BASE_DIR from ipware import get_client_ip g = GeoIP2(path=os.path.join(BASE_DIR, 'api', 'geoipdata')) ip, is_routable = get_client_ip(request) if ip is None: return Response({"country": "Unknown", "ip": None}) else: if is_routable: return Response({ "country": g.country(ip)['country_name'], "ip": ip }) else: return Response({"country": "Private", "ip": ip})
def post(self, request, format=None): ip, is_routeable = get_client_ip(request) if ip and is_routeable: server_data = request.data.dict() server_data['ip_address'] = ip serializer = GameServerSerializer(data=server_data) if serializer.is_valid(): serializer.save() return_data = serializer.data return_data['id'] = GameServer.objects.last().id return Response(return_data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) errordata = {'error': True, 'reason': 'Could not obtain IP address.'} if ip is None\ else {'error': True, 'reason': 'This IP address is not valid. It must be routeable.'}\ if not is_routeable else {'error': True, 'reason': 'Unkown reason.'} return Response(data=errordata, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def get_IP(self): """ get client's IP address :return: client ip """ from ipware import get_client_ip client_ip, is_routable = get_client_ip(self.request) if client_ip is None: # Unable to get the client's IP address return 'N/A' else: # We got the client's IP address if is_routable: # The client's IP address is publicly routable on the Internet pass else: # The client's IP address is private pass return client_ip
def store_search(request): # https://docs.djangoproject.com/en/2.2/ref/contrib/gis/geoip2/# # https://github.com/un33k/django-ipware # https://developers.google.com/maps/documentation/urls/guide # dev_ip = 'www.hamburg.de' # for use during development, Hamburg Germany dev_ip = '2a02:8108:4640:1214:b9e5:9090:525c:d282' # Get client ip address client_ip, is_routable = get_client_ip(request) if client_ip is None: found_ip = dev_ip else: # We got the client's IP address if is_routable: found_ip = client_ip else: #found_ip = 'Your IP is private' found_ip = dev_ip # Get location from IP address g = GeoIP2() city = g.city(found_ip) lat, lon = g.lat_lon(found_ip) # Have a bit of fun #lat, lon, city['city'], city['country_name'] = 51.5074, 0.1278, 'London', 'UK' #lat, lon, city['city'], city['country_name'] = 43.6532, -79.3832, 'Toronto', 'Canada' #lat, lon, city['city'], city['country_name'] = 48.8566, 2.3522, 'Paris', 'France' #lat, lon, city['city'], city['country_name'] = 53.3498, -6.2603, 'Dublin', 'Ireland' user_location = Point(lon, lat, srid=4326) # Filter stores by distance results = Store.objects.annotate( distance=Distance('location', user_location)) results = results.order_by('distance')[:100] context = {'city': city['city'], 'country': city['country_name'], 'store_list': results} return render(request, 'stores/search_results.html', context)
def __call__(self, request): response = self.get_response(request) if not request.user: username = "******" elif request.user.is_anonymous: username = "******" else: username = request.user.username ip, routable = get_client_ip(request) log_line = "{} - {} - [{}] \"{}\" \"{}\"".format( ip, username, datetime.now(), request.get_full_path(), request.META.get("HTTP_USER_AGENT", "")) logger.info(log_line) return response
def middleware(request): ip = get_client_ip(request) ip = ip[0] if not (request.path_info == '/profile/banned/' and not request.path_info == '/admin'): if ip is not None: if not request.user.is_anonymous: user = UserProfile.objects.get( user__username=request.user.username) user.ip = ip # change field user.save() # this will update only if not BannedUser.objects.filter(ip=ip).exists(): if BannedUser.objects.filter(user=request.user): return render(request, 'profiles/banned.html') if BannedUser.objects.filter(ip=ip).exists(): return render(request, 'profiles/banned.html') return get_response(request)
def get_user_coordinates(coords, request): if request: client_ip, is_routable = get_client_ip(request) if client_ip: if is_routable: geocode = geocoder.ip(client_ip) location = geocode.latlng lat, lng = location[0], location[1] else: lat, lng = None, None latitude, longitude, radius = ( coords[0] or lat, coords[1] or lng, coords[2] or 25, ) return latitude, longitude, radius
def post(self, request, format=None): """ Create """ client_ip, is_routable = get_client_ip(self.request) write_serializer = WorkOrderListCreateSerializer( data=request.data, context={ 'created_by': request.user, 'created_from': client_ip, 'created_from_is_public': is_routable, 'franchise': request.tenant }) write_serializer.is_valid(raise_exception=True) order_obj = write_serializer.save() read_serializer = WorkOrderRetrieveUpdateDestroySerializer(order_obj, many=False) return Response(data=read_serializer.data, status=status.HTTP_201_CREATED)
def post(self, request, format=None): """ Create """ # Get the users IP. client_ip, is_routable = get_client_ip(self.request) # Input the POST data into our serializer to create our image. serializer = PublicImageUploadListCreateSerializer( data=request.data, context={ 'created_by': request.user, 'created_from': client_ip, 'created_from_is_public': is_routable, 'franchise': request.tenant }) serializer.is_valid(raise_exception=True) serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED)
def withdraw(self, request): merchant = request.user.work_merchant client_ip, _ = get_client_ip(request._request) logger.info(f'merchant({merchant.id, merchant.name, client_ip} requested a withdraw: {request.data}') serializer = MerchantWithdrawSerializer(merchant.account, data=request.data, partial=True) serializer.is_valid(raise_exception=True) manager = AccountManager(merchant.account) if request.data['channel'] == PAY_CHANNELS.WECHAT: withdraw_error = manager.wechat_withdraw(serializer.validated_data['amount'], client_ip) else: withdraw_error = manager.alipay_withdraw(serializer.validated_data['amount']) logger.info(f'merchant({merchant.id, merchant.name, client_ip} withdraw error is {withdraw_error}') return Response(status=status.HTTP_200_OK, data=withdraw_error or {})
def get_egg(request): if 'tname' in request.POST and request.POST['tname']: name = request.POST['tname'] if Tamagochi.objects.filter(name__exact=name): return render( request, "authen/egg.html", {'errors': "Your tamagochi's name is taken by somebody else"}) else: ran = random.randint(1, 32) if ran % 2 == 0: gender = 'Female' else: gender = 'Male' ran = ran.__str__() filename = '/tamaEvolve/' + ran + '/1.png' log = LoginLogoutLog.objects.get(user=request.user) log.length = None log.login_time = timezone.now() log.save() # get ip and latlong ip, is_routable = get_client_ip(request) latlong = get( 'https://ipapi.co/{}/latlong/'.format(ip)).text.split(',') if latlong == ['Undefined', 'Undefined']: g = geocoder.ip('me') ip = g.ip latlong = get( 'https://ipapi.co/{}/latlong/'.format(ip)).text.split(',') new_tamagochi = Tamagochi(name=name, user=request.user, gender=gender, apperance=filename, apperanceNum=ran, online=True, latitude=latlong[0], longitude=latlong[1]) new_tamagochi.save() return redirect('map') else: return render(request, "authen/egg.html", {})
def __call__(self, request): # Code to be executed for each request before # the view (and later middleware) are called. if request.method == 'GET' \ and not request.path.startswith(settings.STATIC_URL) \ and not request.path.startswith(settings.MEDIA_URL): # Naver if all(k in request.GET for k in ( 'n_campaign_type', 'n_media', 'n_query', 'n_rank', 'n_ad_group', 'n_ad', 'n_keyword_id', 'n_keyword')): log = NaverAdvertisementLog() log.ip_address = get_client_ip(request)[0] log.user_agent = request.META['HTTP_USER_AGENT'] log.campaign_type = request.GET['n_campaign_type'] if request.GET['n_campaign_type'].isdigit() else 1 log.media = request.GET['n_media'] log.query = request.GET['n_query'] log.rank = request.GET['n_rank'] log.ad_group = request.GET['n_ad_group'] log.ad = request.GET['n_ad'] log.keyword_id = request.GET['n_keyword_id'] log.keyword = request.GET['n_keyword'] log.save() # Google response = self.get_response(request) # Code to be executed for each request/response after # the view is called. return response
def __call__(self, request): # If the requested url isn't in the admin panel if not reverse('admin:index') in request.path or reverse( 'admin:index' ) + 'login/' in request.path or request.path == reverse('admin:index'): requested_url = bleach.clean(request.path) # Create the GlobalPageHit page_hit, page_hit_created = GlobalPageHit.objects.get_or_create( page_url=requested_url) page_hit.hit_count = F('hit_count') + 1 page_hit.save() # Create the Visitor visitor_ip = get_client_ip(request) visitor, visitor_created = Visitor.objects.get_or_create( ip_address=visitor_ip[0]) # if the visitor already exists then we do nothing as it does more api requests for data that you already have if visitor_created: # if the ip is not localhost then do a lookup of the country for the ip if visitor_ip[0] not in ('localhost', '127.0.0.1'): handler = ipinfo.getHandler(settings.IPINFO_API_KEY) details = handler.getDetails(str(visitor_ip[0])) if details.country_name is not None: visitor.ip_country = details.country_name visitor.user_agent = request.META['HTTP_USER_AGENT'] visitor.save() # Create the VisitorPageHit visitor_page_hit, visitor_page_hit_created = VisitorPageHit.objects.get_or_create( page_url=requested_url, visitor=visitor) visitor_page_hit.hit_count = F('hit_count') + 1 if not request.META[ 'HTTP_USER_AGENT'] in visitor_page_hit.user_agent: visitor_page_hit.user_agent += '\n' + request.META[ 'HTTP_USER_AGENT'] visitor_page_hit.save() return self.get_response(request)