Esempio n. 1
0
 def count_by_country(self):
     geoip = GeoIP()
     count = Counter()
     for request in self.all():
         if request.ip is None or geoip.country_code(request.ip) is None:
             continue
         country = geoip.country(request.ip)
         count[country['country_code']] += 1
     return count
Esempio n. 2
0
    def test01_init(self):
        "GeoIP initialization."
        g1 = GeoIP2()  # Everything inferred from GeoIP path
        path = settings.GEOIP_PATH
        g2 = GeoIP2(path, 0)  # Passing in data path explicitly.
        g3 = GeoIP2.open(path, 0)  # MaxMind Python API syntax.

        for g in (g1, g2, g3):
            self.assertTrue(g._country)
            self.assertTrue(g._city)

        # Only passing in the location of one database.
        city = os.path.join(path, 'GeoLite2-City.mmdb')
        cntry = os.path.join(path, 'GeoLite2-Country.mmdb')
        g4 = GeoIP2(city, country='')
        self.assertIsNone(g4._country)
        g5 = GeoIP2(cntry, city='')
        self.assertIsNone(g5._city)

        # Improper parameters.
        bad_params = (23, 'foo', 15.23)
        for bad in bad_params:
            with self.assertRaises(GeoIP2Exception):
                GeoIP2(cache=bad)
            if isinstance(bad, str):
                e = GeoIP2Exception
            else:
                e = TypeError
            with self.assertRaises(e):
                GeoIP2(bad, 0)
Esempio n. 3
0
def map_home(request):
    x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
    if x_forwarded_for:
        ip = x_forwarded_for.split(',')[0]
    else:
        ip = request.META.get('REMOTE_ADDR')
    g = GeoIP2()
    (lat, lng) = g.lat_lon(ip)
    # lat = 19.0748
    # lng = 72.8856
    pnt = Point(lng, lat, srid=4326)
    inc_near = Incidences.objects.annotate(
        distance=Distance('location', pnt)).order_by('distance').first()
    # print(inc_near)
    # name = Incidences.objects.filter('name' == inc_near)
    string = str(inc_near.location)
    near_lat = ""
    near_lng = ""
    take1 = True
    go = False
    for i in string:
        if i == '(':
            go = True
            continue
        if i == ')':
            break
        if go:
            if i == " ":
                take1 = False
            elif take1:
                near_lng += i
            else:
                near_lat += i

    all_incidences = Incidences.objects.all()
    context = {
        'lng': lng,
        'lat': lat,
        'near_lat': near_lat,
        'near_lng': near_lng,
        'all_incidences': all_incidences,
    }

    return render(request, 'geo/index.html', context)
Esempio n. 4
0
def get_user_location(request):
    """
    This function captures the user's IP Address, User-Agent, Country and City
    """
    values = {}

    # Get IP Address of user
    try:
        x_forward = request.META.get("HTTP_X_FORWARDED_FOR")
        if x_forward:
            ip = x_forward.split(",")[0]
        else:
            ip = request.META.get("REMOTE_ADDR")
    except:
        ip = ""

    # Get User Agent of user
    try:
        user_agent = request.META.get("HTTP_USER_AGENT")
    except:
        user_agent = ""

    # Trace user location using Geoip API
    from django.contrib.gis.geoip2 import GeoIP2
    g = GeoIP2()

    # Get Country of user
    try:
        country = g.country_name(ip)
    except:
        country = ""

    # Get City of user
    try:
        city = g.city(ip)['city']
    except:
        city = ""

    values['ip'] = ip
    values['user_agent'] = user_agent
    values['country'] = country
    values['city'] = city

    return values
