Esempio n. 1
0
def search(request):
    form = SearchForm(request.GET)

    context = {
        'form': form,
    }

    if form.is_valid():
        query_text = form.cleaned_data['q']
        context['query'] = query_text

        postcode = ''.join(query_text.split()).upper()
        if validation.is_valid_postcode(postcode):
            res = requests.get('https://api.postcodes.io/postcodes/' +
                               postcode,
                               timeout=1)
            if res.ok:
                result = res.json()['result']
                point = Point(result['longitude'],
                              result['latitude'],
                              srid=4326)
                bbox = Polygon.from_bbox((point.x - .05, point.y - .05,
                                          point.x + .05, point.y + .05))

                context['postcode'] = Locality.objects.filter(
                    latlong__within=bbox).filter(
                        Q(stoppoint__active=True)
                        | Q(locality__stoppoint__active=True)).distinct(
                        ).annotate(distance=Distance('latlong', point)
                                   ).order_by('distance').defer('latlong')[:2]

        if 'postcode' not in context:
            query = SearchQuery(query_text,
                                search_type="websearch",
                                config="english")

            rank = SearchRank(F('search_vector'), query)

            localities = Locality.objects.filter()
            operators = Operator.objects.filter(
                service__current=True).distinct()
            services = Service.objects.filter(current=True)

            localities = localities.filter(search_vector=query).annotate(
                rank=rank).order_by('-rank')
            operators = operators.filter(search_vector=query).annotate(
                rank=rank).order_by('-rank')
            services = services.filter(search_vector=query).annotate(
                rank=rank).order_by('-rank')

            services = services.prefetch_related('operator')

            context['localities'] = Paginator(localities, 20).get_page(
                request.GET.get('page'))
            context['operators'] = Paginator(operators, 20).get_page(
                request.GET.get('page'))
            context['services'] = Paginator(services, 20).get_page(
                request.GET.get('page'))

    return render(request, 'search.html', context)
Esempio n. 2
0
def LocationPosition(request):
    """
    Get coordinates for location or postcode
    """

    locationtext = request.GET.get('location').strip()

    location, zoom, result = None, 15, {'result': 'failure'}
    postcodetext = re.sub("[^0-9a-zA-Z]+", "", locationtext).upper()

    if validation.is_valid_postcode(postcodetext):
        location = get_postcode_point(postcodetext)
    else:
        locationrecord = Location.objects.filter(
            town__iexact=locationtext).first()
        if (locationrecord is not None):
            location = locationrecord.location
            zoom = locationrecord.scale

    if location:
        result = {
            'result': 'success',
            'data': {
                'lat': location[1],
                'lng': location[0],
                'zoom': zoom
            }
        }

    return HttpResponse(json.dumps(result),
                        content_type="text/json-comment-filtered")
Esempio n. 3
0
    def clean(self):
        cleaned_data = super(OrganisationFinderForm, self).clean()
        location = cleaned_data.get('location', None)
        if location:
            postcode = re.sub('\s+', '', location.upper())
            if validation.is_valid_postcode(postcode):
                organisations = self.organisations_from_postcode(postcode)
                validation_message = "Sorry, there are no matches within 5 miles of %s. Please try again. %s" % (location, self.PILOT_SEARCH_CAVEAT)
            elif validation.is_valid_partial_postcode(postcode):
                organisations = self.organisations_from_postcode(postcode, partial=True)
                validation_message = "Sorry, there are no matches within 5 miles of %s. Please try again. %s" % (location, self.PILOT_SEARCH_CAVEAT)
            else:
                organisations = self.queryset.filter(name__icontains=location)
                if len(organisations) < 5:
                    # Try a metaphone search to give more results
                    location_metaphone = dm(location)
                    # First do a __startswith or __endswith
                    alt_orgs = self.queryset.filter(Q(name_metaphone__startswith=location_metaphone[0])
                                                    | Q(name_metaphone__endswith=location_metaphone[0]),
                                                    ~Q(pk__in=list([a.id for a in organisations])))
                    organisations = list(chain(organisations, alt_orgs))
                    if len(organisations) < 10:
                        # Try a metaphone __contains to give even more results
                        more_orgs = self.queryset.filter(Q(name_metaphone__contains=location_metaphone[0]),
                                                         ~Q(pk__in=list([a.id for a in organisations])))
                        organisations = list(chain(organisations, more_orgs))

                validation_message = "We couldn't find any matches for '%s'. Please try again. %s" % (location, self.PILOT_SEARCH_CAVEAT)
            if len(organisations) == 0:
                raise forms.ValidationError(validation_message)

            cleaned_data['organisations'] = organisations

        return cleaned_data
