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 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)
def cancel_billing(request, order_id):
order = Order.by_id(order_id)
res = order.cancel_billing()
return JSONResponse({'success': res})
