def old_status(request):
# List orders for a user in reverse chronologically
res = HttpResponse(content_type=CONTENT_TYPE_JSON)
try:
username = request.POST['username']
except MultiValueDictKeyError:
res.status_code = 400
res.content = json.dumps({'error': 'missing username'})
return res
orders = Order.objects.filter(user__username=username).order_by('-ctime')
out = {}
if orders:
out['success'] = True
else:
out['success'] = False
l = []
for i in orders:
oi = i.orderitem_set.all()[0]
restaurant = oi.meal.restaurant
l.append(
dict(time=i.ctime,
number_slip_index=i.id,
number_slip=i.pos_slip_number,
rest_id=restaurant.id,
rest_name=restaurant.name,
status=i.status))
out['list'] = l
res.status_code = 200
res.content = jsonate(out)
return res
def old_status_detail(request):
res = HttpResponse(content_type=CONTENT_TYPE_JSON)
try:
order_key = request.POST['number_slip_index']
except MultiValueDictKeyError:
res.status_code = 400
return res
# Using order_by('id') to keep the OrderItem's in the same order
# in old_status_detail() and old_order()
order_items = Order.objects.get(
pk=order_key).orderitem_set.all().order_by('id')
out = {}
if order_items:
out['success'] = True
else:
out['success'] = False
l = []
for i in order_items:
meal = i.meal
l.append(
dict(amount=i.amount,
meal_id=meal.id,
meal_name=meal.name,
meal_price=meal.price))
out['list'] = l
res.status_code = 200
res.content = jsonate(out)
return res
def restaurants(request):
res = HttpResponse(content_type=CONTENT_TYPE_JSON)
try:
location_key = request.GET['location']
except MultiValueDictKeyError:
res.status_code = 400
return res
res.status_code = 200
res.content = jsonate(Restaurant.objects.filter(location=location_key))
return res
def order_vendor(request):
res = HttpResponse(content_type=CONTENT_TYPE_TEXT)
vendor = request.user
restaurant = vendor.profile.restaurant
if not restaurant:
res.content = "the restaurant of this vendor is not set"
res.status_code = 400
return res
orders_all = Order.objects.filter(restaurant=restaurant)
orders = []
for o in orders_all:
if o.status == ORDER_STATUS_INIT_COOKING or o.status == ORDER_STATUS_FINISHED:
orders.append(o)
r = []
for i in orders:
row = {}
row['order'] = i
u = i.user
row['user'] = dict(username=u.username,
first_name=u.first_name,
last_name=u.last_name,
email=u.email,
id=u.id)
order_items = OrderItem.objects.filter(order=i)
oi_packed = []
for j in order_items:
oi = {}
m = j.meal
oi['meal'] = dict(meal_price=m.price,
meal_name=m.name,
meal_id=m.id)
oi['amount'] = j.amount
oi_packed.append(oi)
row['order_items'] = oi_packed
r.append(row)
# update vendor last request
try:
vl = VendorLastRequestTime.objects.get(restaurant=restaurant)
vl.last_time = timezone.now()
vl.save()
except VendorLastRequestTime.DoesNotExist:
vl = VendorLastRequestTime(restaurant=restaurant,
last_time=timezone.now())
vl.save()
res.status_code = 200
res.content = jsonate(dict(orders=r))
return res
def menu(request):
res = HttpResponse(content_type=CONTENT_TYPE_JSON)
try:
restaurant_key = request.GET['rest_id']
except MultiValueDictKeyError:
res.status_code = 400
return res
res.status_code = 200
res.content = jsonate(Meal.objects.filter(restaurant=restaurant_key))
return res
def __init__(self,
content,
mimetype='application/json',
jsonp_callback=False,
*args,
**kwargs):
json_content = jsonate(content)
if jsonp_callback:
json_content = jsonp_callback + "(" + json_content + ");"
super(JsonateResponse, self).__init__(json_content, mimetype, *args,
**kwargs)
def test_basic_serialization(self):
mymodel_data = {
"float_field": 32.25,
"normal_field1": "field1",
"normal_field2": "field2",
"boolean_field": True,
"null_field": None,
"decimal_field": 32.25,
"foreign_key": 1,
"datetime_field": "2011-01-11T11:11:11",
"image_field": "images/image_file.wbm",
"date_field": "2011-01-11",
"id": 1,
"file_field": "files/text_file.txt"
}
self.assertJsonEqual(jsonate(self.model), mymodel_data)
self.assertJsonEqual(jsonate(MyModel.objects.all()), [mymodel_data])
user_data = [{"username": '******', "password": self.user.password}]
self.assertJsonEqual(
jsonate(User.objects.values("username", "password")), user_data)
def vendor_list(request):
res = HttpResponse(content_type=CONTENT_TYPE_JSON)
group = Group.objects.get(name='vendor')
users = group.user_set.all()
vendor_usernames = []
for i in users:
vendor_usernames.append(i.username)
res.status_code = 200
res.content = jsonate({'vendor_usernames': vendor_usernames})
return res
def test_basic_serialization(self):
mymodel_data = {
u"float_field": 32.25,
u"normal_field1": u"field1",
u"normal_field2": u"field2",
u"boolean_field": True,
u"null_field": None,
u"decimal_field": 32.25,
u"foreign_key": 1,
u"datetime_field": u"2011-01-11T11:11:11",
u"image_field": u"images/image_file.wbm",
u"date_field": u"2011-01-11",
u"id": 1,
u"file_field": u"files/text_file.txt"
}
self.assertJsonEqual(jsonate(self.model), mymodel_data)
self.assertJsonEqual(jsonate(MyModel.objects.all()), [mymodel_data])
user_data_values = [{
"username": '******',
"password": self.user.password
}]
self.assertJsonEqual(
jsonate(User.objects.values("username", "password")),
user_data_values
)
user_data_values_list = [['asdf']]
self.assertJsonEqual(
jsonate(User.objects.values_list("username")),
user_data_values_list
)
user_data_values_list_flat = ['asdf']
self.assertJsonEqual(
jsonate(User.objects.values_list("username", flat=True)),
user_data_values_list_flat
)
def current_ns(require):
res = HttpResponse(content_type=CONTENT_TYPE_JSON)
try:
rest_id = require.GET['rest_id']
except MultiValueDictKeyError:
res.status_code = 400
return res
r = Restaurant.objects.get(pk=rest_id)
res.status_code = 200
res.content = jsonate({'current_ns': r.current_number_slip})
return res
def post(self, request, *args, **kwargs):
res = HttpResponse(content_type=CONTENT_TYPE_TEXT)
user = request.user
# create new order
# FIXME: should check 'can_place_order'
try:
order_json = request.POST['order']
except MultiValueDictKeyError:
res.content = "post error"
res.status_code = 400
return res
try:
order_data = json.loads(order_json)
except ValueError:
res.content = "json parsing error"
res.status_code = 400
return res
if not order_data:
res.content = "empty order"
res.status_code = 400
return res
# check if all meals are from the same restaurant
m = order_data[0]['meal_id']
rest = Meal.objects.get(pk=m).restaurant
for i in order_data[1:]:
m = i['meal_id']
if rest.id != Meal.objects.get(pk=m).restaurant.id:
res.content = "must be in the same restaurant"
res.status_code = 400
return res
# FIXME: does it make more sense to implement 'order_create' at Restuarant?
i = order_data[0]
(meal_key, amount) = (i['meal_id'], i['amount'])
(order, number_slip) = Meal.objects.get(pk=meal_key).order_create(
user=user, amount=amount)
for i in order_data[1:]:
(meal_key, amount) = (i['meal_id'], i['amount'])
Meal.objects.get(pk=meal_key).order_add(amount=amount, order=order)
res.content = jsonate(dict(number_slip=number_slip))
res.status_code = 200
return res
def get(self, request, *args, **kwargs):
# list eixsting order (only the latest one)
res = HttpResponse(content_type=CONTENT_TYPE_TEXT)
user = request.user
orders = Order.objects.filter(user=user).order_by('-ctime')
if not orders:
res.content = "no processing order"
res.status_code = 204
return res
last_order = orders[:1][0]
# last_order
r_d = dict(name=last_order.restaurant.name,
location=last_order.restaurant.location,
rest_id=last_order.restaurant.id)
l_d = dict(ctime=last_order.ctime,
mtime=last_order.mtime,
restaurant=r_d,
pos_slip_number=last_order.pos_slip_number,
status=last_order.status)
# order_items
order_items = OrderItem.objects.filter(order=last_order)
l_l = []
for i in order_items:
m_d = dict(meal_name=i.meal.name,
meal_price=i.meal.price,
meal_id=i.meal.id)
l_l.append(dict(meal=m_d, amount=i.amount))
# combine, and output
receipt = {}
receipt['last_order'] = l_d
receipt['order_items'] = l_l
res.content = jsonate(receipt)
res.status_code = 200
return res
def restaurant_status(request):
res = HttpResponse(content_type=CONTENT_TYPE_TEXT)
vendor = request.user
if not vendor.is_authenticated():
res.status_code = 401
return res
r = vendor.profile.restaurant
if request.method == 'GET':
if r.closed_reason is None:
msg = ''
else:
msg = r.closed_reason.msg
res.status_code = 200
res.content = jsonate({
'status': r.status,
'is_open': r.is_open,
'closed_reason': msg
})
return res
if request.method == 'POST':
try:
status = request.POST['status']
except MultiValueDictKeyError:
res.content = "wrong input"
res.status_code = 400
return res
r.status_set(status)
res.status_code = 200
return res
def closed_reason(request):
res = HttpResponse(content_type=CONTENT_TYPE_TEXT)
vendor = request.user
if not vendor.is_authenticated():
res.status_code = 401
return res
r = vendor.profile.restaurant
if request.method == 'GET':
crs = ClosedReason.objects.all()
res.status_code = 200
res.content = jsonate({'closed_reasons': crs})
return res
if request.method == 'POST':
try:
cr = request.POST['closed_reason']
except MultiValueDictKeyError:
res.content = "wrong input"
res.status_code = 400
return res
try:
r.closed_reason_set(cr)
except ClosedReason.DoesNotExist:
res.content = "not such closed reason"
res.status_code = 422
return res
res.status_code = 200
return res
u = profile.user
try:
lr = LastRegistrationTime.objects.get(user=u)
except (LastRegistrationTime.DoesNotExist,
LastRegistrationTime.MultipleObjectsReturned), err:
lr = None
if lr:
now = timezone.now()
last = lr.last_time
d = datetime.timedelta(
minutes=Configs.MINUTES_LOCK_BETWEEN_REGISTRATIONS)
if now < (last + d):
res.content = "just registered before, retry again later"
error_msg = "已經註冊，若無收到簡訊，請在" + str(
Configs.MINUTES_LOCK_BETWEEN_REGISTRATIONS) + "分鐘後再嘗試"
res.content = jsonate({'error_msg': error_msg})
res.status_code = 470
return res
lr.last_time = timezone.now()
lr.save()
else:
new_lr = LastRegistrationTime(user=u, last_time=timezone.now())
new_lr.save()
#
url_prefix = request.build_absolute_uri()[:-len(request.get_full_path())]
wsgi_mount_point = request.path[:-len(request.path_info)]
if wsgi_mount_point:
url_prefix += wsgi_mount_point
c = Configuration.get0()
def jsonate_attr(obj):
return escape(jsonate(obj))
def __init__(self, content, mimetype="application/json", jsonp_callback=False, *args, **kwargs):
json_content = jsonate(content)
if jsonp_callback:
json_content = jsonp_callback + "(" + json_content + ");"
super(JsonateResponse, self).__init__(json_content, mimetype, *args, **kwargs)
def jsonate_attr(obj):
return escape(jsonate(obj))
def order_post(request):
res = HttpResponse(content_type=CONTENT_TYPE_TEXT)
user = request.user
# create new order
# FIXME: should check 'can_place_order'
try:
order_json = request.POST['order']
except MultiValueDictKeyError:
res.content = "post error"
res.status_code = 400
return res
try:
order_data = json.loads(order_json)
except ValueError:
res.content = "json parsing error"
res.status_code = 400
return res
if not order_data:
res.content = "empty order"
res.status_code = 400
return res
# FIXME: move business logic to Model classes
# check if all meals are from the same restaurant
m = order_data[0]['meal_id']
rest = Meal.objects.get(pk=m).restaurant
for i in order_data[1:]:
m = i['meal_id']
if rest.id != Meal.objects.get(pk=m).restaurant.id:
res.content = "must be in the same restaurant"
res.status_code = 400
return res
# check if the total amount is over our limitation
total_price = 0
for i in order_data:
(meal_key, amount) = (i['meal_id'], i['amount'])
meal = Meal.objects.get(pk=meal_key)
total_price += (meal.price * amount)
if total_price > Configs.MAX_TOTAL_PRICE_PER_ORDER:
error_msg = "總價錢不得超過" + str(Configs.MAX_TOTAL_PRICE_PER_ORDER) + "元"
res.content = jsonate({'error_msg': error_msg})
res.status_code = 461
return res
if user.profile.failure >= Configs.MAX_ACCEPTABLE_FAILURE:
error_msg = "您已經有" + str(
Configs.MAX_ACCEPTABLE_FAILURE
) + "次以上的訂單失敗記錄，不得再領餐。 洽[email protected]"
res.content = jsonate({'error_msg': error_msg})
res.status_code = 462
return res
if not Configs.ALLOW_MULTIPLE_OUTSTANDING_ORDERS:
profile = Profile.objects.get(user=user)
if not profile.free_to_order():
error_msg = "您有尚未完成的訂單，同時間只能進行一份訂單"
res.content = jsonate({'error_msg': error_msg})
res.status_code = 463
return res
if not rest.is_open:
if rest.closed_reason is None:
error_msg = ''
else:
error_msg = rest.closed_reason.msg
res.content = jsonate({'error_msg': error_msg})
res.status_code = 464
return res
# if the rest is offline, email the admins
try:
lr = VendorLastRequestTime.objects.get(restaurant=rest)
t = lr.last_time
now = timezone.now()
if ((now - t) >
datetime.timedelta(seconds=Configs.ACCEPTABLE_OFFLINE_TIME)):
title = rest.name + " is offline"
message = "now: " + str(now) + "\n" + "last request time: " + str(
t)
tasks.email_admin.delay(title, message)
except VendorLastRequestTime.DoesNotExist:
pass
# FIXME: does it make more sense to implement 'order_create' at Restuarant?
i = order_data[0]
(meal_key, amount) = (i['meal_id'], i['amount'])
(order,
number_slip) = Meal.objects.get(pk=meal_key).order_create(user=user,
amount=amount)
for i in order_data[1:]:
(meal_key, amount) = (i['meal_id'], i['amount'])
Meal.objects.get(pk=meal_key).order_add(amount=amount, order=order)
res.content = jsonate(dict(number_slip=number_slip))
res.status_code = 200
return res
