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)