Esempio n. 5
0
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)
Esempio n. 6
0
 def __call__(self, request):
     if "HTTP_X_FORWARDED_FOR" in request.META:
         request.META["HTTP_X_PROXY_REMOTE_ADDR"] = request.META[
             "REMOTE_ADDR"]
         parts = request.META["HTTP_X_FORWARDED_FOR"].split(",", 1)
         request.META["REMOTE_ADDR"] = parts[0]
     ip = request.META["REMOTE_ADDR"]
     g = GeoIP2()
     try:
         ip_response = g.city(ip)
         time_zone = ip_response['time_zone']
     except AddressNotFoundError:
         time_zone = None
     if time_zone:
         timezone_object = pytz.timezone(time_zone)
         timezone.activate(timezone_object)
     else:
         timezone.deactivate()
     return self.get_response(request)
Esempio n. 7
0
    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})
Esempio n. 8
0
 def test_repr(self):
     path = settings.GEOIP_PATH
     g = GeoIP2(path=path)
     meta = g._reader.metadata()
     version = "%s.%s" % (
         meta.binary_format_major_version,
         meta.binary_format_minor_version,
     )
     country_path = g._country_file
     city_path = g._city_file
     expected = (
         '<GeoIP2 [v%(version)s] _country_file="%(country)s", _city_file="%(city)s">'
         % {
             "version": version,
             "country": country_path,
             "city": city_path,
         }
     )
     self.assertEqual(repr(g), expected)
Esempio n. 9
0
def fetch(request):
    geo_ip = GeoIP2()
    # client_ip = request.META.get('REMOTE_ADDR')
    client_ip = '77.47.236.2'
    try:
        city = City.objects.get(name=geo_ip.city(client_ip)['city'])
        if city.date_update.date() != timezone.now().date():
            city.delete()
            city = create_models(geo_ip, client_ip)
    except City.DoesNotExist:
        city = create_models(geo_ip, client_ip)
    except AddressNotFoundError:
        args = dict()
        args['error_message'] = 'Your address was not found'
        return render_to_response('openweathermap/index.htm', args)

    args = dict()
    args['city'] = city
    return render_to_response('openweathermap/index.htm', args)
Esempio n. 10
0
def paygol_ipn(request):
    ip = get_ip(request)
    g = GeoIP2()
    try:
        country = g.country(ip)
        if country["country_name"] == "Georgia":
            user_language = 'ka_GE'
            translation.activate(user_language)
            response = HttpResponse()
            response.set_cookie(settings.LANGUAGE_COOKIE_NAME, user_language)
        elif country["country_name"] == "Russia" or country[
                "country_name"] == "Ukraine" or country[
                    "country_name"] == "Belarus" or country[
                        "country_name"] == "Latvia" or country[
                            "country_name"] == "Lithuania" or country[
                                "country_name"] == "Moldova" or country[
                                    "country_name"] == "Estonia":
            user_language = 'ru'
            translation.activate(user_language)
            response = HttpResponse()
            response.set_cookie(settings.LANGUAGE_COOKIE_NAME, user_language)
    except:
        pass
    secret_key = "14846f31-426a-11e8-b407-128b57940774"
    if secret_key != request.GET.get('key'):
        return HttpResponseRedirect("/cabinet")
    transaction_id = request.GET.get('transaction_id')
    service_id = request.GET.get('service_id')
    shortcode = request.GET.get('shortcode')
    keyword = request.GET.get('keyword')
    message = request.GET.get('message')
    sender = request.GET.get('sender')
    operator = request.GET.get('operator')
    country = request.GET.get('country')
    custom = request.GET.get('custom')
    price = request.GET.get('frmprice')
    currency = request.GET.get('currency')

    balance = MyProfile.objects.get(user_id=custom)
    finalprice = Decimal(price)
    balance.account_balance += finalprice
    balance.save()
    return HttpResponseRedirect("/")
