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