Esempio n. 4
0
 def clean(self):
     cleaned_data = super(PostcodeFieldForm, self).clean()
     postcode_field = cleaned_data.get('postcode_field')
     skip_bad_rows = cleaned_data.get('skip_bad_rows')
     bad_rows = 0
     bad_row_numbers = []
     for i, row in enumerate(self.instance.original_file_reader()):
         postcode = row[postcode_field].replace(" ", "")
         if not is_valid_postcode(postcode):
             bad_rows += 1
             bad_row_numbers.append(str(i + 1))
     if not skip_bad_rows and bad_rows > 0:
         # Make sure the skip checkbox is shown next time
         self.fields['skip_bad_rows'].widget = forms.CheckboxInput()
         if bad_rows == 1:
             msg = 'Row: '
             msg += ', '.join(bad_row_numbers)
             msg += ' doesn\'t seem to be a valid postcode.'
             msg += ' Do you want us to skip it?'
         else:
             msg = 'Rows: '
             msg += ', '.join(bad_row_numbers)
             msg += ' don\'t seem to be valid postcodes.'
             msg += ' Do you want us to skip them?'
         raise forms.ValidationError(msg)
     else:
         cleaned_data['bad_rows'] = bad_rows
     return cleaned_data
Esempio n. 5
0
def validate_uk_postcode(value):
    # The validator doesn't like spaces or lowercase:
    test_value = value.replace(' ', '').upper()
    if validation.is_valid_postcode(test_value) is False:
        raise ValidationError(
            _('%(value)s is not a valid postcode'),
            params={'value': value},
        )
Esempio n. 6
0
def getvalidPostcode():
    userText = request.args.get('msg')
    postcode.append(userText)
    postcode_without_space = userText.replace(" ", "")
    if (validation.is_valid_postcode(postcode_without_space)
            and " " in userText):
        return "1"
    else:
        return "2"
Esempio n. 7
0
def add_helper(request):
    postcode = request.POST["postcodeFirst"] + request.POST["postcodeSecond"]
    if validation.is_valid_postcode(postcode):
        Helper.objects.create(
            postcodeFirst=request.POST["postcodeFirst"],
            postcodeSecond=request.POST["postcodeSecond"],
            link=request.POST["link"],
        )
        return render(request, "thankyou.html")
    else:
        return render(request, "error.html", {"postcode": postcode})
Esempio n. 8
0
    def clean_postcode(self) -> str:
        """If country is in the UK, validates a UK postcode, and reformats it to uppercase with the correct space"""
        country = self.cleaned_data.get('country')
        postcode = self.cleaned_data.get('postcode')
        if postcode and country and 'United Kingdom' in country.name:
            spaceless_postcode = re.sub(r'\s', '', postcode).upper()
            if not is_valid_postcode(spaceless_postcode):
                raise ValidationError('Invalid UK postcode')
            postcode = f'{spaceless_postcode[:-3]} {spaceless_postcode[-3:]}'

        return postcode
Esempio n. 9
0
 def postcodeSearch(postcode):
     postcode_id = postcode.replace(' ','').upper()
     if validation.is_valid_postcode(postcode_id):
         searchQuery = {
             "query": {
                 "ids" : {
                     "type" : "postcode",
                     "values" : postcode_id
                 }
             }
         }
         return requests.get(ES_URL,json=searchQuery).json()
     else:
         return False #return false for invalid postcode
Esempio n. 10
0
 def get_postcode(self):
     q = self.cleaned_data['q']
     q = ''.join(q.split()).upper()
     if validation.is_valid_postcode(q):
         res = session.get('https://api.postcodes.io/postcodes/' + q, timeout=2)
         if not res.ok:
             return ''
         result = res.json()['result']
         point = Point(result['longitude'], result['latitude'], srid=4326)
         bbox = Polygon.from_bbox((point.x - .05, point.y - .05, point.x + .05, point.y + .05))
         return Locality.objects.filter(
             latlong__within=bbox
         ).filter(
             Q(stoppoint__active=True) | Q(locality__stoppoint__active=True)
         ).distinct().annotate(
             distance=Distance('latlong', point)
         ).order_by('distance').defer('latlong')[:2]
