def get_order_billing_status(request, passenger): approved = "approved" pending = "pending" order_id = request.GET.get("order_id") order = Order.by_id(order_id) if not (order and order.passenger == passenger): return JSONResponse({"error": _("You are not authorized to view the status of this order")}) response = {} try: billing_trx = sorted(order.billing_transactions.all(), lambda trx: trx.create_date)[0] if billing_trx.status == BillingStatus.APPROVED: response['status'] = approved elif billing_trx.status == BillingStatus.FAILED: response['error'] = _("This card cannot be charged. It may be expired, blocked or not yet supported by WAYbetter (American Express)") else: response['status'] = pending except IndexError: # no billing transactions response['error'] = _("Order was not processed for billing") logging.info("response = %s" % response) return JSONResponse(response)
def track_order(request, order_id): order = Order.by_id(order_id) use_mock = False ride = None expiration_date = default_tz_now() if order: try: ride = order.ride or order.pickmeapp_ride except (SharedRide.DoesNotExist, PickMeAppRide.DoesNotExist): pass else: error_message = _("This ride is invalid") if not ride: error_message = _("This ride is invalid") else: expiration_date = ride.arrive_time + timedelta(minutes=15) if expiration_date < default_tz_now(): error_message = _("This ride has expired") if ride.station: station_icon_url = ride.station.app_icon_url station_phone = ride.station.phone if request.GET.get("use_mock"): error_message = "" station_icon_url = "https://s3.amazonaws.com/stations_icons/ny_icon.png" use_mock = True expiration_date = default_tz_now() + timedelta(minutes=15) expiration_date = to_js_date(expiration_date) # prepare for JS consumption return custom_render_to_response("track_order.html", locals(), context_instance=RequestContext(request))
def update_ride_add_order(ride, ride_data, new_order): # important: # connect new_order to ride ONLY AFTER update_ride is done. # If not, new_order will turn up in ride.orders.all() queries which doesn't reflect the state of the ride prior to joining update_ride(ride, ride_data, new_order=new_order) # create or update points for the new order for point_data in [ride_data.order_pickup_point(NEW_ORDER_ID), ride_data.order_dropoff_point(NEW_ORDER_ID)]: if len(point_data.order_ids) == 1: # new point point = create_ride_point(ride, point_data) else: # find existing point existing_order_id = first(lambda id: id != NEW_ORDER_ID, point_data.order_ids) existing_order = Order.by_id(existing_order_id) point = existing_order.pickup_point if point_data.stop_type == StopType.PICKUP else existing_order.dropoff_point logging.info("joining existing point %s" % point.id) if point_data.stop_type == StopType.PICKUP: new_order.pickup_point = point else: new_order.dropoff_point = point new_order.price_data = ride_data.order_price_data(NEW_ORDER_ID) new_order.ride = ride new_order.save()
def track_order(request, order_id): order = Order.by_id(order_id) use_mock = False ride = None expiration_date = default_tz_now() if order: try: ride = order.ride or order.pickmeapp_ride except (SharedRide.DoesNotExist, PickMeAppRide.DoesNotExist): pass else: error_message = _("This ride is invalid") if not ride: error_message = _("This ride is invalid") else: expiration_date = ride.arrive_time + timedelta(minutes=15) if expiration_date < default_tz_now(): error_message = _("This ride has expired") if ride.station: station_icon_url = ride.station.app_icon_url station_phone = ride.station.phone if request.GET.get("use_mock"): error_message = "" station_icon_url = "https://s3.amazonaws.com/stations_icons/ny_icon.png" use_mock = True expiration_date = default_tz_now() + timedelta(minutes=15) expiration_date = to_js_date(expiration_date) # prepare for JS consumption return custom_render_to_response('track_order.html', locals(), context_instance=RequestContext(request))
def get(self, request, email=None, output_format=None): '''Request handler for displaying all user orders Keyword args: request -- HTTP request object email -- the user's email output_format -- deprecated Return: HttpResponse ''' if email is None or not emails.Emails().validate_email(email): user = User.objects.get(username=request.user.username) email = user.email orders = Order.list_all_orders(email) form = ListOrdersForm(initial={'email': email}) c = self._get_request_context(request, {'form': form, 'email': email, 'orders': orders }) t = loader.get_template(self.template) return HttpResponse(t.render(c))
def fb_share(request): context = request.GET.get("context") raw_data = request.GET.get("data") data = simplejson.loads(raw_data) if raw_data else None caption = u"הצטרפו למהפכת המוניות המשותפות WAYbetter:" description = u"מתקדם יותר, חכם יותר, נוח יותר ומשתלם הרבה יותר!" if context == 'order_approved': order = Order.by_id(data.get('order_id')) savings = order.price - order.get_billing_amount() if savings: caption = u"חסכתי %s₪ על מונית משותפת מ%s ל%s. תצטרפו אלי ונחסוך יחד יותר..." % (savings, order.from_raw, order.to_raw) else: caption = u"הזמנתי מונית משותפת מ%s ל%s. תצטרפו אלי ונחסוך יחד יותר..." % (order.from_raw, order.to_raw) args = { 'app_id': settings.FACEBOOK_APP_ID, 'link': settings.DEFAULT_DOMAIN, 'picture': 'http://%s/static/images/fb_share_logo.png' % settings.DEFAULT_DOMAIN, 'name': 'WAYbetter', 'caption': caption.encode("utf-8"), 'description': description.encode("utf-8"), 'redirect_uri': settings.CLOSE_CHILD_BROWSER_URI if request.mobile else "http://%s" % settings.DEFAULT_DOMAIN, 'display': 'touch' if request.mobile else 'page' } url = "http://%s.facebook.com/dialog/feed?%s" % ("m" if request.mobile else "www", urllib.urlencode(args)) return HttpResponseRedirect(url)
def post(self): args = parser.parse_args() name = args['name'] items_id = args['items'] destination = args['address'] creation_date = datetime.datetime.now() bill = 0 # Update items availability in inventory for item_id in items_id: resp_get_item = requests.get("http://inventory:5000/items/" + item_id) data = resp_get_item.json() curr_availability = data['availability'] resp_update_item = requests.put("http://inventory:5000/items/"+\ item_id, json={'availability': curr_availability - 1}) bill += data['price'] # TODO: add id and delivery at saving Order order = Order( name=name, bill=bill, items=items_id, \ creation_date=creation_date, destination=destination) order.save() resp_create_delivery = requests.post("http://tracking:5000/tracking", \ json={'destination': destination, 'order_id': str(order._id)}) print(resp_create_delivery.text, '\n\n') order.delivery_id = resp_create_delivery.json()['_id'] order.save() return jsonify(pretty(order))
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 get_order_position(request, order_id): """ Return a taxi position and pickup/dropoff status for taxi tracking page. position : TaxiRidePosition if there is a position, None if there is no position or it is stale (expired) passenger_pickup_up: bool indicating if the passenger is on the taxi """ order = Order.by_id(order_id) position = get_position_for_order(order) response = {"position": position.__dict__ if position else None, "passenger_picked_up": order.pickup_point.visited} logging.info(response) return JSONResponse(response)
def create_order(json): # Rating an SDR file customer_data = json['customer'] total = json['total'] amount = json['subtotal'] vat = json['taxes'] currency = 'EUR' account_id = customer_data['tef_account'] country = customer_data['country'] order_code = compute_uuid() account = Account.objects.get(account_id=account_id) order = Order(account=account, total=total, currency=currency, country=country, order_code=order_code, payment_method=None, amount=amount, vat=vat) order.save() json['order'] = order.to_dict() return (json, None)
def create_order(order_settings, passenger, ride=None, discount_data=None): """ Returns a created Order or None @param order_settings: @param passenger: @param ride: @param discount_data: a DiscountData instance @return: """ ride_id = ride.id if ride else NEW_ORDER_ID # get ride data from algo: don't trust the client candidates = [ride] if ride else [] matching_rides = get_matching_rides(candidates, order_settings) ride_data = first(lambda match: match.ride_id == ride_id, matching_rides) if not ride_data: return None order = Order.fromOrderSettings(order_settings, passenger, commit=False) if ride: # if joining a ride, order departure is as shown in offer, not what was submitted in order_settings ride_departure = compute_new_departure(ride, ride_data) new_order_pickup_point = ride_data.order_pickup_point(NEW_ORDER_ID) order.depart_time = ride_departure + datetime.timedelta(seconds=new_order_pickup_point.offset) if order_settings.private: order.type = OrderType.PRIVATE else: order.type = OrderType.SHARED order.price_data = ride_data.order_price_data(NEW_ORDER_ID) if discount_data: order = apply_discount_data(order, order_settings, discount_data) if not order: return None order.save() logging.info("created new %s order [%s]" % (OrderType.get_name(order.type), order.id)) billing_trx = BillingTransaction(order=order, amount=order.get_billing_amount(), debug=order.debug) billing_trx.save() billing_trx.commit(callback_args={ "ride_id": ride_id, "ride_data": ride_data, "discount_data": DiscountData.dump(discount_data) }) return order
def create_selenium_dummy_order(from_raw, to_raw): order = Order(passenger=SELENIUM_PASSENGER, station=SELENIUM_STATION, status=ACCEPTED, from_city=City.objects.get(name="תל אביב יפו"), from_country=Country.objects.get(code="IL"), from_geohash=u'swnvcbdruxgz', from_lat=u'32', from_lon=u'34', from_raw=from_raw, from_street_address=u'street1', to_city=City.objects.get(name="תל אביב יפו"), to_country=Country.objects.get(code="IL"), to_geohash=u'swnvcbdruxgz', to_lat=u'32', to_lon=u'34', to_raw=to_raw, to_street_address=u'street2', create_date=datetime.datetime.now() - datetime.timedelta(hours=1)) order.save() return order
def create_selenium_dummy_order(from_raw, to_raw): order = Order( passenger=SELENIUM_PASSENGER, station=SELENIUM_STATION, status=ACCEPTED, from_city=City.objects.get(name="תל אביב יפו"), from_country=Country.objects.get(code="IL"), from_geohash=u"swnvcbdruxgz", from_lat=u"32", from_lon=u"34", from_raw=from_raw, from_street_address=u"street1", to_city=City.objects.get(name="תל אביב יפו"), to_country=Country.objects.get(code="IL"), to_geohash=u"swnvcbdruxgz", to_lat=u"32", to_lon=u"34", to_raw=to_raw, to_street_address=u"street2", create_date=datetime.datetime.now() - datetime.timedelta(hours=1), ) order.save() return order
def get_order_position(request, order_id): """ Return a taxi position and pickup/dropoff status for taxi tracking page. position : TaxiRidePosition if there is a position, None if there is no position or it is stale (expired) passenger_pickup_up: bool indicating if the passenger is on the taxi """ order = Order.by_id(order_id) position = get_position_for_order(order) response = { 'position': position.__dict__ if position else None, 'passenger_picked_up': order.pickup_point.visited, } logging.info(response) return JSONResponse(response)
def get_ongoing_ride_details(request): order_id = request.GET.get("order_id") order = Order.by_id(order_id) response = {} if order and order.ride: ride = order.ride station = ride.station station_data = { 'name': station.name if station else WAYBETTER_STATION_NAME, 'phone': settings.CONTACT_PHONE } pickup_position = {"lat": order.from_lat, "lng": order.from_lon} dropoff_position = {"lat": order.to_lat, "lng": order.to_lon} taxi_position = get_position_for_order(order) if taxi_position: taxi_position = {"lat": taxi_position.lat, "lng": taxi_position.lon} pickup_stops = [{"lat": p.lat, "lng": p.lon} for p in ride.pickup_points] # sorted by stop_time sorted_orders = sorted(ride.orders.all(), key=lambda o: o.depart_time) # stops include other passengers stops only stops = filter(lambda stop: (stop["lat"], stop["lng"]) not in [(pickup_position["lat"], pickup_position["lng"]), (dropoff_position["lat"], dropoff_position["lng"])], pickup_stops) # passenger appears as many times as seats she ordered passengers = [{'name': o.passenger.name, 'picture_url': o.passenger.picture_url, 'is_you': o==order} for o in sorted_orders for seat in range(o.num_seats)] response = { "station" : station_data, "passengers" : passengers, "taxi_position" : taxi_position, "taxi_number" : ride.taxi_number, "pickup_position" : pickup_position, "dropoff_position" : dropoff_position, 'passenger_picked_up': order.pickup_point.visited, "stops" : stops, "empty_seats" : MAX_SEATS - sum([o.num_seats for o in sorted_orders]), } else: logging.error("ongoing ride details error for order [%s]" % order_id) return JSONResponse(response)
def order(request): cart = Cart(request) if cart.get_summary_quantity() == 0: return redirect('main-page') if request.method == 'GET': form = CustomerForm() return render(request, 'ordering/index.html', {'form': form, 'cart': cart}) if request.method == 'POST': post = request.POST form = CustomerForm(request.POST) try: customer = Customer.objects.get(first_name=post.get('first_name'), last_name=post.get('last_name'), phone_number=post.get('phone_number')) except Customer.DoesNotExist as err: print(err) if {'first_name', 'last_name', 'phone_number'} < set(post.keys()): customer = Customer(first_name=post['first_name'], last_name=post['last_name'], phone_number=post['phone_number']) customer.save() if not customer: return JsonResponse({'message': 'error'}) order = Order() order.status = 'made' order.address = post.get('address') order.customer = customer order.save() # print(customer) cart = Cart(request) for position in cart.get_products(): order_position = OrderPosition() order_position.product = position['product'] order_position.quantity = position['quantity'] order_position.order = order order.save() print(order) return render(request, 'ordering/index.html', {'form': form, 'cart': cart})
def get(self, request, orderid, output_format=None): '''Request handler to get the full listing of all the scenes & statuses for an order Keyword args: request -- HTTP request object orderid -- the order id for the order output_format -- deprecated Return: HttpResponse ''' t = loader.get_template(self.template) c = self._get_request_context(request) try: c['order'], c['scenes'] = Order.get_order_details(orderid) return HttpResponse(t.render(c)) except Order.DoesNotExist: raise Http404
def _get_order_options(self, request): defaults = Order.get_default_options() # This will make sure no additional options past the ones we are # expecting will make it into the database #for key in request.POST.iterkeys(): for key in defaults: if key in request.POST.iterkeys(): val = request.POST[key] if val is True or str(val).lower() == 'on': defaults[key] = True elif utilities.is_number(val): if str(val).find('.') != -1: defaults[key] = float(val) else: defaults[key] = int(val) else: defaults[key] = val return defaults
def cancel_order(request, passenger): """ Cancel an order. Current status must be APPROVED meaning J5 was successful. The billing backend is responsible for not charging (J4) the order. """ from sharing.sharing_dispatcher import WS_SHOULD_HANDLE_TIME response = {'success': False, 'message': _("This order cannot be cancelled anymore")} order = Order.by_id(request.POST.get("order_id")) cancel_allowed = False if order and order.passenger == passenger: cancel_allowed = True ride = order.ride if ride: cancel_allowed = ride.depart_time > default_tz_now() + datetime.timedelta(minutes=WS_SHOULD_HANDLE_TIME) if cancel_allowed and order.change_status(APPROVED, CANCELLED): response = {'success': True, 'message': _("Order cancelled")} return JSONResponse(response)
def create_ride(address, comments, passenger_phone, first_name, last_name, start_time, finish_time, station_id, as_raw_output): from common.tz_support import set_default_tz_time from geo.coder import geocode if not address: return "Please choose a valid street address: street, house number and city" lat, lon, city, street, house_number = None, None, None, None, None results = geocode(address, lang_code="he") if results: result = results[0] if "street_address" in result["types"]: lat = result["geometry"]["location"]["lat"] lon = result["geometry"]["location"]["lng"] for component in result["address_components"]: if "street_number" in component["types"]: house_number = component["short_name"] if "route" in component["types"]: street = component["short_name"] if "locality" in component["types"]: city_name = component["short_name"] city = City.objects.get(name=city_name) if not all([lat, lon, city, street, house_number]): return "Please choose a valid street address: street, house number and city" user = User() user.first_name = first_name user.last_name = last_name passenger = Passenger() passenger.user = user passenger.phone = passenger_phone passenger.id = random.randrange(1, 999999) order = Order() order.id = random.randrange(1, 999999) order.from_raw = address order.from_city = city order.from_street_address = street order.from_house_number = house_number order.from_lat = lat order.from_lon = lon order.comments = comments order.depart_time = set_default_tz_time(datetime.datetime.strptime(start_time, "%Y-%m-%dT%H:%M:%S")) if start_time else None order.arrive_time = set_default_tz_time(datetime.datetime.strptime(finish_time, "%Y-%m-%dT%H:%M:%S")) if finish_time else None order.passenger = passenger station = Station() station.fleet_manager = isr_fm station.fleet_station_id = station_id or 8 # waybetter station operator id ride = FakeSharedRide([order]) ride.id = random.randrange(1, 999999) ride.station = station ride.dn_fleet_manager_id = isr_fm.id ride.status = ASSIGNED DEV_WB_ONGOING_RIDES.append(ride) if as_raw_output: ex_order = ISR._create_external_order(order, station.fleet_station_id) reply = ISR._get_client().service.Insert_External_Order(ISR._get_login_token(), ex_order) return reply return "%s ride id=%s" % (fleet_manager.create_ride(ride), ride.id)
def cancel_billing(request, order_id): order = Order.by_id(order_id) res = order.cancel_billing() return JSONResponse({'success': res})
def post(self, request): '''Request handler for new order submission Keyword args: request -- HTTP request object Return: HttpResponseRedirect upon successful submission HttpResponse if there are errors in the submission ''' #request must be a POST and must also be encoded as multipart/form-data #in order for the files to be uploaded validator_parameters = {} # coerce the request.POST to be a normal Python dictionary validator_parameters = dict(request.POST) # retrieve the namedtuple for the input product list ipl = self._get_input_product_list(request) # send the validator only the items in the list that could actually # be instantiated as a sensor. The other tuple item not_implemented # is being ignored unless we want to tell the users about all the # junk they included in their input file validator_parameters['input_products'] = ipl.input_products validator = validators.NewOrderValidator(validator_parameters) validation_errors = validator.errors() #if validator.errors(): if validation_errors: c = self._get_request_context(request) #unwind the validator errors. It comes out as a dict with a key #for the input field name and a value of a list of error messages. # At this point we are only displaying the error messages in one # block but going forward will be able to put the error message # right next to the field where the error occurred once the # template is properly modified. errors = validation_errors.values() error_list = list() for e in errors: for m in e: m = m.replace("\n", "<br/>") m = m.replace("\t", " • ") m = m.replace(" ", " ") error_list.append(m) c['errors'] = sorted(error_list) c['user'] = request.user t = loader.get_template(self.template) return HttpResponse(t.render(c)) else: vipl = self._get_verified_input_product_list(request) order_options = self._get_order_options(request) order_type = "level2_ondemand" if order_options['include_statistics'] is True: vipl.append("plot") order_type = "lpcs" option_string = json.dumps(order_options, sort_keys=True, indent=4) desc = self._get_order_description(request.POST) order = Order.enter_new_order(request.user.username, 'espa', vipl, option_string, order_type, note=desc ) email = order.user.email url = reverse('list_orders', kwargs={'email': email}) return HttpResponseRedirect(url)
def create_ride(address, comments, passenger_phone, first_name, last_name, start_time, finish_time, station_id, as_raw_output): from common.tz_support import set_default_tz_time from geo.coder import geocode if not address: return "Please choose a valid street address: street, house number and city" lat, lon, city, street, house_number = None, None, None, None, None results = geocode(address, lang_code="he") if results: result = results[0] if "street_address" in result["types"]: lat = result["geometry"]["location"]["lat"] lon = result["geometry"]["location"]["lng"] for component in result["address_components"]: if "street_number" in component["types"]: house_number = component["short_name"] if "route" in component["types"]: street = component["short_name"] if "locality" in component["types"]: city_name = component["short_name"] city = City.objects.get(name=city_name) if not all([lat, lon, city, street, house_number]): return "Please choose a valid street address: street, house number and city" user = User() user.first_name = first_name user.last_name = last_name passenger = Passenger() passenger.user = user passenger.phone = passenger_phone passenger.id = random.randrange(1, 999999) order = Order() order.id = random.randrange(1, 999999) order.from_raw = address order.from_city = city order.from_street_address = street order.from_house_number = house_number order.from_lat = lat order.from_lon = lon order.comments = comments order.depart_time = set_default_tz_time( datetime.datetime.strptime( start_time, "%Y-%m-%dT%H:%M:%S")) if start_time else None order.arrive_time = set_default_tz_time( datetime.datetime.strptime( finish_time, "%Y-%m-%dT%H:%M:%S")) if finish_time else None order.passenger = passenger station = Station() station.fleet_manager = isr_fm station.fleet_station_id = station_id or 8 # waybetter station operator id ride = FakeSharedRide([order]) ride.id = random.randrange(1, 999999) ride.station = station ride.dn_fleet_manager_id = isr_fm.id ride.status = ASSIGNED DEV_WB_ONGOING_RIDES.append(ride) if as_raw_output: ex_order = ISR._create_external_order(order, station.fleet_station_id) reply = ISR._get_client().service.Insert_External_Order( ISR._get_login_token(), ex_order) return reply return "%s ride id=%s" % (fleet_manager.create_ride(ride), ride.id)