Esempio n. 11
0
def home_page(request):  ### popup that presents rules.
    g = GeoIP2()
    ip = get_client_ip(request)
    try:
        lat, lng = g.lat_lon(ip)
        city = g.city(ip)
        place = city['city'] + ', ' + city['country_name']
    except:
        lat, lng = -7.480207, 178.675933
        place = "Tuvalu"
        success = "We can't find your location so your photo will be posted to the Island Nation of Tuvalu"
    photos = Photo.objects.all().order_by('timestamp')[:60][::-1]
    for photo in photos:
        lon2 = photo.lon
        lat2 = photo.lat
        uuid = photo.uuid
        getPhotos = PhotoViewSet()
        photo.distance = getPhotos.haversine(lng, lat, lon2, lat2)
    return render(request, 'home.html', {'photos': photos, 'place': place})
Esempio n. 12
0
    def test03_country(self):
        "GeoIP country querying methods."
        g = GeoIP2(city='<foo>')

        for query in (self.fqdn, self.addr):
            self.assertEqual(
                'US',
                g.country_code(query),
                'Failed for func country_code and query %s' % query
            )
            self.assertEqual(
                'United States',
                g.country_name(query),
                'Failed for func country_name and query %s' % query
            )
            self.assertEqual(
                {'country_code': 'US', 'country_name': 'United States'},
                g.country(query)
            )
Esempio n. 13
0
def home(request):
    x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')

    if x_forwarded_for:
        ip = x_forwarded_for.split(',')[0]
    else:
        ip = request.META.get('REMOTE_ADDR')
    
    device_type = ""
    browser_type = ""
    browser_version = ""
    os_type = ""
    os_version = ""

    if request.user_agent.is_mobile:
        device_type = "Mobile"
    if request.user_agent.is_tablet:
        device_type = "Tablet"
    if request.user_agent.is_pc:
        device_type = "PC"
    
    browser_type = request.user_agent.browser.family
    browser_version = request.user_agent.browser.version_string
    os_type = request.user_agent.os.family
    os_version = request.user_agent.os.version_string
    
    g = GeoIP2()
    location = g.city(ip)
    location_country = location["country_name"]
    location_city = location["city"]

    context = {
        "ip": ip,
        "device_type": device_type,
        "browser_type": browser_type,
        "browser_version": browser_version,
        "os_type":os_type,
        "os_version":os_version,
        "location_country": location_country,
        "location_city": location_city
    }

    return render(request, "home.html", context)
Esempio n. 14
0
    def get(self, request):
        resp_dict = {
            'login_error': request.GET.get('login_error', 0),
            'page': 'single',
            'org_types': OrganizationType.objects.all()
                .prefetch_related("claimtype_set").order_by('name'),
            'test_alarm': False}

        claim_type_sets = {}
        for org_type in resp_dict['org_types']:
            claim_type_set = []
            for claim_type in org_type.claimtype_set.all():
                claim_type_set.append({'id': claim_type.id,
                                      'value': claim_type.name})
            claim_type_sets[org_type.type_id] = claim_type_set

        resp_dict['claim_types'] = mark_safe(json.dumps(claim_type_sets))

        if settings.RECAPTCHA_ENABLED is False:
            settings.RECAPTCHA_PUBLIC = ''
        resp_dict['recaptcha_public'] = settings.RECAPTCHA_PUBLIC

        if settings.TEST_SERVER:
            resp_dict['test_alarm'] = True

        ip = get_client_ip(request)
        # cached_zoom = cache.get('lat_lon_for::%s' % ip)

        # if cached_zoom is not None:
        #     resp_dict['zoom_to']=cached_zoom
        # else:
        g = GeoIP2()
        try:
            if g.country(ip)['country_code'] == settings.COUNTRY_CODE:
                resp_dict['zoom_to'] = list(g.lat_lon(ip))
            else:
                resp_dict['zoom_to'] = settings.DEFAULT_ZOOM
        except AddressNotFoundError:
            resp_dict['zoom_to'] = settings.DEFAULT_ZOOM

            # cache.set('lat_lon_for::%s' % ip, resp_dict['zoom_to'])

        return render(request, self.template_name, resp_dict)
