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_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 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 test_private_remote_address(self):
request = HttpRequest()
request.META = {
'REMOTE_ADDR': 'fe80::02ba',
}
ip = get_real_ip(request)
self.assertEqual(ip, None)
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 __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):
"""
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 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 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 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 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 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 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 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")