Esempio n. 11
0
def validate_postcode(postcode: str):
    """
    Validate UK postcode format

    Args:
        postcode: string
    Raises:

        Validation Error:

    Returns:
        None:
    """
    postcode_no_spaces = postcode.replace(' ', '')
    if not validation.is_valid_postcode(postcode_no_spaces):
        raise ValidationError(
            'This cannot be a valid postcode: %s' % postcode)
Esempio n. 12
0
 def get_postcode(self):
     q = self.cleaned_data['q']
     q = ''.join(q.split()).upper()
     if validation.is_valid_postcode(q):
         res = session.get('https://api.postcodes.io/postcodes/' + q,
                           timeout=2)
         if not res.ok:
             return ''
         result = res.json()['result']
         point = Point(result['longitude'], result['latitude'], srid=4326)
         bbox = Polygon.from_bbox(
             (point.x - .05, point.y - .05, point.x + .05, point.y + .05))
         return Locality.objects.filter(latlong__within=bbox).filter(
             Q(stoppoint__active=True)
             | Q(locality__stoppoint__active=True)).distinct().annotate(
                 distance=Distance('latlong', point)).order_by(
                     'distance').defer('latlong')[:2]
Esempio n. 13
0
    def validate_postcode(form, field):

        #is it a postcode?
        if not validation.is_valid_postcode(field.data.replace(' ', '').upper()):
            raise ValidationError('You need to enter a valid postcode')
                
        if app.config.get('BECKTON_POSTCODE_AREAS_CSV', False):
            #is it in the an allowed postcode?
            condition_postcode_areas = app.config['BECKTON_POSTCODE_AREAS_CSV'].split(',')
            if not condition_postcode_areas == []:
                in_bounds = False

                for postcode_area in condition_postcode_areas:
                    if field.data.lower().startswith(postcode_area.lower()):
                      in_bounds = True

                if not in_bounds:
                    postcode_areas_formatted = ', '.join(condition_postcode_areas)
                    raise ValidationError('You can currently only sign up if your postcode starts with %s' % postcode_areas_formatted)
Esempio n. 14
0
    def get_context_data(self, **kwargs):
        context = super(MapSearch, self).get_context_data()

        term = self.request.GET.get('term', '')

        # no search, no results
        if not len(term):
            return context

        to_serialize = context['results']

        # Check if the term is a postcode
        possible_postcode = re.sub('\s+', '', term.upper())
        is_postcode = is_valid_postcode(possible_postcode)
        is_partial_postcode = is_valid_partial_postcode(possible_postcode)
        if is_postcode or is_partial_postcode:
            try:
                point = MapitPostCodeLookup.postcode_to_point(possible_postcode, partial=is_partial_postcode)
                to_serialize.append({
                    "id":   possible_postcode,
                    "text": term.upper() + ' (postcode)',
                    "type": "place",
                    "lat":  point.y,
                    "lon":  point.x,
                })
                return context
            except MapitError:
                # Not really much to be done about an error, pass through to the rest of the code.
                pass
        places = Place.objects.filter(name__istartswith=term)
        places = places.order_by('name')

        for obj in places[:8]:
            to_serialize.append({
                "id":   obj.id,
                "text": obj.context_name,
                "type": "place",
                "lat":  obj.centre.y,
                "lon":  obj.centre.x,
            })

        return context
Esempio n. 15
0
def process(userText):
    postcode_without_space = postcode[0].replace(" ", "")
    if (validation.is_valid_postcode(postcode_without_space)
            and " " in postcode[0]):
        if (num[0] == 2):
            response = hack.getMeATM(postcode[0])
            return response
        elif (num[0] == 1):
            if (userText == "no" or userText == "No"):
                response = hack.getMeBranches(postcode[0])
                return response
            else:
                try:
                    response = hack.getMeBranchesForSpecificBank(
                        postcode[0], userText)
                    return response
                except:
                    return ("Invalid bank input")
    else:
        return ("Invalid Postcode.")