Esempio n. 15
0
    def create_tenant(domain='', **extra_fields):
        extra_fields.setdefault('name', '')
        extra_fields.setdefault('country', '')
        extra_fields.setdefault('currency', '')

        if domain and not freemail.is_free(domain):
            # We can guess some field values based on the domain.
            tld = tldextract.extract(domain)
            geo_ip = GeoIP2()

            if not extra_fields['name']:
                # Use the domain of the email address as tenant name.
                extra_fields['name'] = tld.domain.title()

            if not extra_fields['country']:
                try:
                    country_code = geo_ip.country(
                        tld.registered_domain).get('country_code')
                except (gaierror, AddressNotFoundError):
                    pass
                else:
                    if country_code in [c[0] for c in COUNTRIES]:
                        extra_fields['country'] = country_code

            if extra_fields['country'] and not extra_fields['currency']:
                currency = get_territory_currencies(
                    extra_fields['country'])[-1]
                if currency in [c[0] for c in CURRENCIES]:
                    extra_fields['currency'] = currency

        if settings.BILLING_ENABLED:
            # Chargebee needs extra info on who to bill, so for now only create the plans without activating the trial.
            plan, created = Plan.objects.get_or_create(
                name=settings.CHARGEBEE_PRO_TRIAL_PLAN_NAME)
            billing = Billing.objects.create(plan=plan)
        else:
            billing = Billing.objects.create()

        tenant = Tenant.objects.create(billing=billing, **extra_fields)

        create_defaults_for_tenant(tenant)

        return tenant
Esempio n. 16
0
def get_location_from_request(request):
    """
    Returns location object.
    :param request: http request
    :type request: django.http.HttpRequest
    :return: location instance or empty dict
    :rtype: instance or dict
    """
    from django.contrib.gis.geoip2 import GeoIP2
    from geoip2.errors import AddressNotFoundError

    user_ip = get_ip_from_request(request=request)
    g = GeoIP2()
    try:
        location = g.city(user_ip)
    except AddressNotFoundError:
        return dict()
    else:
        return location
Esempio n. 17
0
def index(request):
    url = 'http://api.openweathermap.org/data/2.5/weather?lat={}&lon={}&units=metric&appid=a37ca4bee258beb72cf54b2b5cf190f3'
    city = "Las Vegas"
    city_weather = ""

    if request.method == 'POST':  #only true if form is submited
        # form = CityForm(request.POST)
        # form.save() # will validate and save if validate
        print(request.POST.items())
        city_weather = requests.get(
            url.format(request.POST["lat"], request.POST["lon"])).json()
    else:
        x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
        ip = None
        if x_forwarded_for:
            ip = x_forwarded_for.split(',')[0]
        else:
            ip = request.META.get('REMOTE_ADDR')

        g = GeoIP2()

        try:
            print(ip)
            lat_lon = g.lat_lon(ip)
            city_weather = requests.get(url.format(lat_lon[0],
                                                   lat_lon[1])).json()
        except:
            url = 'http://api.openweathermap.org/data/2.5/weather?q={}&units=metric&appid=a37ca4bee258beb72cf54b2b5cf190f3'
            city_weather = requests.get(url.format(city)).json()

    weather_data = []

    weather = {
        'city': city_weather['name'],
        'temperature': city_weather['main']['temp'],
        'description': city_weather['weather'][0]['description'],
        'lat': city_weather['coord']['lat'],
        'lon': city_weather['coord']['lon'],
        'icon': city_weather['weather'][0]['icon'],
    }
    context = weather
    return render(request, 'weatherapp/index.html',
                  context)  #returns the index.html template
Esempio n. 18
0
    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
