def address_edit_page(address_id):
db = current_app.config["db"]
customer_id = db.customer_address.get_row("CUSTOMER_ID", "ADDRESS_ID", address_id)
if current_user.id != customer_id and not current_user.is_admin:
return abort(401)
form = AddressForm()
address_obj = db.address.get_row("*", "ADDRESS_ID", address_id)
if form.validate_on_submit():
values = address_take_info_from_form(form, request.form)
db.address.update(["ADDRESS_NAME", "COUNTRY", "CITY", "DISTRICT", "NEIGHBORHOOD", "AVENUE", "STREET", "ADDR_NUMBER", "ZIPCODE", "EXPLANATION"], values, "ADDRESS_ID", address_obj.address_id)
flash("Address is updated successfully", "success")
next_page = request.args.get("next", url_for("home_page"))
return redirect(next_page)
return render_template("address/address_form.html", form=form, address=address_obj, head_title="Edit address")
def home():
form = AddressForm()
p = Place()
if request.method == 'GET':
places = []
gl = session.get('_location', None)
gl = get_user_location() if gl is None else Geolocation(*gl)
if gl is None:
form.address.data = 'London, UK'
else:
form.address.data = '{}, {}, {} {}'.format(gl.city, gl.region_name,
gl.country_name,
gl.zip_code)
my_coordinates = p.address_to_latlng(form.address.data)
if not all(my_coordinates):
# failed to decode address to lat, lng
form.address.errors += (
'Invalid address',
) # form.address.errors is a immutable tuple
else:
places = p.query(form.address.data)
return render_template('home.html',
form=form,
my_coordinates=my_coordinates,
places=places)
elif request.method == 'POST':
if form.validate() == False:
return render_template('home.html', form=form)
else:
# get the address
address = form.address.data
# query for places around the address
my_coordinates = p.address_to_latlng(address)
places = p.query(address)
# return the results as a list
return render_template('home.html',
form=form,
my_coordinates=my_coordinates,
places=places)
def address():
"""
A view to display and add addresses.
"""
form = AddressForm(request.form)
if request.method == 'POST':
if form.validate_on_submit():
flash(message="Success")
new_address = Address(address=form.address.data)
db_session.add(new_address)
db_session.commit()
return redirect(url_for('address'))
else:
return render_template('address/address.html', form=form)
elif request.method == 'GET':
addresses_lists = db_session.query(Address).all()
return render_template('address/address.html',
addresses=addresses_lists)
def home():
if 'email' not in session:
return redirect(url_for('login'))
form = AddressForm()
if request.method == "POST":
if form.validate() == False:
return render_template('home.html', form=form)
else:
# get the address
address = form.address.data
# query for places around it
# return those results
elif request.method == "GET":
return render_template('home.html', form=form)
def home():
form = AddressForm()
if 'email' not in session:
return redirect(url_for('login'))
if request.method == 'POST':
if form.validate() == False:
return render_template('home.html', form=form)
#else:
# get the address
#address = form.address.data
# query for places around it
# return the results
#pass
return render_template("home.html", form=form)
def map():
this_route = url_for('.map')
if 'email' not in session:
app.logger.info(
"Can't access {} without session id".format(this_route))
return redirect(url_for('login'))
form = AddressForm()
places = []
ip = urllib.request.urlopen('https://ident.me').read().decode('utf8')
g = geocoder.ip(ip)
my_coordinates = (g.lat, g.lng)
if request.method == 'POST':
if form.validate() == False:
app.logger.info("Map request invalid {}".format(this_route))
return render_template('map.html', form=form)
else:
# get the address
address = form.address.data
# query for places around it
p = Place()
my_coordinates = p.address_to_latlng(address)
places = p.query(address)
app.logger.info("Map request success {}".format(this_route))
# return those results
return render_template('map.html',
form=form,
my_coordinates=my_coordinates,
places=places)
elif request.method == 'GET':
app.logger.info("GET {}".format(this_route))
return render_template("map.html",
form=form,
my_coordinates=my_coordinates,
places=places)
app.logger.info("Logging a test message from {}".format(this_route))
return render_template("map.html")
def booking4(request, date, slot, contractor_id):
'''
This function is for users to confirm
'''
variables = {}
try:
start = date = datetime.datetime.strptime(date, '%Y-%m-%d')
except:
start = date + datetime.timedelta(days=1)
end = start + datetime.timedelta(days=1)
form = AddressForm(request.GET)
if form.is_valid():
request.session['address'] = [
request.GET['housenumber'], request.GET['street'],
request.GET['city'], request.GET['postcode']
]
request.session['additional_info'] = request.GET['additional_info']
else:
variables['form'] = form
return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
mylist = []
for item in request.session['qwerty']:
mylist.append(Item.objects.get(id=item[0]))
variables['items'] = mylist
variables['contractor'] = contractor = MyUser.objects.get(id=contractor_id)
variables['date'] = date
variables['slot'] = slot
variables['stripe_key'] = STRIPE_PUBLISH_KEY
request.session['deposit'] = round(
request.session['cost'] * CHANGE_THE_LOCKS_DEPOSIT / 100, 2)
variables['address'] = request.session['address']
request.session['slot'] = slot
request.session['date'] = date.strftime('%Y-%m-%d')
request.session['contractor_id'] = contractor_id
variables['cost'] = request.session['cost']
variables['menu'] = 'menu2'
return render(request, 'booking/booking4.html', variables)
def home():
#if 'email' not in session: # make sure if user is not logged in, he cant access to the home page
#return redirect(url_for('login'))
if not is_loggedin():
return redirect(url_for('login'))
places=[]
my_coordinates=(37.4221, -122.0844)
form =AddressForm()
if request.method=='POST':
if form.validate()==False:
return render_template('home.html',form=form)
else:
address=form.address.data
p=Place()
my_coordinates = p.address_to_latlng(address)
places= p.query(address)
return render_template("home.html", form=form, my_coordinates=my_coordinates,places=places)
elif request.method=='GET':
return render_template("home.html", form=form, my_coordinates=my_coordinates,places=places)
def home():
if 'email' not in session:
return redirect(url_for('login'))
form = AddressForm()
places = []
geoloc = []
if request.method == 'POST':
place = Places()
address = form.address.data
geoloc = place.address2geo(address)
places = place.query(address)
return render_template('home.html',
form=form,
places=places,
my_coordinates=geoloc)
return render_template("home.html",
form=form,
places=places,
my_coordinates=geoloc)
def address_page():
information_types = info_types
states = s
form = AddressForm()
validated = form.validate_on_submit()
print(f'address form errors: {form.errors}')
if validated:
address = form.address.data
# search for location on google maps
driver.get('https://www.google.com/maps')
time.sleep(2)
input_field = driver.find_element_by_class_name(
'tactile-searchbox-input')
input_field.send_keys(address)
input_field.send_keys(Keys.ENTER)
time.sleep(2)
address_is_valid = bool(
len(driver.find_elements_by_class_name('section-bad-query-title'))
== 0)
if not address_is_valid:
return invalid_page(invalid=['address'], address=address)
return found_comps_page(information_types, states, address)
return render_template('address.html',
wca_image=wca_image,
form=form,
loading_gif=loading_gif)
def home():
if 'email' not in session:
return redirect(url_for('login'))
form = AddressForm()
places = []
my_coordinates = (37.4221, -122.0844)
if request.method == 'POST':
if form.validate() == False:
return render_template('home.html',
form=form,
my_coordinates=my_coordinates,
places=places,
MAPBOX_KEY=os.environ['MAPBOX_KEY'])
else:
# get the address
address = form.address.data
# query for places around it
p = Place()
my_coordinates = p.address_to_latlng(address)
places = p.query(address)
# return those results
return render_template('home.html',
form=form,
my_coordinates=my_coordinates,
places=places,
MAPBOX_KEY=os.environ['MAPBOX_KEY'])
elif request.method == 'GET':
return render_template('home.html',
form=form,
my_coordinates=my_coordinates,
places=places,
MAPBOX_KEY=os.environ['MAPBOX_KEY'])
def index():
form = AddressForm()
session['navbar_role_selection'] = False
if form.validate_on_submit():
session['person_url'] = request.form['person_url']
start = datetime.datetime.now()
url = session['person_url']
source = requests.get(url)
app.logger.info(f'{datetime.datetime.now() - start} getting the main request')
start = datetime.datetime.now()
soup = BeautifulSoup(source.text, 'lxml')
app.logger.info(f'{datetime.datetime.now() - start} getting the main page soup')
session['roles'] = [i.get('data-category') for i in soup.find('div', {'id': 'jumpto'}).find_all('a')]
session['person'] = soup.select('h1 span', class_='itemprop')[
0].get_text() # Todo: redo other data extraction with get_text()
return redirect('/role')
return render_template('index.html', form=form)
def home():
if 'email' not in session:
# user not logged in send to to login page
return redirect(url_for('login'))
form = AddressForm()
if request.method == 'POST':
if form.validate() == False:
# reload the page - try again
return render_template("home.html", form=form)
else:
# get the address
address = form.address.data
# query for places around it
# return the results
pass
elif request.method == 'GET':
return render_template("home.html", form=form)
return render_template("home.html")
def home():
if 'email' not in session:
return redirect(url_for('login'))
form=AddressForm()
places = []
coord = (0,0)
if request.method == "POST":
if form.validate() == False:
return render_template('home.html', form=form)
else:
#get the address
address = form.address.data
#mark the places
p = Place()
coord = p.latlng(address)
places = p.query(address)
#return the result
return render_template('home.html', form=form, coord=coord, places=places)
elif request.method == "GET":
return render_template("home.html", form=form, coord=coord, places=places)
def home():
if 'email' not in session:
return redirect(url_for('login'))
form=AddressForm()
places = []
my_coordinates = (12.3444,-142.3814)
if request.method == "POST":
if form.validate() == False:
return render_template("home.html", form=form)
else:
# get the address
address = form.Address.data
# query for nearby places
p=Place()
my_coordinates = p.address_to_latlng(address)
places = p.query(address)
# return those results
return render_template("home.html", form=form, my_coordinates=my_coordinates, places=places)
else:
return render_template("home.html", form=form, my_coordinates=my_coordinates, places=places)
def home():
""" Renders the home page """
if 'email' not in session:
return redirect(url_for('login'))
form = AddressForm()
places = []
my_coordinates = (-1.2886111111111, 36.823055555556)
if request.method == 'POST':
if form.validate():
# get the address
address = form.address.data
# query for places around it
p = Place()
my_coordinates = p.address_to_latlng(address)
places = p.query(address)
# return results
return render_template("home.html",
form=form,
my_coordinates=my_coordinates,
places=places,
logout=True)
else:
return render_template("home.html", form=form, logout=True)
elif request.method == 'GET':
return render_template("home.html",
form=form,
my_coordinates=my_coordinates,
places=places,
logout=True)
def rsvp(**kwargs):
choices = models.Party.query.all()
all_addresses = []
for x in choices:
all_addresses.append(x.address)
addressForm = AddressForm()
address = None
postal = None
check = False
error = False
full_name = None
name = None
g = []
q = None
x = None
if request.method == "POST":
address = request.form['address']
x = process.extractOne(address, all_addresses)
if x[1] == 100:
q = models.Party.query.filter_by(address=x[0]).first()
g = models.Guests.query.filter_by(party_id=q.id).all()
addressForm.address.data = ''
elif 88 < x[1] < 100:
check = True
else:
error = True
return render_template('rsvp.html',
addressForm=addressForm,
addres=address,
postal=postal,
full_name=full_name,
g=g,
q=q,
x=x,
check=check,
error=error)
def home():
# Check if email has been set in session - if not, user is not
# logged in and should be redirected to log in page
if "email" not in session:
return redirect(url_for("login"))
form = AddressForm()
places = []
coordinates = (37.4221, -122.0844)
if request.method == "POST":
if form.validate() == False:
return render_template("home.html",
form=form,
coordinates=coordinates,
places=places)
else:
# Get the address from the form
address = form.address.data
# Query for places around it
p = Place()
coordinates = p.address_to_latlng(address)
places = p.query(address)
# Return results
return render_template("home.html",
form=form,
coordinates=coordinates,
places=places)
elif request.method == "GET":
return render_template("home.html",
form=form,
coordinates=coordinates,
places=places)
def home():
if 'email' in session:
form = AddressForm()
places = []
my_coordinates = (42.360091, -71.094160)
if request.method == 'POST':
if not form.validate():
render_template('home.html', form=form)
else:
address = form.address.data
p = Place()
my_coordinates = p.address_to_latlng(address)
places = p.query(address)
return render_template('home.html',
form=form,
my_coordinates=my_coordinates,
places=places)
elif request.method == 'GET':
return render_template('home.html',
form=form,
my_coordinates=my_coordinates,
places=places)
else:
return redirect(url_for('login'))
def home():
if 'email' not in session:
return redirect(url_for('login'))
places = []
my_coordinates = (21.234234,23.343434)
form = AddressForm()
if request.method == 'POST':
if form.validate() == False:
return redirect(url_for('home'))
else:
# get the address
address = form.address.data
# query for place around it
p = Place()
my_coordinates = p.address_to_latlng(address)
places = p.query(address)
# Show the result
return render_template('home.html',form=form,my_coordinates = my_coordinates, places=places)
elif request.method == 'GET':
return render_template('home.html', form = form,my_coordinates = my_coordinates, places=places)
def home():
if 'email' not in session:
return redirect(url_for('login'))
form = AddressForm()
places = []
my_coordinates = [37.4221, -122.0844]
if request.method == 'POST':
if form.validate() == False:
return render_template("home.html", form=form)
else:
# get addess
address = form.address.data
#wuarry for places around it
p = Place()
my_coordinates = p.address_to_latlng(address)
places = p.query(address)
#return resutls
return render_template('home.html', form=form, my_coordinates=my_coordinates, places=places)
elif request.method == 'GET':
return render_template("home.html", form=form, my_coordinates=my_coordinates, places=places)
def home():
if 'email' not in session:
return redirect(url_for('login'))
form = AddressForm()
places = []
my_coordinates = (37.786971, -122.399677)
if request.method == 'POST':
if form.validate() == False:
return render_template("home.html", form = form)
else:
#get the AddressForm
address = form.address.data
#query for places around it
p = Place()
my_coordinates = p.address_to_latlng(address)
places = p.query(address)
#return those results
return render_template('home.html', form=form, my_coordinates=my_coordinates, places=places)
elif request.method == 'GET':
return render_template("home.html", form = form, my_coordinates=my_coordinates, places=places)
return render_template("home.html")
def detailed_user_profile_form(request, id=None):
init_data = {}
user = request.user
user_profile = UserProfile.objects.get(user_id=request.user.id)
if request.method == 'POST':
user_profile_form = DetailedUserProfileForm(request.POST, request.FILES)
if user_profile_form.is_valid():
# User info
user.username = user_profile_form.cleaned_data['user_name']
user.first_name = user_profile_form.cleaned_data['first_name']
user.last_name = user_profile_form.cleaned_data['last_name']
user.email = user_profile_form.cleaned_data['email']
user.save(force_insert=False,
force_update=True,
update_fields=('username', 'first_name', 'last_name', 'email'))
# Address : address and city
city_data = {
'name': user_profile_form.cleaned_data['city'],
'zipcode': user_profile_form.cleaned_data['zipcode'],
'country': user_profile_form.cleaned_data['country']
}
# Check if we can get this city
# If the city doesn't exist, we try to create it, but data may be incomplete
try:
city = City.objects.get(**city_data)
except ObjectDoesNotExist:
try:
city = CityForm(data=city_data).save()
except ValueError:
city = None
if city is not None:
address_data = {
'num': user_profile_form.cleaned_data['num'],
'street': user_profile_form.cleaned_data['street'],
'city': city.pk,
}
try:
address = Address.objects.get(**address_data)
except ObjectDoesNotExist:
try:
address = AddressForm(data=address_data).save()
except ValueError:
address = None
else:
address = None
user_profile.address = address
user_profile.dialcode = user_profile_form.cleaned_data['dialcode']
user_profile.phone_number = user_profile_form.cleaned_data['phone_number']
user_profile.school = user_profile_form.cleaned_data['school']
user_profile.studies_domain = user_profile_form.cleaned_data['studies_domain']
# Profile picture
if 'profile_picture' in user_profile_form.changed_data:
import Image as Pil
import StringIO, time
from django.core.files.uploadedfile import InMemoryUploadedFile
profile_pic = Pil.open(request.FILES.get('profile_picture'))
profile_pic.thumbnail((200, 200), Pil.ANTIALIAS)
ppic_io = StringIO.StringIO()
profile_pic.save(ppic_io, request.FILES['profile_picture'].content_type.split('/')[-1].upper())
ppic_filename = request.user.username + '_avatar_' + str(int(time.time()))
ppic_file = InMemoryUploadedFile(ppic_io,
u"profile_picture",
ppic_filename,
request.FILES['profile_picture'].content_type,
ppic_io.len,
None)
user_profile.profile_picture = ppic_file
user_profile.save()
return redirect(reverse('profiles-list'))
else:
return render(request,
'forms/detailed_userprofile_form.html',
{'form': user_profile_form})
init_data = {
'user_name': user.username,
'first_name': user.first_name,
'last_name': user.last_name,
'email': user.email,
'confirm_email': user.email
}
if user_profile.address is not None:
user_address = Address.objects.get(pk=user_profile.address.pk)
user_city = City.objects.get(pk=user_address.city.pk)
init_data.update({
'num': user_address.num,
'street': user_address.street,
'city': user_city.name,
'zipcode': user_city.zipcode,
'country': user_city.country,
'phone_number': user_profile.phone_number,
'school': user_profile.school,
'studies_domain': user_profile.studies_domain,
})
if user_profile.dialcode is not None:
init_data['dialcode'] = CallingCode.objects.get(pk=user_profile.dialcode.pk)
if user_profile.profile_picture is not None:
init_data['profile_picture'] = user_profile.profile_picture
return render(request, 'forms/detailed_userprofile_form.html',
{'form': DetailedUserProfileForm(initial=init_data)})
def deposit(request):
if request.method == "GET":
html_dict = dict(form_capcha=CaptchaTestForm(),
form_address=AddressForm(),
current=request.path,
client_id=gvars.client_id.lower())
unspent = []
try:
unspent = json.loads(
Popen([
'coin-cli', '-rpcconnect={}_coind'.format(
gvars.client_id.lower()), 'listunspent', '0'
],
stdout=PIPE).communicate()[0])
unspent_filtered = []
for i in unspent:
if i.get('amount') >= gvars.minimum_amount:
unspent_filtered.append(i)
except ValueError:
#unspent_filtered = [] #TODO move this before try?
logging.debug(
'ValueError in deposit.get 0 view.\nIs the coin daemon active?'
)
request.session['error_message'] = general_error_message
except OSError:
#unspent_filtered = [] #TODO move this before try?
logging.debug(
'OSError in deposit.get 0 view.\nIs the coin daemon installed?'
)
request.session['error_message'] = general_error_message
error_message = request.session.get('error_message', False)
if error_message:
html_dict.update(error_message=error_message)
del request.session['error_message']
html_dict.update(count=len(unspent_filtered))
html_dict.update(csrf(request))
return render_to_response('deposit_get.html', html_dict)
if request.method == 'POST':
form = CaptchaTestForm(request.POST)
# check valid capcha
if not form.is_valid():
request.session['error_message'] = 'Invalid captcha.'
return redirect('deposit')
# check valid address
if not is_address_valid(
request.POST['return_address']) == gvars.client_id:
request.session[
'error_message'] = 'Invalid {} return address.'.format(
gvars.client.title())
return redirect('deposit')
# placed before internal address check on purpose
try:
deposit_address = Popen([
'coin-cli', '-rpcconnect={}_coind'.format(
gvars.client_id.lower()), "getnewaddress"
],
stdout=PIPE).communicate()[0].strip()
except ValueError:
logging.debug(
'ValueError in deposit.post 0 view.\nIs the coin daemon active?'
)
request.session['error_message'] = general_error_message
# allow chaining
if not gvars.chaining:
try:
internal_address_list = json.loads(
Popen([
'coin-cli', '-rpcconnect={}_coind'.format(
gvars.client_id.lower()), 'getaddressesbyaccount',
""
],
stdout=PIPE).communicate()[0])
except ValueError:
logging.debug(
'ValueError in deposit.post 1 view.\nIs the coin daemon active?'
)
request.session['error_message'] = general_error_message
if request.POST['return_address'] in internal_address_list:
request.session['error_message'] = 'Chain betting is disabled'
return redirect('deposit')
# create address model
AddressModel.objects.create(
deposit_address=deposit_address,
return_address=request.POST['return_address']).save()
html_dict = dict(deposit_address=deposit_address,
minimum_amount=gvars.minimum_amount,
client_id=gvars.client_id,
client=gvars.client,
current=request.path)
return render_to_response('deposit_post.html', html_dict)
def edit_fulladdress(request):
print "edit full"
user_profile = request.user.user_profile
saved = False
new_address_parts = {
'city': False,
'address': False
}
if request.method == 'POST':
print "Request method is PPOST"
form = FullAddressForm(request.POST)
if form.is_valid():
print "Form is valid"
# Address : address and city
city_data = {
'name': form.cleaned_data['city'],
'zipcode': form.cleaned_data['zipcode'],
'country': form.cleaned_data['country']
}
# Check if we can get this city
# If the city doesn't exist, we try to create it, but data may be incomplete
try:
city = City.objects.get(**city_data)
except ObjectDoesNotExist:
try:
city = CityForm(data=city_data).save()
if city is not None:
new_address_parts['city'] = True
new_address_parts['city_name'] = city.__str__()
except ValueError:
city = None
if city is not None:
address_data = {
'num': form.cleaned_data['num'],
'street': form.cleaned_data['street'],
'city': city.pk,
}
try:
address = Address.objects.get(**address_data)
except ObjectDoesNotExist:
try:
address = AddressForm(data=address_data).save()
print "SAVe address"
new_address_parts['address'] = True
except ValueError:
address = None
else:
address = None
user_profile.address = address
user_profile.save()
saved = True
else:
return render(request, 'forms/self_edit/address.html',
{'form': form})
init_data = {}
if user_profile.address is not None:
user_address = Address.objects.get(pk=user_profile.address.pk)
user_city = City.objects.get(pk=user_address.city.pk)
init_data.update({
'num': user_address.num,
'street': user_address.street,
'city': user_city.name,
'zipcode': user_city.zipcode,
'country': user_city.country,
})
return render(request, 'forms/self_edit/address.html',
{
'form': FullAddressForm(initial=init_data),
'notice_saved': saved,
'new_address_parts': new_address_parts
})
else:
return render(request, 'forms/self_edit/address.html',
{
'form': FullAddressForm(),
'notice_saved': False
})
def lists():
form = AddressForm()
return render_template("lists.html",
form=form)