Esempio n. 16
0
def api():

	postcode = request.args.get('postcode', '')
	postcode = postcode.replace(' ', '').upper()

	if postcode == '' or not validation.is_valid_postcode(postcode):
			return Response(response="{'message': 'Invalid data'}", status=400, mimetype='application/json')

	data = {}
	br = mechanize.Browser()
	br.addheaders = [('User-agent', 'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.0.1) Gecko/2008071615 Fedora/3.0.1-1.fc9 Firefox/3.0.1')]

	try:
			br.open(app.config['DIRECT_GOV_URL'])
			br.form = list(br.forms())[0]
			br.form["ctl00$ContentPlaceHolder1$Postcode"] = postcode
			response = br.submit()
			html = response.read()
	except urllib2.URLError:
			return Response(response="{'message': 'Bad gateway - direct.gov.uk not available'}", status=502, mimetype='application/json')

	try:
			#get name
			matches = re.findall('<h3>([^<]*)</h3>', html)
			name = matches[1].strip()

			#get address
			matches = re.search('(.*)<br \/>Telephone', html)
			print  matches
			parts = matches.group(1).strip().split('<br />')
			postcode = parts[len(parts) - 1]
			address = ', '.join(parts)
	except IndexError:
			return Response(response="{'message': 'Bad gateway - error passing data'}", status=502, mimetype='application/json')

	data = {'name': name, 'address':address, 'postcode':postcode, 'opening-times': []}
	return Response(response=json.dumps(data), status=200, headers=None, mimetype='application/json', content_type=None, direct_passthrough=False)
Esempio n. 17
0
def checkout(request):
    customer = request.user.customer
    order, created = Order.objects.get_or_create(customer=customer,
                                                 complete=False)

    products = order.orderproduct_set.all()
    cartProducts = order.get_cart_items

    if request.method == 'GET':
        form = CheckoutForm()
        context = {
            'products': products,
            'order': order,
            'cartProducts': cartProducts,
            'form': form
        }
        return render(request, 'checkout.html', context)

    form = CheckoutForm(request.POST)
    context = {
        'products': products,
        'order': order,
        'cartProducts': cartProducts,
        'form': form
    }
    if not form.is_valid():
        return render(request, 'checkout.html', context)

    name = form.cleaned_data['name'].strip()
    street_address = form.cleaned_data['street_address'].strip()
    city = form.cleaned_data['city'].strip()
    state = form.cleaned_data['state'].strip()
    postcode = form.cleaned_data['postcode'].strip().upper()
    phone_number = form.cleaned_data['phone_number'].strip()
    postcode = ''.join(postcode.split())

    if len(phone_number) != 11:
        messages.warning(request, 'Please enter a valid phone number')
        return render(request, 'checkout.html', context)

    if not phone_number.isdecimal():
        messages.warning(request, 'Please enter a valid phone number')
        return render(request, 'checkout.html', context)

    if not validation.is_valid_postcode(postcode):
        messages.warning(request, 'Please enter a valid postcode')
        return render(request, 'checkout.html', context)

    order.order_date = datetime.datetime.today().strftime('%Y-%m-%d')
    order.order_id = datetime.datetime.now().timestamp()
    order.complete = True
    order.save()

    new_shipping = Shipping(customer=customer,
                            order=order,
                            street_address=street_address,
                            city=city,
                            state=state,
                            postcode=postcode,
                            phone_number=phone_number)
    new_shipping.save()

    messages.success(request, f'Thanks for your order')
    return HttpResponseRedirect('/')
Esempio n. 18
0
def is_valid_postcode(pc):
    return validation.is_valid_postcode(
        pc, SPECIAL_POSTCODES + ('ZZ99ZZ', 'ZZ99ZY'))
Esempio n. 19
0
def is_valid_postcode(value):
    if not validation.is_valid_postcode(value.replace(' ', '').upper()):
        raise ValidationError(_('Please enter a UK postcode'))
Esempio n. 20
0
def post_code_validator(form, field):
    if not validation.is_valid_postcode(field.data):
        raise ValidationError('Invalid UK Post Code')
Esempio n. 21
0
def is_valid_postcode(pc):
    return validation.is_valid_postcode(pc, SPECIAL_POSTCODES + ('ZZ99ZZ', 'ZZ99ZY'))
 def f(postcode):
     if not is_valid_postcode(postcode, extra_postcodes_that_are_valid):
         raise Invalid("Postcode is invalid: " + postcode)
     return postcode