Esempio n. 19
0
    def test04_city(self, gethostbyname):
        "GeoIP city querying methods."
        gethostbyname.return_value = "129.237.192.1"
        g = GeoIP2(country="<foo>")

        for query in (self.fqdn, self.addr):
            # Country queries should still work.
            self.assertEqual(
                "US",
                g.country_code(query),
                "Failed for func country_code and query %s" % query,
            )
            self.assertEqual(
                "United States",
                g.country_name(query),
                "Failed for func country_name and query %s" % query,
            )
            self.assertEqual(
                {"country_code": "US", "country_name": "United States"},
                g.country(query),
            )

            # City information dictionary.
            d = g.city(query)
            self.assertEqual("NA", d["continent_code"])
            self.assertEqual("North America", d["continent_name"])
            self.assertEqual("US", d["country_code"])
            self.assertEqual("Lawrence", d["city"])
            self.assertEqual("KS", d["region"])
            self.assertEqual("America/Chicago", d["time_zone"])
            self.assertFalse(d["is_in_european_union"])
            geom = g.geos(query)
            self.assertIsInstance(geom, GEOSGeometry)

            for e1, e2 in (
                geom.tuple,
                g.coords(query),
                g.lon_lat(query),
                g.lat_lon(query),
            ):
                self.assertIsInstance(e1, float)
                self.assertIsInstance(e2, float)
Esempio n. 20
0
def payment_pingback(request):
    ip = get_ip(request)
    g = GeoIP2()
    try:
        country = g.country(ip)
        if country["country_name"] == "Georgia":
            user_language = 'ka_GE'
            translation.activate(user_language)
            response = HttpResponse()
            response.set_cookie(settings.LANGUAGE_COOKIE_NAME, user_language)
        elif country["country_name"] == "Russia" or country[
                "country_name"] == "Ukraine" or country[
                    "country_name"] == "Belarus" or country[
                        "country_name"] == "Latvia" or country[
                            "country_name"] == "Lithuania" or country[
                                "country_name"] == "Moldova" or country[
                                    "country_name"] == "Estonia":
            user_language = 'ru'
            translation.activate(user_language)
            response = HttpResponse()
            response.set_cookie(settings.LANGUAGE_COOKIE_NAME, user_language)
    except:
        pass
    test = request.GET.dict()
    test2 = request.GET.get('uid')

    pingback = Pingback(test, request.META['REMOTE_ADDR'])

    if pingback.validate():
        virtual_currency = pingback.get_vc_amount()
        if pingback.is_deliverable():
            # deliver the virtual currency
            print('OK')
        elif pingback.is_cancelable():
            # withdraw the virtual currency
            pass
            print(
                'Fail'
            )  # Paymentwall expects response to be OK, otherwise the pingback will be resent
    else:
        print(pingback.get_error_summary())
    return render(request, 'payment/pingback.html')
Esempio n. 21
0
    def process_request(self, request):
        """
        Add country info _before_ view is called.

        The country info is stored in the session between requests,
        so we don't have to do the lookup on each request, unless the
        client IP has changed.

        """
        try:
            self.geoip2 = GeoIP2()
        except GeoIP2Exception:
            return None
        ip_address = self.remote_addr(request)
        data = request.session.get(GeoIP2Middleware.SESSION_KEY)
        if data is None:
            data = self.get_geo_data(ip_address).to_dict()
        elif data['ip_address'] != ip_address:
            data = self.get_geo_data(ip_address).to_dict()
        request.session[GeoIP2Middleware.SESSION_KEY] = request.geo_data = data
Esempio n. 22
0
    def test03_country(self, gethostbyname):
        "GeoIP country querying methods."
        gethostbyname.return_value = '128.249.1.1'
        g = GeoIP2(city='<foo>')

        for query in (self.fqdn, self.addr):
            self.assertEqual(
                'US',
                g.country_code(query),
                'Failed for func country_code and query %s' % query
            )
            self.assertEqual(
                'United States',
                g.country_name(query),
                'Failed for func country_name and query %s' % query
            )
            self.assertEqual(
                {'country_code': 'US', 'country_name': 'United States'},
                g.country(query)
            )
