def add_listing():
(plongitude,
platitude) = geocode(request.vars.food_location + ', United States')
logger.info(platitude)
logger.info(plongitude)
# if user is logged in, insert their profile picture into the listing. Otherwise, don't
if auth.user is not None:
t_id = db.checklist.insert(
driver_name=request.vars.driver_name,
post=request.vars.post,
category=request.vars.category,
profile_picture_url=auth.user.profile_picture,
venmo_QR_url=auth.user.VenmoQR,
food_location=request.vars.food_location,
fee=request.vars.fee,
longitude=plongitude,
latitude=platitude,
)
else:
t_id = db.checklist.insert(
driver_name=request.vars.driver_name,
post=request.vars.post,
category=request.vars.category,
food_location=request.vars.food_location,
)
t = db.checklist(t_id)
return response.json(dict(title=t))
def createEvent():
form = SQLFORM(db.aevent)
address = request.post_vars.address
(latitude, longitude) = geocode(address)
form.vars.lat = latitude
form.vars.lng = longitude
if form.process().accepted:
redirect(URL('Events_Around_you'))
return locals()
def locations():
location_list = db(db.locations).select()
location_picture_array = db(db.location_images).select()
delivery_member_array = db(db.delivery_profile).select()
location_tag_list = []
location_picture_list = []
for location in location_list:
location_tag_list.append(db(db.location_tag.location_id == location['id']).select())
location_picture_list.append(db(db.location_images.location_id == location['id']).select())
location_tag_list_array = []
for tag_list in location_tag_list:
for tag in tag_list:
location_tag_list_array.append(tag['tag'])
set_location_tag_list = set(location_tag_list_array)
tag_location_list_unsorted = list(set_location_tag_list)
combined_count_and_tag_array=[]
for tag in tag_location_list_unsorted:
combined_count_and_tag_array.append([tag, location_tag_list_array.count(tag)])
from operator import itemgetter
tag_location_list_sorted_by_total_count = sorted(combined_count_and_tag_array, key=itemgetter(1))
from gluon.tools import geocode
lat_lng_array = []
location_array = []
for location in location_list:
(latitude, longitude) = geocode(location['complete_address'])
lat_lng_array.append([latitude, longitude, location['name']])
location_image=db(db.location_images.location_id == location['id']).select()
location_tag=db(db.location_tag.location_id == location['id']).select()
if location_image:
location_array.append([location,location_image,location_tag])
else:
location_array.append([location,"null",location_tag])
return dict(
lat_lng_array=lat_lng_array,
location_list=location_list,
location_picture_array=location_picture_array,
location_array=location_array,
tag_location_list_sorted_by_total_count=tag_location_list_sorted_by_total_count,
delivery_member_array=delivery_member_array,
)
def index():
from gluon.tools import geocode
latitude = longtitude = ''
form=SQLFORM.factory(Field('search'), _class='form-search')
form.custom.widget.search['_class'] = 'input-long search-query'
form.custom.submit['_value'] = 'Search'
form.custom.submit['_class'] = 'btn'
if form.accepts(request):
address=form.vars.search
(latitude, longitude) = geocode(address)
else:
(latitude, longitude) = ('','')
return dict(form=form, latitude=latitude, longitude=longitude)
def index():
from gluon.tools import geocode
latitude = longtitude = ''
form = SQLFORM.factory(Field('search'), _class='form-search')
form.custom.widget.search['_class'] = 'input-long search-query'
form.custom.submit['_value'] = 'Search'
form.custom.submit['_class'] = 'btn'
if form.accepts(request):
address = form.vars.search
(latitude, longitude) = geocode(address)
else:
(latitude, longitude) = ('', '')
return dict(form=form, latitude=latitude, longitude=longitude)
def nearby_stylists():
city = request.args(0)
state = request.args(1)
stylists = db(db.t_stylists.state_acronym == str(state)).select()
near_stylists = []
pics = []
address = str(city) + ", " + str(state) + ", " + "USA"
(lat, long) = geocode(address)
# function that computes distance between two (lat, long) points
def distance_on_unit_sphere(lat1, long1, lat2, long2):
degrees_to_radians = math.pi / 180.0
phi1 = (90.0 - lat1) * degrees_to_radians
phi2 = (90.0 - lat2) * degrees_to_radians
theta1 = long1 * degrees_to_radians
theta2 = long2 * degrees_to_radians
cos = math.sin(phi1) * math.sin(phi2) * math.cos(theta1 - theta2) + math.cos(phi1) * math.cos(phi2)
arc = math.acos(cos)
return arc * 3960
# get all stylists that are within 10 miles
for stylist in stylists:
stylist_address = str(stylist.city) + ", " + str(stylist.state_acronym) + ", " + "USA"
(lat_stylist, long_stylist) = geocode(stylist_address)
distance = distance_on_unit_sphere(lat, long, lat_stylist, long_stylist)
if distance < 15.0:
near_stylists.append(stylist)
# get profile pic of each stylist in near_stylists
for stylist in near_stylists:
images = db(db.t_profile_pics.stylist_id == stylist.user_id).select(orderby=~db.t_profile_pics.post_date)
image = images[0]
pics.append(image)
return dict(stylists=near_stylists, pics=pics)
def mymap():
#rows=db(db.register.name==auth.user.id)(db.register.f_start_time>=request.now).select()
#return dict(rows=rows)
from gluon.tools import geocode
latitude = longtitude = ''
form=SQLFORM.factory(Field('search'), _class='form-search')
form.custom.widget.search['_class'] = 'input-long search-query'
form.custom.submit['_value'] = 'Search'
form.custom.submit['_class'] = 'btn'
if form.accepts(request):
address=form.vars.search
(latitude, longitude) = geocode(address)
else:
(latitude, longitude) = ('','')
return dict(form=form, latitude=latitude, longitude=longitude)
def googleMap():
""" Uses google maps to get most accurate coordinates for scavenger sessions """
""" This was moved to clue_EDIT as that is where the coordinates functionality """
""" is needed most. If you want to re-use, re-add to the menu in model/menu.py file """
from gluon.tools import geocode
latitude = longtitude = ''
form=SQLFORM.factory(Field('search'), _class='form-search')
form.custom.widget.search['_class'] = 'input-long search-query'
form.custom.submit['_value'] = 'Search'
form.custom.submit['_class'] = 'btn'
if form.accepts(request):
address=form.vars.search
(latitude, longitude) = geocode(address)
else:
(latitude, longitude) = ('','')
return dict(form=form, latitude=latitude, longitude=longitude)
def discover():
from gluon.tools import fetch
from gluon.tools import geocode
address = '310 Mcmasters Street, Chapel Hill, NC, USA'
(latitude, longitude) = geocode(address)
url = 'http://openstates.org/api/v1//legislators/geo/?lat=' + str(latitude) + '&long=' + str(longitude) + '&apikey=c16a6c623ee54948bac2a010ea6fab70'
url1 = 'http://congress.api.sunlightfoundation.com//legislators/locate?latitude=' + str(latitude) + '&longitude=' + str(longitude) + '&apikey=c16a6c623ee54948bac2a010ea6fab70'
page = fetch(url)
page1 = fetch(url)
import gluon
data_list = gluon.contrib.simplejson.loads(page)
data_list1 = gluon.contrib.simplejson.loads(page)
return dict(data_list=data_list,data_list1=data_list1,)
def index():
"""
example action using the internationalization operator T and flash
rendered by views/default/index.html or views/generic.html
if you need a simple wiki simply replace the two lines below with:
return auth.wiki()
"""
profiles = db(db.auth_user).select()
#blank_list = request.vars['blank_profiles[]']
#if blank_list is None:
# blank_list = []
#elif type(blank_list) is str:
# blank_list = [blank_list]
#rows = db(~db.profile.profile_id.belongs(blank_list)).select(db.profile.ALL, orderby=~db.profile.created_on)
d =[]
for r in profiles:
location = geocode(r.Address)
d = d + [{'profile_Fname': r.first_name,'profile_Lname': r.last_name, 'profile_address': r.Address, 'profile_car': r.Own_a_Car, 'profile_driving_experience':r.Driving_Experience, 'profile_pic':r.Profile_pic, 'lat': location[0], 'lng': location[1]}]
return dict(profile_dict=json(d),add_dict=profiles)
def search():
from gluon.tools import geocode
search_form=SQLFORM(db.member_search)
if search_form.process(session=None, formname='search_form').accepted:
#session.flash = 'results'
redirect(URL('search'))
elif search_form.errors:
response.flash = 'Error'
selected_locations = db(db.locations.id==1).select(db.locations.ALL)
search_form_member_location = request.args(0)
search_form_radius = request.args(1)
search_form_details = request.args(2)
location_list = db(db.locations).select()
location_array = []
for location in location_list:
(latitude, longitude) = geocode(location['complete_address'])
lat_lng_array.append([latitude, longitude, location['name']])
location_image=db(db.location_images.location_id == location['id']).select()
location_tag=db(db.location_tag.location_id == location['id']).select()
location_item=db(db.location_item.location_id == location['id']).select()
if location_image:
location_array.append([location,location_image,location_tag,location_item])
else:
location_array.append([location,"null",location_tag,location_item])
return dict(
search_form=search_form,
selected_locations=selected_locations,
search_form_member_location=search_form_member_location,
search_form_radius=search_form_radius,
search_form_details=search_form_details,
location_array=location_array,
lat_lng_array=lat_lng_array,
)
def log():
#Carrega mapa JS
from gluon.tools import geocode
id_cliente = request.vars.id
lista=[]
end = Cliente[id_cliente].endereco
num = Cliente[id_cliente].numero
cid = Cliente[id_cliente].cidade
local = geocode("%s, %s, %s" %(end,num, cid) )
if local[0] != '':
lat = local[0]
lista.append(lat)
print lat
if local[1] != '':
lon = local[1]
lista.append(lon)
print lon
return response.json(lista)
def clue_CREATE():
""" Clue creation """
from gluon.tools import geocode
clueCreate = SQLFORM(db.clue)
if clueCreate.process().accepted:
redirect(URL(r=request, f='hunt_admin'))
elif clueCreate.errors:
response.flash = 'form has errors'
latitude = longtitude = ''
form=SQLFORM.factory(Field('search'), _class='form-search')
form.custom.widget.search['_class'] = 'input-long search-query'
form.custom.submit['_value'] = 'Search'
form.custom.submit['_class'] = 'btn'
if form.accepts(request):
address=form.vars.search
(latitude, longitude) = geocode(address)
else:
(latitude, longitude) = ('','')
return dict(form=form, latitude=latitude, longitude=longitude,
clueCreate = clueCreate)
def bar():
from gluon.tools import geocode
bar_id = None
if request.args(0):
bar_id = request.args(0)
else:
redirect(URL('bars'))
bar_info = db(db.bar.id == bar_id).select().first()
if not bar_info:
redirect(URL('index'))
(latitude, longitude) = geocode(bar_info.address)
taps= db(db.bar_beers.bar == bar_id).select()
mgr=False
mgr_set=None
if auth.user:
mgr_set=db((db.bar_mgrs.mgr ==auth.user.id)&(db.bar_mgrs.bar==bar_id)).select()
if mgr_set:
mgr=True
beer_rows=None
dbug=''
add_beer_form = SQLFORM.factory(Field('brewery', 'string'))
if add_beer_form.process().accepted:
brewery_var=request.vars.brewery
beer_rows = db(db.beer.brewery.contains(brewery_var, case_sensitive=False)).select()
if not beer_rows:
response.flash="No breweries with that name found"
return locals()
dbug=BEAUTIFY(request.vars)
return locals()
def clue_EDIT():
""" Edit page for selected clue """
from gluon.tools import geocode
selectedClue = db.clue(request.args(0))
clueForm = SQLFORM(db.clue, selectedClue, deletable=True, showid=False)
if clueForm.process().accepted:
redirect(URL(r=request, f='hunt_admin'))
elif clueForm.errors:
response.flash = 'Edit Failure'
latitude = longtitude = ''
form=SQLFORM.factory(Field('search'), _class='form-search')
form.custom.widget.search['_class'] = 'input-long search-query'
form.custom.submit['_value'] = 'Search'
form.custom.submit['_class'] = 'btn'
if form.accepts(request):
address=form.vars.search
(latitude, longitude) = geocode(address)
else:
(latitude, longitude) = ('','')
return dict(form=form, latitude=latitude, longitude=longitude,
clueForm = clueForm)
def location():
location_from_url = db(db.locations.url_title==request.args(0)).select()
id_from_url = db(db.locations.url_title==request.args(0)).select(db.locations.id)[0]['id']
item_array = db(db.location_item.location_id==id_from_url).select()
item_array = db(db.location_item.location_id==id_from_url).select()
form_rate_location = SQLFORM(db.ratings)
if form_rate_location.process(formname='form_rate_location', onvalidation=__onvalidation_rating).accepted:
session.flash = 'Location Rated'
redirect(URL('location/' + request.args(0)))
elif form_rate_location.errors:
response.flash = 'Error'
location_rating_array=db((db.ratings.ratee_id==id_from_url) & (db.ratings.ratee_type=='location')).select()
from gluon.tools import geocode
lat_lng_array_location = []
lat_lng_array_member = []
(latitude, longitude) = geocode(location_from_url[0]['complete_address'])
lat_lng_array_location.append((latitude, longitude, location_from_url[0]['name'], location_from_url[0]['name'], location_from_url[0]['description'], 0))
####find near_by delivery drivers, need to restict to active. na meen yeah
import math
(lat1, long1) = geocode(location_from_url[0]['complete_address'])
location_from_member = db(db.delivery_profile).select()
distance_meter_array = []
for location in location_from_member:
(lat2, long2) = geocode(location['current_location'])
degrees_to_radians = math.pi / 180.0
phi1 = (90.0 - lat1) * degrees_to_radians
phi2 = (90.0 - lat2) * degrees_to_radians
theta1 = long1 * degrees_to_radians
theta2 = long2 * degrees_to_radians
cos = (math.sin(phi1) * math.sin(phi2) * math.cos(theta1 - theta2) + math.cos(phi1) * math.cos(phi2))
distance_in_meters = math.acos(cos) * 6378100
distance_meter_array.append([float(location['delivery_radius']) - distance_in_meters, float(location['max_radius_from_home']) - distance_in_meters, location])
available_member_array = []
for element in distance_meter_array:
if element[0] > 0:
if element[1] > 0:
available_member_array.append(element[2])
(lat2, long2) = geocode(element[2]['current_location'])
username = db(db.auth_user.id == element[2]['user_id']).select()[0]['username']
member_images = db(db.member_images.user_id == element[2]['user_id']).select()
lat_lng_array_member.append((lat2, long2, element[2]['current_location'], element[2]['current_location'], username, element[2]['delivery_radius'],member_images))
location_picture_array = db(db.location_images.location_id == id_from_url).select()
items_from_location = db(db.location_item.location_id == id_from_url).select()
#member_orders_from_location = db((db.member_orders.location_id == id_from_url) & (db.member_orders.member_id == auth.user_id)).select()
member_orders_from_location = db(db.member_orders.location_id == id_from_url).select()
hours_of_operation = db(db.location_hours.location_id == id_from_url).select()
return dict(
location_picture_array=location_picture_array,
available_member_array=available_member_array,
distance_meter_array=distance_meter_array,
location_from_url=location_from_url,
id_from_url=id_from_url,
lat_lng_array_member=lat_lng_array_member,
lat_lng_array_location=lat_lng_array_location,
items_from_location=items_from_location,
member_orders_from_location=member_orders_from_location,
hours_of_operation=hours_of_operation,
)
def index():
from gluon.tools import geocode
import random
#make function to go to nice long / lat
latitude = longtitude = ''
if session.auth is None:
complete_address_array = ''
delivery_member_array = []
current_location_array = [r.current_location for r in db(db.delivery_profile).select(db.delivery_profile.current_location)]
for location in current_location_array:
delivery_profile_info = db(db.delivery_profile.current_location==location).select(db.delivery_profile.ALL).as_list()
user_id_at_location = db(db.delivery_profile.current_location==location).select(db.delivery_profile.user_id).as_list()[0]['user_id']
delivery_profile_pictures_array = [r.picture for r in db(db.member_images.user_id==user_id_at_location).select(db.member_images.picture)]
delivery_profile_username = db(db.auth_user.id==user_id_at_location).select(db.auth_user.username).as_list()[0]['username']
(latitude, longitude) = geocode(location)
delivery_member_array.append((latitude, longitude, location, delivery_profile_pictures_array, delivery_profile_username))
else:
complete_address_array = [r.complete_address for r in db(db.member_locations.user_id==session.auth.user.id).select(db.member_locations.complete_address)]
description_array = [r.description for r in db(db.member_locations.user_id==session.auth.user.id).select(db.member_locations.description)]
delivery_member_array = []
current_location_array = [r.current_location for r in db(db.delivery_profile).select(db.delivery_profile.current_location)]
for location in current_location_array:
delivery_profile_info = db(db.delivery_profile.current_location==location).select(db.delivery_profile.ALL).as_list()
user_id_at_location = db(db.delivery_profile.current_location==location).select(db.delivery_profile.user_id).as_list()[0]['user_id']
delivery_profile_pictures_array = [r.picture for r in db(db.member_images.user_id==user_id_at_location).select(db.member_images.picture)]
delivery_profile_username = db(db.auth_user.id==user_id_at_location).select(db.auth_user.username).as_list()[0]['username']
(latitude, longitude) = geocode(location)
delivery_member_array.append((latitude, longitude, location, delivery_profile_pictures_array, delivery_profile_username))
search_form=SQLFORM(db.member_search)
if search_form.process(session=None, formname='test').accepted:
session.search_form_member_locations = search_form.vars.member_locations
session.search_form_radius = search_form.vars.radius
session.search_form_details = search_form.vars.details
redirect(URL('search/' + search_form.vars.member_locations + '/' + search_form.vars.radius + 'mi/' + search_form.vars.details))
elif search_form.errors:
response.flash = 'There\'s a problem!'
session.flash = 'welcome to deliveryfor!'
member_picture_array = db(db.member_images).select()
location_list = db(db.locations).select()
location_array = []
location_image_array=[]
location_tag_list = []
for location in location_list:
location_image=db(db.location_images.location_id == location['id']).select()
location_tag_list.append(db(db.location_tag.location_id == location['id']).select())
location_tag=db(db.location_tag.location_id == location['id']).select()
if location_image:
location_array.append([location,location_image,location_tag])
location_tag_list_array = []
for tag_list in location_tag_list:
for tag in tag_list:
location_tag_list_array.append(tag['tag'])
item_list = db(db.location_item).select()
set_location_tag_list = set(location_tag_list_array)
tag_location_list_unsorted = list(set_location_tag_list)
combined_count_and_tag_array=[]
for tag in tag_location_list_unsorted:
combined_count_and_tag_array.append([tag, location_tag_list_array.count(tag)])
from operator import itemgetter
tag_location_list_sorted_by_total_count = sorted(combined_count_and_tag_array, key=itemgetter(1))
index_block_list = db(db.html_block.html_type == 'index').select().as_list()
random.shuffle(index_block_list)
index_header_block_list = db(db.html_block.html_type == 'index-header').select().as_list()
random.shuffle(index_header_block_list)
index_header_block_list = index_header_block_list[0]['html_content']
item_tag_list = []
for item in item_list:
item_tag_list.append(db(db.location_item_tag.location_item_id == item['id']).select())
item_tag=db(db.location_item_tag.location_item_id == item['id']).select()
item_tag_list_array = []
for tag_list in item_tag_list:
for tag in tag_list:
item_tag_list_array.append(tag['tag'])
set_item_tag_list = set(item_tag_list_array)
tag_item_list_unsorted = list(set_item_tag_list)
combined_count_and_tag_array=[]
for tag in tag_item_list_unsorted:
combined_count_and_tag_array.append([tag, item_tag_list_array.count(tag)])
from operator import itemgetter
tag_item_list_sorted_by_total_count = sorted(combined_count_and_tag_array, key=itemgetter(1))
#for location in location_list:
#location_tag_list.append(db(db.location_tag.location_id == location['id']).select())
#location_picture_list.append(db(db.location_images.location_id == location['id']).select())
return dict(
tag_location_list_sorted_by_total_count=tag_location_list_sorted_by_total_count,
tag_item_list_sorted_by_total_count=tag_item_list_sorted_by_total_count,
index_header_block_list=index_header_block_list,
delivery_member_array=delivery_member_array,
search_form=search_form,
at_lng_array = lat_lng_array,
member_picture_array=member_picture_array,
location_array=location_array,
index_block_list=index_block_list,
item_list=item_list,
)
def account():
if session.auth is None:
redirect(URL(''))
else:
address_array = [r.address for r in db(db.member_locations.user_id==session.auth.user.id).select(db.member_locations.address)]
description_array = [r.description for r in db(db.member_locations.user_id==session.auth.user.id).select(db.member_locations.description)]
complete_address_array = [r.complete_address for r in db(db.member_locations.user_id==session.auth.user.id).select(db.member_locations.complete_address)]
location_id_array = [r.id for r in db(db.member_locations.user_id==session.auth.user.id).select(db.member_locations.id)]
start_availability_array = [r.start_availability for r in db(db.member_availability.user_id==session.auth.user.id).select(db.member_availability.start_availability)]
end_availability_array = [r.end_availability for r in db(db.member_availability.user_id==session.auth.user.id).select(db.member_availability.end_availability)]
availability_id_array = [r.id for r in db(db.member_availability.user_id==session.auth.user.id).select(db.member_availability.id)]
member_picture_array = [r.picture for r in db(db.member_images.user_id==session.auth.user.id).select(db.member_images.picture)]
member_picture_id_array = [r.id for r in db(db.member_images.user_id==session.auth.user.id).select(db.member_images.id)]
flat_rate_array = [r.flat_rate for r in db(db.member_fees.user_id==session.auth.user.id).select(db.member_fees.flat_rate)]
percentage_array = [r.percentage for r in db(db.member_fees.user_id==session.auth.user.id).select(db.member_fees.percentage)]
per_distance_array = [r.per_distance for r in db(db.member_fees.user_id==session.auth.user.id).select(db.member_fees.per_distance)]
per_hour_array = [r.per_hour for r in db(db.member_fees.user_id==session.auth.user.id).select(db.member_fees.per_hour)]
min_amount_array = [r.min_amount for r in db(db.member_fees.user_id==session.auth.user.id).select(db.member_fees.min_amount)]
max_amount_array = [r.max_amount for r in db(db.member_fees.user_id==session.auth.user.id).select(db.member_fees.max_amount)]
is_active_array = [r.is_active for r in db(db.member_fees.user_id==session.auth.user.id).select(db.member_fees.is_active)]
member_currency = [r.member_currency for r in db(db.member_fees.user_id==session.auth.user.id).select(db.member_fees.member_currency)]
member_units = [r.member_units for r in db(db.member_fees.user_id==session.auth.user.id).select(db.member_fees.member_units)]
fee_id_array = [r.id for r in db(db.member_fees.user_id==session.auth.user.id).select(db.member_fees.id)]
fee_title_array = [r.title for r in db(db.member_fees.user_id==session.auth.user.id).select(db.member_fees.title)]
complete_fee_array=[fee_id_array, flat_rate_array, percentage_array, per_distance_array, per_hour_array, min_amount_array, max_amount_array, is_active_array, member_currency, member_units, fee_title_array]
delivery_profile_id = db(db.delivery_profile.user_id==session.auth.user.id).select()
from gluon.tools import geocode
for thecounter, complete_address in enumerate(complete_address_array):
(latitude, longitude) = geocode(complete_address)
lat_lng_array.append((latitude, longitude, complete_address, description_array[thecounter], description_array[thecounter]))
#new location form
form_newlocation = SQLFORM(db.member_locations, col3 = {'special_instructions':A('[?]',
_href='http://www.google.com/search?q=define:address')})
if form_newlocation.process(formname='member_locations').accepted:
session.flash = 'Location Added'
redirect(URL('/account'))
elif form_newlocation.errors:
response.flash = 'Error'
#location edit / delete forms
form_location_edit_array = []
for counter, x in enumerate(location_id_array):
form_location_edit_array.append(SQLFORM(db.member_locations, x, deletable=True, submit_button = 'Save Location', showid = False))
if form_location_edit_array[counter].process(formname='form_location_edit_array-' + str(counter)).accepted:
response.flash = 'Location Updated'
redirect(URL('/account'))
elif form_location_edit_array[counter].errors:
response.flash = 'Error'
member_settings_id = db(db.member_settings.user_id==session.auth.user.id).select()
if member_settings_id:
hi=''
else:
db.member_settings.insert(member_language="English", member_currency="$ USD", member_units="Imperial")
member_settings_record = db(db.member_settings.user_id==session.auth.user.id).select(db.member_settings.id)[0]['id']
form_member_settings_general = SQLFORM(db.member_settings, member_settings_record, fields = ['member_language', 'member_currency', 'member_units'], separator = ' ', submit_button = 'Save profile', showid = False, labels = {'member_language':P('Language' ,_class='head'), 'member_currency':P('Currency', _class='head'), 'member_units':P('Units', _class='head')})
if form_member_settings_general.process(formname='form_member_settings_general').accepted:
session.flash = 'Settings Updated'
redirect(URL('/account'))
elif form_member_settings_general.errors:
response.flash = 'Error'
form_member_settings_notifications = SQLFORM(db.member_settings, member_settings_record, formstyle = 'divs', fields = ['member_accepts_email', 'member_phone_number'], submit_button = 'Save profile', showid = False, separator = ' ', labels = {'member_accepts_email':'', 'member_phone_number':P('Send text updates to this number', _class='head')}, col3 = {'member_accepts_email':P('Recieve news and update emails from deliveryfor', _class='head', _style="margin-left:5px;margin-top:20px;")})
if form_member_settings_notifications.process(formname='form_member_settings_notifications').accepted:
session.flash = 'Settings Updated'
redirect(URL('/account'))
elif form_member_settings_notifications.errors:
response.flash = 'Error'
form_create_delivery_profile = SQLFORM(db.delivery_profile)
terms = TR(LABEL('I agree to the terms and conditions'), INPUT(_name='agree',value=True,_type='checkbox'))
form_create_delivery_profile[0].insert(-1,terms)
if form_create_delivery_profile.process(formname='create_delivery_profile').accepted:
session.flash = 'Profile Created'
redirect(URL('/account'))
elif form_create_delivery_profile.errors:
response.flash = 'Error'
if delivery_profile_id:
delivery_profile_record = db(db.delivery_profile.user_id==session.auth.user.id).select(db.delivery_profile.id)[0]['id']
form_delivery_profile_update=SQLFORM(db.delivery_profile, delivery_profile_record, submit_button = 'Save profile', showid = False)
if form_delivery_profile_update.process(formname='form_delivery_profile_update').accepted:
session.flash = 'Profile Updated'
redirect(URL('/member/'+session.auth.user.username))
elif form_delivery_profile_update.errors:
response.flash = 'Error'
else:
form_delivery_profile_update=''
form_upload_member_images = SQLFORM(db.member_images)
if form_upload_member_images.process(formname='form_member_images').accepted:
session.flash = 'Image Uploaded'
redirect(URL('/account'))
elif form_upload_member_images.errors:
response.flash = 'Error'
form_edit_member_picture_array = []
for counter, x in enumerate(member_picture_id_array):
form_edit_member_picture_array.append(SQLFORM(db.member_images, x, deletable=True, submit_button = 'Save Picture', showid = False))
if form_edit_member_picture_array[counter].process(formname='form_edit_member_picture_array-' + str(counter)).accepted:
session.flash = 'Image Updated'
redirect(URL('/account'))
elif form_edit_member_picture_array[counter].errors:
response.flash = 'Error'
form_create_member_availability = SQLFORM(db.member_availability)
if form_create_member_availability.process(formname='form_create_member_availability', onvalidation=__onvalidation_availability).accepted:
session.flash = 'Availability Added'
redirect(URL('/account'))
elif form_create_member_availability.errors:
response.flash = 'Error'
form_edit_member_availability_array = []
for counter, x in enumerate(availability_id_array):
form_edit_member_availability_array.append(SQLFORM(db.member_availability, x, deletable=True, submit_button = 'Save Availability', showid = False))
if form_edit_member_availability_array[counter].process(formname='form_edit_member_availability_array-' + str(counter), onvalidation=__onvalidation_availability).accepted:
session.flash = 'Availability Updated'
redirect(URL('/account'))
elif form_edit_member_availability_array[counter].errors:
response.flash = 'Error'
form_create_member_fee = SQLFORM(db.member_fees)
if form_create_member_fee.process(formname='form_create_member_fee').accepted:
session.flash = 'Fee Added'
redirect(URL('/account'))
elif form_create_member_fee.errors:
response.flash = 'Error'
form_edit_member_fee_array = []
for counter, x in enumerate(fee_id_array):
form_edit_member_fee_array.append(SQLFORM(db.member_fees, x, deletable=True, submit_button = 'Save Fee', showid = False))
if form_edit_member_fee_array[counter].process(formname='form_edit_member_fee_array-' + str(counter)).accepted:
session.flash = 'Fee Updated'
redirect(URL('/account'))
elif form_edit_member_fee_array[counter].errors:
response.flash = 'Error'
edit_member_information=SQLFORM(db.auth_user, auth.user_id, fields = ['first_name','last_name','email', 'username'], submit_button = 'save profile', showid = False)
return dict(
form_member_settings_notifications=form_member_settings_notifications,
form_member_settings_general=form_member_settings_general,
edit_member_information=edit_member_information,
form_edit_member_picture_array=form_edit_member_picture_array,
member_picture_array=member_picture_array,
delivery_profile_id=delivery_profile_id,
form_edit_member_fee_array=form_edit_member_fee_array,
fee_id_array=fee_id_array,
complete_fee_array=complete_fee_array,
start_availability_array=start_availability_array,
end_availability_array=end_availability_array,
availability_id_array=availability_id_array,
form_edit_member_availability_array=form_edit_member_availability_array,
form_create_member_fee=form_create_member_fee,
form_create_member_availability=form_create_member_availability,
form_upload_member_images = form_upload_member_images,
form_location_edit_array=form_location_edit_array,
form_delivery_profile_update=form_delivery_profile_update,
form_create_delivery_profile=form_create_delivery_profile,
form_newlocation=form_newlocation,
location_id_array=location_id_array,
address_array = address_array,
description_array = description_array,
complete_address_array = complete_address_array,
lat_lng_array = lat_lng_array,
)
def process_geolocation(form):
if form.vars.latitude is None and form.vars.address is not None:
form.vars.latitude, form.vars.longitude = geocode(form.vars.address)
if end_availability - datetime.datetime.now() < datetime.timedelta(days=0):
msg.append('this availibility has expired')
#db(db.user_availability.user_id==session.auth.user.id).update(end_availability=datetime.datetime.now(),start_availability=datetime.datetime.now(), is_available='false')
else:
msg.append('this availibility is active')
#db(db.user_availability.user_id==session.auth.user.id).update(is_available='true')
#if session is notalready scanned
#if is in active database
delivery_location = db(db.delivery_profile.user_id==session.auth.user.id).select(db.delivery_profile.current_location)[0]['current_location']
from gluon.tools import geocode
(latitude, longitude) = geocode(delivery_location)
session.has_scanned = 'false'
#####scan when a delivery driver becomes is active
if session.has_scanned == 'false':
session.has_scanned = 'true'
import gluon.contrib.simplejson
from gluon.tools import fetch
lat = latitude
lng = longitude
radius = 5000
places_url = fetch("https://maps.googleapis.com/maps/api/place/nearbysearch/json?location=" + str(lat) + "," + str(lng) + "&radius=" + str(radius) + "&sensor=false&key=AIzaSyCGdFtkeR8egXJvte3eLH3deLKXXmPuXlA")
locations_in_radius = gluon.contrib.simplejson.loads(places_url)
results_array = locations_in_radius['results']
def geocode2(form):
from gluon.tools import geocode
lo,la= geocode(form.vars.f_location+' USA')
form.vars.f_latitude=la
form.vars.f_longitude=lo
Field('booked_on', 'datetime'))
db.define_table('restaurant_order',
Field('user_id', 'reference auth_user'),
Field('item', 'reference item'),
Field('refill', 'boolean', default=False),
Field('quantity', 'integer', default=1),
Field('restaurant_table', 'reference restaurant_table'),
Field('ordered_on', 'datetime'))
db.define_table('bill',
Field('restaurant_table', 'reference restaurant_table'),
Field('restaurant_order', 'list:reference order'),
Field('billed_on', 'datetime'),
Field('total_bill', 'double'))
db.define_table('restaurant',
Field('name'),
Field('address'),
Field('latitude',
compute=lambda r: geocode(r.address)[0]),
Field('longitude',
compute=lambda r: geocode(r.address)[1]),
Field('phone'),
Field('url'),
Field('menu', 'reference menu'),
Field('images', 'list:reference restaurant_images'),
format='%(latitude; longitude)s')
session.connect(request, response, db)
def member():
if session.auth is None:
delivery_profile_id=''
else:
delivery_profile_id = db(db.delivery_profile.user_id==session.auth.user.id).select()
id_from_username = db(db.auth_user.username==request.args(0)).select(db.auth_user.id)[0]['id']
current_location = db(db.delivery_profile.user_id==id_from_username).select(db.delivery_profile.current_location)[0]['current_location']
profile_firstname = db(db.auth_user.id==id_from_username).select(db.auth_user.first_name).as_list()[0]['first_name']
profile_lastname = db(db.auth_user.id==id_from_username).select(db.auth_user.last_name)[0]['last_name']
start_availability_array = [r.start_availability for r in db(db.member_availability.user_id==id_from_username).select(db.member_availability.start_availability)]
end_availability_array = [r.end_availability for r in db(db.member_availability.user_id==id_from_username).select(db.member_availability.end_availability)]
availability_id_array = [r.id for r in db(db.member_availability.user_id==id_from_username).select(db.member_availability.id)]
member_picture_array = [r.picture for r in db(db.member_images.user_id==id_from_username).select(db.member_images.picture)]
flat_rate_array = [r.flat_rate for r in db(db.member_fees.user_id==id_from_username).select(db.member_fees.flat_rate)]
percentage_array = [r.percentage for r in db(db.member_fees.user_id==id_from_username).select(db.member_fees.percentage)]
per_distance_array = [r.per_distance for r in db(db.member_fees.user_id==id_from_username).select(db.member_fees.per_distance)]
per_hour_array = [r.per_hour for r in db(db.member_fees.user_id==id_from_username).select(db.member_fees.per_hour)]
min_amount_array = [r.min_amount for r in db(db.member_fees.user_id==id_from_username).select(db.member_fees.min_amount)]
max_amount_array = [r.max_amount for r in db(db.member_fees.user_id==id_from_username).select(db.member_fees.max_amount)]
is_active_array = [r.is_active for r in db(db.member_fees.user_id==id_from_username).select(db.member_fees.is_active)]
member_currency = [r.member_currency for r in db(db.member_fees.user_id==id_from_username).select(db.member_fees.member_currency)]
member_units = [r.member_units for r in db(db.member_fees.user_id==id_from_username).select(db.member_fees.member_units)]
fee_id_array = [r.id for r in db(db.member_fees.user_id==id_from_username).select(db.member_fees.id)]
fee_title_array = [r.title for r in db(db.member_fees.user_id==id_from_username).select(db.member_fees.title)]
complete_fee_array=[fee_id_array, flat_rate_array, percentage_array, per_distance_array, per_hour_array, min_amount_array, max_amount_array, is_active_array, member_currency, member_units, fee_title_array]
location_rating_array=db((db.ratings.ratee_id==id_from_username) & (db.ratings.ratee_type=='member')).select()
about = db(db.delivery_profile.user_id==id_from_username).select(db.delivery_profile.about)[0]['about']
radius = db(db.delivery_profile.user_id==id_from_username).select(db.delivery_profile.delivery_radius)[0]['delivery_radius']
max_radius_from_home = db(db.delivery_profile.user_id==id_from_username).select(db.delivery_profile.delivery_radius)[0]['max_radius_from_home']
lat_lng_array_member = []
lat_lng_array_location = []
from gluon.tools import geocode
(latitude, longitude) = geocode(current_location)
delivery_username = db(db.auth_user.username==request.args(0)).select().as_list()[0]['username']
current_location_new = db(db.delivery_profile.user_id==id_from_username).select(db.delivery_profile.current_location).as_list()[0]['current_location']
lat_lng_array_member.append((latitude, longitude, current_location_new, member_picture_array, delivery_username, radius))
member_ratings = db(db.ratings.ratee_id==str(id_from_username)).select()
import math
(lat1, long1) = geocode(current_location)
location_list = db(db.locations).select()
distance_meter_array = []
for location in location_list:
(lat2, long2) = geocode(location['complete_address'])
degrees_to_radians = math.pi / 180.0
phi1 = (90.0 - lat1) * degrees_to_radians
phi2 = (90.0 - lat2) * degrees_to_radians
theta1 = long1 * degrees_to_radians
theta2 = long2 * degrees_to_radians
cos = (math.sin(phi1) * math.sin(phi2) * math.cos(theta1 - theta2) + math.cos(phi1) * math.cos(phi2))
distance_in_meters = math.acos(cos) * 6378100
distance_meter_array.append([float(radius) - distance_in_meters, float(max_radius_from_home) - distance_in_meters, location])
available_location_array = []
for element in distance_meter_array:
if element[0] > 0:
if element[1] > 0:
available_location_array.append(element[2])
(lat2, long2) = geocode(element[2]['complete_address'])
lat_lng_array_location.append((lat2, long2, element[2]['name'], element[2]['address'], element[2]['phone_number'], 0))
return dict(
location_rating_array=location_rating_array,
profile_firstname = profile_firstname,
profile_lastname = profile_lastname,
member_picture_array=member_picture_array,
complete_fee_array=complete_fee_array,
fee_id_array=fee_id_array,
start_availability_array=start_availability_array,
end_availability_array=end_availability_array,
availability_id_array=availability_id_array,
delivery_profile_id = delivery_profile_id,
lat_lng_array_member=lat_lng_array_member,
lat_lng_array_location=lat_lng_array_location,
current_location = current_location,
about = about,
id_from_username=id_from_username,
radius=radius,
member_ratings=member_ratings,
available_location_array=available_location_array,
)
def geo(form):
(form.vars.longitude,
form.vars.latitude) = geocode(form.vars.my_city + ', USA')
def geocode2(form):
from gluon.tools import geocode
lo, la = geocode(form.vars.f_location + ' USA')
form.vars.f_latitude = la
form.vars.f_longitude = lo
def edit_Landlord():
"""
This is the page to create / edit / delete a post.
"""
p = None
post_list = []
if request.args(0) is None:
# If argument zero in URL is empty then it must be a create form
form_type = 'create'
# Create form that enables insertion and name database table form refers to
form = SQLFORM(db.post_landlord)
# add cancel button
form.add_button('cancel', URL('default', 'index'))
else:
# URL is referencing specific post
# Check that post exists and if user is author of post
# first() used to get either first element or none instead of iterator
query = ((db.post_landlord.user_email == auth.user.email) &
(db.post_landlord.id == request.args(0)))
p = db(query).select().first()
if p is None:
session.flash = T('Not Authorized')
redirect(URL('default', 'index'))
# Post now confirmed to be valid
# Boolean to check user intent to edit, if not then just view
is_edit = (request.vars.edit == 'true')
form_type = 'edit' if is_edit else 'view'
# Extract post content
"""post_list = None
try:
post_list = json.loads(p.post)
except:
pass
if not isinstance(post_list, list):
# When try causes error, execute here
# If string in database then
if isinstance(p.post, basestring):
post_list = [p.post]
else:
post_list = []"""
form = SQLFORM(db.post_landlord,
record=p,
deletable=is_edit,
readonly=not is_edit,
writable=is_edit)
# add cancel button
form.add_button('cancel', URL('default', 'index'))
# Updates posts when edited
# p.post_content = form.vars.post_content
# Update created_on and updated_on date
# Take time stamp of when post created only once, no need to update
# p.created_on = datetime.datetime.utcnow()
p.updatedon = datetime.datetime.utcnow()
# Updates actual database
p.update_record()
# Add necessary buttons for each user action
button_list = []
if form_type == 'edit':
button_list.append(
A('Cancel',
_class='btn btn-warning',
_href=URL('default', 'index')))
elif form_type == 'create':
button_list.append(
A('Cancel',
_class='btn btn-warning',
_href=URL('default', 'index')))
elif form_type == 'view':
button_list.append(
A('Edit',
_class='btn btn-warning',
_href=URL('default', 'edit', args=[p.id],
vars=dict(edit='true'))))
button_list.append(
A('Back', _class='btn btn-primary', _href=URL('default', 'index')))
if form.process().accepted:
# Post already validated and posted at this point
# Update and insert record
if form_type == 'create':
session.flash = T('Post created!')
else:
session.flash = T('Content saved')
p.my_address = form.vars.my_address
p.my_city = form.vars.my_city
p.my_state = form.vars.my_state
p.rent = form.vars.rent
p.sq_ft = form.vars.sq_ft
p.num_bed = form.vars.num_bed
p.num_bath = form.vars.num_bath
p.washdry = form.vars.washdry
p.furnish = form.vars.furnish
p.pets = form.vars.pets
p.more_info = form.vars.more_info
p.picture = form.vars.picture
p.longitude = ""
p.latitude = ""
(p.longitude,
p.latitude) = geocode(form.vars.my_address + form.vars.my_city +
form.vars.my_state + ', United States')
p.updatedon = datetime.datetime.utcnow()
p.update_record()
redirect(URL('default', 'index'))
elif form.errors:
(form.vars.longitude, form.vars.latitude) = ('', '')
session.flash = T('Get it right this time')
# return dict(form=form, button_list=button_list, p=p, form_type=form_type, post_list=post_list)
return dict(form=form)
