def get_orders_map_data(request):
offset = int(request.GET.get("offset", 0))
batch_size = int(request.GET.get("batch_size", 500))
request_type = request.GET.get("type", PICKMEAPP)
status = None
# try:
# status = int(request.GET.get("status"))
# except ValueError, e:
# pass
count_only = request.GET.get("count_only", False)
if count_only: count_only = simplejson.loads(count_only)
if request_type == PICKMEAPP:
orders = Order.objects.filter(type=OrderType.PICKMEAPP, debug=False)
else:
orders = Order.objects.filter(type=OrderType.SHARED, debug=False)
if not status is None: orders = orders.filter(status=status)
if count_only:
return JSONResponse(orders.count())
else:
orders = orders[offset:offset + batch_size]
points = []
for o in orders:
if o.from_lat and o.from_lon:
points.append([o.from_lat, o.from_lon, o.passenger_id])
return JSONResponse(points)
def resolve_address(request, station):
try:
city = City.objects.filter(id=request.GET.get('city_id', '-1')).get()
except City.DoesNotExist:
return HttpResponseBadRequest(_("Invalid city"))
address = request.GET.get('address', None)
if not address:
return JSONResponse('')
return JSONResponse(geocode(address, constrain_to_city=city))
def is_user_authenticated(request):
if request.user.is_authenticated():
logging.info("User is authenticated: %s" % request.user.username)
response_data = [True, request.user.username]
passenger = Passenger.from_request(request)
if passenger and (request.is_secure() or settings.DEV): # send token only over secure connection
response_data.append(passenger.login_token)
return JSONResponse(response_data)
else:
logging.info("User is not authenticated")
return JSONResponse([False])
def account_view(request):
if not request.user.is_authenticated():
return HttpResponseRedirect(reverse(registration_view))
PASSWORD_MASK = "********"
user = request.user
passenger = user.passenger
if request.method == 'GET':
name = user.get_full_name()
email = user.email
password = PASSWORD_MASK
phone = passenger.phone
billing_info = passenger.billing_info.card_repr[-4:] if hasattr(
passenger, "billing_info") else None
title = _("Your Account")
credit_card_error = request.session.get('credit_card_error', '')
promo_activations = PromoCodeActivation.objects.filter(
passenger=passenger)
return render_to_response("mobile/account_registration.html", locals(),
RequestContext(request))
elif request.method == 'POST':
new_email = request.POST.get("email", "").strip() or None
new_first_name, new_last_name = get_name_parts(
request.POST.get("name") or None)
new_password = request.POST.get("password", "").replace(
PASSWORD_MASK, "") or None
new_phone = request.POST.get("phone", "") or None
try:
user = update_user_details(user,
first_name=new_first_name,
last_name=new_last_name,
email=new_email,
password=new_password,
phone=new_phone)
if new_password:
user = authenticate(username=user.username,
password=new_password)
login(request, user)
except UpdateUserError, e:
return JSONResponse({'error': e.message})
# success
return JSONResponse({
'redirect': reverse(account_view),
'billing_url': (get_token_url(request))
})
def get_trx_status(request, passenger):
trx_id = request.GET.get("trx_id")
trx = BillingTransaction.by_id(trx_id)
if trx and trx.passenger == passenger:
response = {'status': trx.status}
if trx.status == BillingStatus.FAILED:
msg = get_custom_message(trx.provider_status, trx.comments)
if msg:
response.update({'error_message': msg})
return JSONResponse(response)
return JSONResponse({'status': BillingStatus.FAILED})
def update_order_status(request, work_station):
new_status = request.POST.get("status")
order_id = request.POST.get("order_id")
if order_id == station_connection_manager.DUMMY_ID:
return JSONResponse({'order_id': order_id, "order_status": "stale"})
order_id = int(order_id)
logging.info(request.POST)
pickup_time = int(request.POST.get("pickup_time", 0))
try:
result = order_manager.update_order_status(order_id, work_station, new_status, pickup_time)
return JSONResponse(result)
except UpdateOrderError:
return HttpResponseBadRequest("Invalid status")
def is_email_available_for_user(request):
passenger = Passenger.from_request(request)
if passenger and passenger.user:
if request.GET.get("email", None) == passenger.user.email:
return JSONResponse(True)
return is_email_available(request)
def get_station_orders_history_data(request, station):
keywords = request.GET.get("keywords", None)
page = int(request.GET.get("page", "1"))
sort_by = request.GET.get("sort_by", "create_date")
sort_dir = request.GET.get("sort_dir", "-")
data = get_stations_orders_history_data(station, page, keywords, sort_by, sort_dir)
return JSONResponse(data)
def get_places(request):
def place_to_suggestion(place, name=None):
return {
'id': place.id,
'name': name or place.name_for_user,
'description': place.description_for_user,
'city_name': place.dn_city_name,
'street': place.street,
'house_number': place.house_number,
'lon': place.lon,
'lat': place.lat,
'country_code': settings.DEFAULT_COUNTRY_CODE
}
places_data = []
for place in Place.objects.all():
places_data.append(place_to_suggestion(place))
for alias in place.aliases:
places_data.append(place_to_suggestion(place, name=alias))
return JSONResponse({
"places": places_data,
"blacklist": ['תל אביב, ישראל', 'היכל נוקיה, תל אביב יפו, ישראל', 'היכל נוקיה, תל אביב יפו, מחוז תל אביב, ישראל', 'היכל נוקיה ניהול והשקעות בע"מ, תל אביב יפו, ישראל' ]
})
def get_messages(request):
messages = Message.objects.all()
res = {}
for m in messages:
res[m.key] = m.content
return JSONResponse(res)
def get_passenger_orders_history_data(request, passenger):
keywords = request.GET.get("keywords", None)
page = int(request.GET.get("page", "1"))
sort_by = request.GET.get("sort_by", "create_date")
sort_dir = request.GET.get("sort_dir", "-")
data = get_orders_history(passenger, page, keywords, sort_by, sort_dir)
return JSONResponse(data)
def get_ride(request, ride_id):
from fleet import isr_tests
result = str(isr_tests.get_ride(ride_id, False))
if request.is_ajax():
return JSONResponse({'result': result})
else:
return HttpResponse(result)
def update_city_area_order(request):
new_order = simplejson.loads(request.POST['data'])
for city_area_id in new_order.keys():
ca = CityArea.by_id(city_area_id)
ca.set_order(new_order[city_area_id])
ca.save()
return JSONResponse("")
def crud_place(request):
lib_ng = True
lib_map = True
lib_geo = True
if request.method == "GET":
places = simplejson.dumps([place.serialize() for place in Place.objects.all()])
return render_to_response("crud_place.html", locals())
elif request.method == "POST": # CRUD actions
payload = simplejson.loads(request.raw_post_data)
action = payload["action"]
place_data = payload["data"]
place_data = dict_to_str_keys(place_data)
if action in ["create", "update"]:
if place_data.get("city_name"):
place_data["city"] = City.objects.get(name=place_data["city_name"].strip())
del(place_data["city_name"])
place_data["aliases"] = place_data["aliases"]
if action == "create":
place = Place(**place_data)
place.save()
logging.info("created new place: %s" % place.name)
else: # update
place = Place.by_id(place_data["id"])
del(place_data["id"])
place.update(**place_data)
logging.info("updated place %s" % place.name)
return JSONResponse({'place': place.serialize()})
elif action == "remove":
place = Place.by_id(place_data["id"])
deleted = False
if place:
place.delete()
deleted = True
logging.info("deleted place %s" % place.name)
return JSONResponse({'success': deleted})
return HttpResponseBadRequest()
def validate_phone(request):
local_phone = request.POST.get('local_phone')
verification_code = int(request.POST.get('verification_code', -1))
country = get_object_or_404(Country,
code=request.POST.get('country_code', ""))
stored_code, stored_phone = request.session.get(SESSION_VERIFICATION_KEY,
(None, None))
intl_phone_number = get_international_phone(country, local_phone)
if not (stored_code and stored_phone):
return HttpResponseBadRequest(
_("Error validating phone (check that your browser accepts cookies)"
))
if intl_phone_number != stored_phone or verification_code != int(
stored_code):
return HttpResponseBadRequest(_("Invalid verification code"))
# there is a user
if request.user.is_authenticated():
#TODO_WB: check if user already has a passenger
try:
# has a passenger? update phone
passenger = Passenger.objects.get(user=request.user)
passenger.phone = local_phone
passenger.phone_verified = True
passenger.save()
return HttpResponse(local_phone)
except Passenger.DoesNotExist:
# create passenger
passenger = create_passenger(None, country, local_phone)
passenger.user = request.user
passenger.save()
# no user, get a passenger
else:
try:
passenger = Passenger.objects.filter(country=country).filter(
phone=local_phone).get()
except Passenger.DoesNotExist:
passenger = create_passenger(None, country, local_phone)
except Passenger.MultipleObjectsReturned:
return HttpResponseBadRequest(
_("Phone has multiple passengers"
)) # shouldn't happen to real passengers (only staff)
request.session[CURRENT_PASSENGER_KEY] = passenger
# reset login token after validation
# TODO_WB: check if login_token exists
# TODO_WB: add phone number to salt the token
passenger.login_token = hashlib.sha1(
generate_random_token(length=40)).hexdigest()
passenger.save()
return JSONResponse({PASSENGER_TOKEN: passenger.login_token})
def error_response(message):
result = {
"status": "error",
"errors": {
"title": _("Your Ride Could Not Be Ordered"),
"message": message
}
}
return JSONResponse(result)
def show_order(request, work_station):
order_id = request.POST.get("order_id")
if order_id == station_connection_manager.DUMMY_ID:
return JSONResponse({"pk": order_id,
"status": ASSIGNED,
"from_raw": translate_to_ws_lang(station_connection_manager.DUMMY_ADDRESS, work_station),
"seconds_passed": 5})
order_id = int(order_id)
try:
order_assignment = order_manager.show_order(order_id, work_station)
except ShowOrderError:
logging.error("ShowOrderError")
return HttpResponseBadRequest("ShowOrderError")
result = OrderAssignment.serialize_for_workstation(order_assignment, base_time=order_assignment.show_date)
return JSONResponse(result)
def cancel_order(request, order_id):
res = False
order = Order.by_id(order_id)
order.cancel_billing()
if order.change_status(new_status=CANCELLED):
res = True
return JSONResponse({'success': res})
def resend_to_fleet_manager(request, ride_id):
resend_result = False
ride = SharedRide.by_id(ride_id)
cancel_result = fleet_manager.cancel_ride(ride)
if cancel_result:
resend_result = fleet_manager.create_ride(ride)
return JSONResponse({'result': resend_result})
def resolve_coordinates(request):
lon = request.GET.get('lon', -1)
lat = request.GET.get('lat', -1)
if lon == -1 or lat == -1:
return HttpResponseBadRequest('Invalid arguments')
result = reverse_geocode(float(lat), float(lon))
return JSONResponse(result)
def _send_order_with_version(orders):
"""
Add version information and send orders to client
@param orders: a list of order objects to send
@return: a JSONResponse
"""
return JSONResponse({"orders": orders,
"version": get_current_version()
})
def is_user_property_available(request, prop_name):
#TODO_WB:throttle this
result = False
prop_value = request.GET.get(prop_name, None)
if prop_value:
# time.sleep(1)
result = User.objects.filter(**{prop_name: prop_value}).count() == 0
return JSONResponse(result)
def get_polygons(request):
city_areas_ids = simplejson.loads(request.POST['data'])
result = []
for city_area in CityArea.objects.filter(id__in=city_areas_ids):
result.append({
city_area.id: city_area.points
})
return JSONResponse(result)
def live_search_results(request,
model,
search_index='search_index',
limit=30,
result_item_formatting=None,
query_converter=None,
converter=None,
redirect=False):
"""
Performs a search in searched_model and prints the results as
text, so it can be used by auto-complete scripts.
limit indicates the number of results to be returned.
A JSON file is sent to the browser. It contains a list of
objects that are created by the function indicated by
the parameter result_item_formatting. It is executed for every result
item.
Example:
result_item_formatting=lambda course: {
'value': course.name + '<br />Prof: ' + course.prof.name,
'result': course.name + ' ' + course.prof.name,
'data': redirect=='redirect' and
{'link': course.get_absolute_url()} or {},
}
"""
query = request.GET.get('query', '')
try:
limit_override = int(request.GET.get('limit', limit))
if limit_override < limit:
limit = limit_override
except:
pass
search_index = getattr(model, search_index)
language = getattr(request, 'LANGUAGE_CODE', settings.LANGUAGE_CODE)
results = search_index.search(query, language=language)
if query_converter:
results = query_converter(request, results)
results = results[:limit]
if converter:
results = converter(results)
data = []
for item in results:
if result_item_formatting:
entry = result_item_formatting(item)
else:
value = getattr(item, search_index.fields_to_index[0])
entry = {'value': force_escape(value), 'result': value}
if 'data' not in entry:
entry['data'] = {}
if redirect:
if 'link' not in entry['data']:
entry['data']['link'] = item.get_absolute_url()
data.append(entry)
return JSONResponse(data)
def estimate_ride_cost(request):
from_lon = request.GET["from_lon"]
from_lat = request.GET["from_lat"]
to_lon = request.GET["to_lon"]
to_lat = request.GET["to_lat"]
from_city = int(request.GET["from_city"])
to_city = int(request.GET["to_city"])
result = calculate_time_and_distance(from_lon, from_lat, to_lon, to_lat)
estimated_duration, estimated_distance = result[
"estimated_duration"], result["estimated_distance"]
cities = [from_city, to_city]
if not (estimated_distance and estimated_duration):
return JSONResponse({
"estimated_cost": "",
"estimated_duration": "",
"currency": "",
"label": _("Ride estimation not available")
})
ride_cost, ride_type = estimate_cost(estimated_duration,
estimated_distance,
cities=cities)
if ride_type == CostType.METER:
label = _('Estimated ride cost')
cost = "%d-%d" % (ride_cost, ride_cost *
(1 + ESTIMATION_FUZZINESS_FACTOR))
elif ride_type == CostType.FLAT:
label = _('Flat rate')
cost = "%d" % ride_cost
result = {
"estimated_cost":
cost,
"estimated_duration":
"%d-%d %s" % (estimated_duration / 60, estimated_duration *
(1 + ESTIMATION_FUZZINESS_FACTOR) / 60, _('min')),
"currency":
u'₪', # TODO_WB: change to non hardcoded version
"label":
label
}
return JSONResponse(result)
def get_tracker_init(request):
response = ''
passenger = Passenger.from_request(request)
if passenger:
channel_key = get_channel_key(passenger, request.session.session_key)
token = channel.create_channel(channel_key)
tracker_history = order_tracker.get_tracker_history(passenger)
response = {'tracker_history': tracker_history, 'token': token}
return JSONResponse(response)
def manual_assign_ride(request):
from sharing.sharing_dispatcher import assign_ride
ride_id = request.POST.get("ride_id")
station_id = request.POST.get("station_id")
ride = SharedRide.by_id(ride_id)
station = Station.by_id(station_id)
if station and ride.station != station:
fleet_manager.cancel_ride(ride)
assign_ride(ride, station)
return JSONResponse({'ride': ride.serialize_for_eagle_eye()})
def resolve_address(request):
# get parameters
if not ADDRESS_PARAMETER in request.GET:
return HttpResponseBadRequest("Missing address")
address = request.GET[ADDRESS_PARAMETER]
lon = request.GET.get("lon", None)
lat = request.GET.get("lat", None)
include_order_history = request.GET.get("include_order_history", True)
fixed_address = fix_address(address, lon, lat)
size = request.GET.get(MAX_SIZE_PARAMETER) or DEFAULT_RESULT_MAX_SIZE
try:
size = int(size)
except:
return HttpResponseBadRequest("Invalid value for max_size")
geocoding_results = geocode(fixed_address,
max_size=size,
resolve_to_ids=True)
history_results = []
if include_order_history:
passenger = Passenger.from_request(request)
if passenger:
history_results.extend([
get_results_from_order(o, "from")
for o in passenger.orders.filter(from_raw__icontains=address)
])
history_results.extend([
get_results_from_order(o, "to")
for o in passenger.orders.filter(to_raw__icontains=address)
])
history_results_by_name = {}
for result in history_results:
history_results_by_name[result["name"]] = result
history_results = history_results_by_name.values()
# remove duplicate results
history_results_names = [
result_name for result_name in history_results_by_name
]
for result in geocoding_results:
if result['name'] in history_results_names:
geocoding_results.remove(result)
return JSONResponse({
"geocode": geocoding_results[:size],
"history": history_results[:size],
"geocode_label": "map_suggestion",
"history_label": "history_suggestion"
})
def apply_promo_code(request, passenger):
code = request.POST.get("promo_code")
logging.info("[apply_promo_code] code = %s" % code)
try:
activation = PromoCodeActivation.create(code, passenger)
return JSONResponse({
'description_for_user': activation.promotion.description_for_user,
'promo_code': activation.promo_code.code
})
except ValueError, e:
logging.error("[apply_promo_code] %s" % e.message)
return HttpResponseBadRequest(e.message)
def do_register_user(request):
form = UserRegistrationForm(data=request.POST)
if form.is_valid():
email = form.cleaned_data["email"]
password = form.cleaned_data["password"]
first_name, last_name = get_name_parts(form.cleaned_data["name"])
user = create_user(email, password, email, first_name, last_name)
user = authenticate(username=user.username,
password=form.cleaned_data["password"])
login(request, user)
# redirect to passenger step
return JSONResponse({"redirect": reverse(post_login_redirect)})
else:
errors = [{
'field_name': e,
'errors_ul': str(form.errors[e])
} for e in form.errors.keys()]
return JSONResponse({"errors": errors})
def s3policy(request, prefix):
error_msg = ''
acl = 'public-read'
# TODO: Amazon time difference is strange - investigate
filename = request.GET['filename']
extension = os.path.splitext(os.path.basename(filename))[1].lower()
if extension[1:] not in SUPPORTED_FORMATS.split(','):
error_msg = 'Filetype %s (%s) is not allowed' % (extension, filename)
content_type = mimetypes.guess_type(filename)[0]
if not content_type:
content_type = 'application/octet-stream'
big_content_type = content_type.partition('/')[0]
file_size = int(request.GET.get('file_size', 10))
# if big_content_type=='image' and file_size>1048576:
# error_msg = '%s is too large. Max size image 1MB.' % (filename)
# if file_size>10485760:
# error_msg = '%s is too large. Max size 10MB.' % (filename)
# Test for max file size
if not file_size:
error_msg = 'File size is zero'
if file_size > settings.AWS_MAX_FILE_SIZE:
error_msg = 'Selected file is too large (max is %dMB)' % (settings.AWS_MAX_FILE_SIZE / 1024 / 1024)
if error_msg:
logging.info('s3policy error %s' % error_msg)
return JSONResponse({'errorMessage':error_msg})
#expires = rfc822.formatdate(time.mktime((datetime.datetime.now() + datetime.timedelta(days=360)).timetuple())),
key = '%s/%s/%s' % (prefix, time.time(), filename)
expiration_date = time.strftime('%Y-%m-%dT%H:%M:%S.000Z', time.gmtime(time.time()+30000))
policy_document = simplejson.dumps({"expiration": expiration_date,
"conditions": [
{"bucket": settings.AWS_BUCKET},
{"acl": acl},
{"key": key},
{"Cache-Control": "public, max-age=2629743"},
{"Filename": filename},
{"name": filename},
{"Content-Type": content_type},
["eq", "$success_action_status", "201"],
]
})
policy = base64.b64encode(policy_document.encode('utf-8'))
signature = base64.b64encode(hmac.new(settings.AWS_SECRET_ACCESS_KEY, policy, sha).digest())
response = {
'policy': policy,
'signature': signature,
'AWSAccessKeyId': settings.AWS_ACCESS_KEY_ID,
'Cache-Control': 'public, max-age=2629743',
'Content-Type': content_type,
'acl': acl,
'key': key,
'success_action_status': '201'
}
# Needed when resizing since Flash advancedUpload does not send this and S3 policy fails
if filename.lower().endswith('jpg') or filename.lower().endswith('png'):
response['Filename'] = filename
json_response = JSONResponse(response)
json_response.filename = key
return json_response