Esempio n. 23
0
 def process_request(self, request):
     g = GeoIP2()
     abbrs = [i['abbreviation'] for i in
              CountryFlag.objects.all().values('abbreviation')]
     _row = 'ROW'
     if get_client_ip(request) != '127.0.0.1':
         try:
             country = g.country(get_client_ip(request))\
                 .get('country_code')
             if country in abbrs:
                 request.country = country
             else:
                 request.country = _row
         except AddressNotFoundError:
             request.country = _row
     else:
         request.country = _row
     if 'country' in request.session and request.session['country']:
         request.country = request.session['country']
     return None
Esempio n. 24
0
    def test03_country(self, gethostbyname):
        "GeoIP country querying methods."
        gethostbyname.return_value = "128.249.1.1"
        g = GeoIP2(city="<foo>")

        for query in (self.fqdn, self.addr):
            self.assertEqual(
                "US",
                g.country_code(query),
                "Failed for func country_code and query %s" % query,
            )
            self.assertEqual(
                "United States",
                g.country_name(query),
                "Failed for func country_name and query %s" % query,
            )
            self.assertEqual(
                {"country_code": "US", "country_name": "United States"},
                g.country(query),
            )
Esempio n. 25
0
    def get(self, request):
        resp_dict = {
            'login_error': request.GET.get('login_error', 0),
            'page': 'single',
            'org_types': OrganizationType.objects.all(),
            'test_alarm': False
        }

        claim_type_sets = {}
        for org_type in resp_dict['org_types']:
            claim_type_set = []
            for claim_type in org_type.claimtype_set.all():
                claim_type_set.append({
                    'id': claim_type.id,
                    'value': claim_type.name
                })
            claim_type_sets[org_type.type_id] = claim_type_set

        resp_dict['claim_types'] = mark_safe(json.dumps(claim_type_sets))

        if settings.RECAPTCHA_ENABLED is False:
            settings.RECAPTCHA_PUBLIC = ''
        resp_dict['recaptcha_public'] = settings.RECAPTCHA_PUBLIC

        if settings.TEST_SERVER:
            resp_dict['test_alarm'] = True

        if hasattr(settings, 'TEST_COORDINATES'):
            resp_dict['zoom_to'] = getattr(settings, 'TEST_COORDINATES')
        else:
            g = GeoIP2()
            ip = get_client_ip(request)
            try:
                if g.country(ip)['country_code'] == settings.COUNTRY_CODE:
                    resp_dict['zoom_to'] = list(g.lat_lon(ip))
                else:
                    resp_dict['zoom_to'] = settings.DEFAULT_ZOOM
            except AddressNotFoundError:
                resp_dict['zoom_to'] = settings.DEFAULT_ZOOM

        return render(request, self.template_name, resp_dict)
Esempio n. 26
0
    def serve(self, request):
        default = super(RegionRedirectionPage, self).serve(request)

        # Check if user came here from a different page
        if 'QUERY_STRING' in request.META and 'selector=true' in request.META[
                'QUERY_STRING']:
            # Then they came from a page looking to go to a different page.
            # Which also means we can assume they don't want to be prompted
            # to change language or region. This will get used by the includes
            # prompt (language_location_prompt.html), so we set a cookie to
            # make sure they don't get prompted again
            request.session['chosen_region_or_language'] = True
            # We also want to make sure that we store the correct site_region cookie
            # on the home page, so we redirect them to the correct region home page,
            # See how we handle that in get_context.
            return default

        elif request.session.get('site_region'):
            # We know that they have been to the home page once before, and
            # they're not looking to change region/language otherwise the above
            # case would have caught them.
            return HttpResponseRedirect(self.url +
                                        request.session.get('site_region') +
                                        '/')

        # Check Users IP
        client_ip, is_routable = get_client_ip(request)

        if client_ip:
            if is_routable:
                geo = GeoIP2()
                detected_region = geo.country(client_ip)['country_code']

                if not HomePage.objects.filter(region=detected_region.lower()):
                    # Detected region does not have a home page, so bring them to self for them to pick
                    return default
                # This means that the region detected is an available HomePage, direct user there, automatically.
                return HttpResponseRedirect(self.url +
                                            detected_region.lower() + '/')

        return default
Esempio n. 27
0
def get_login_logs(user, count):
    cache_key = 'member.member_tags.get_login_logs({})'.format(user.id)
    cache_time = settings.CACHES['default']['TIMEOUT']

    logs = cache.get(cache_key)

    if not logs:
        logs = LoginLog.objects.filter(user=user).order_by('-created')[:count]

        for log in logs:
            log.country_code = None
            try:
                if log.ip_address not in ['127.0.0.1']:
                    country = GeoIP2().country(log.ip_address)
                    log.country_code = country['country_code'].lower()
            except AddressNotFoundError:
                pass

        cache.set(cache_key, logs, cache_time)

    return logs
Esempio n. 28
0
def home(request):
    g = GeoIP2()
    x = g.country('google.com')

    x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
    #if x_forwarded_for:

    #ip = request.META.get('REMOTE_ADDR')
    user = request.user
    ip = request.META.get('HTTP_X_FORWARDED_FOR')
    y = g.city('183.82.219.109')
    lat, long = g.lat_lon('183.82.219.109')
    context = {
        'x': x,
        'y': y,
        'ip': ip,
        'lat': lat,
        'long': long,
        'user': user
    }
    return render(request, 'home.html', context)
Esempio n. 29
0
def link_redirect_view(request, link_id):
    link = get_object_or_404(Link, pk=link_id)
    g = GeoIP2()
    ip = request.META.get('REMOTE_ADDR', None)
    if ip == '127.0.0.1':
        my_country_code = 'RS'
    else:
        my_country_code = g.country(ip)['country_code']

    # print("get ip ", request.META.get('HTTP_X_FORWARDED_FOR'))
    redirect_page = "https://google.com"
    linkprefs = link.linkpref_set.all()
    rps = {}
    for lp in linkprefs:
        print(lp.country.code)
        if lp.country.code == my_country_code:
            rps[lp.landing_page] = lp.weight

    redirect_page = np.random.choice(list(rps.keys()), p=list(rps.values()))
    print(redirect_page)
    return redirect(redirect_page)
Esempio n. 30
0
def get_geo_from_ip(ip) -> tuple:
    """Get geometrical info from an IP address based on GeoLite2 databases.

    :param ip: user IP address
    :type ip: str
    :return: geometrical data
    """

    #########################
    # Practically just for testing purposes, because GeoLite2 doesn't contain 127.0.0.1 IP address
    # TODO: remove when done testing
    if ip == '127.0.0.1':
        ip = '89.74.26.21'  # Katowice
    #########################

    g = GeoIP2()
    country = g.country(ip)
    city = g.city(ip)
    lat, lon = g.lat_lon(ip)

    return country, city, lat, lon
Esempio n. 31
0
def get_city_from_request(request):
    if GeoIP2 is None:
        return

    ip = get_client_ip(request)
    if not ip:
        logger.warning('No IP found on request: %s', request)
        return

    try:
        g = GeoIP2()
    except Exception as e:
        logger.exception(e)
        return
    try:
        result = g.city(ip)
    except Exception as e:
        logger.exception(e)
        return
    if result and result.get('latitude'):
        return result
Esempio n. 32
0
def assignment_upload(request):
    if request.method == 'POST' and request.user.is_authenticated:
        active_support = User.objects.filter(
            Q(is_superuser=True) & Q(is_active=True)).first()
        form = AssignmentDocumentForm(request.POST, request.FILES)
        if form.is_valid():
            ip = get_ip(request)
            geographical_location = GeoIP2()
            data = geographical_location.city(ip)
            country = data["country_name"]
            form.instance.ip_address = ip
            form.instance.location = country
            form.instance.creator = request.user
            form.instance.support = active_support
            form.save()
            messages.success(
                request, 'Assignment has been successfully uploaded.Thank you')
            return redirect('assignments:assignment_list')
    else:
        form = AssignmentDocumentForm()
    return render(request, 'upload.html', {'form': form})