def request_redeem_offers(patron_store_id):
"""
Requests all offers in the given patron_store's MessageStatus
"""
ps = PatronStore.objects().get(objectId=patron_store_id,
include="Patron,Store")
patron, store = ps.patron, ps.store
message_statuses = patron.get("receivedMessages",
redeem_available="yes",
limit=999)
for ms in message_statuses:
message = Message.objects().get(objectId=ms.Message)
cloud_call(
"request_redeem", {
"patron_id": ps.Patron,
"store_id": ps.Store,
"store_location_id": store.store_locations[0].objectId,
"patron_store_id": ps.objectId,
"title": message.offer_title,
"reward_id": None,
"num_punches": 0,
"name": patron.get_fullname(),
"message_status_id": ms.objectId,
})
def test_0(self):
"""
Add_patronstore creates a new PatronStore if does not exist
"""
if PatronStore.objects().count(Patron=self.patron.objectId,
Store=self.store.objectId) == 1:
return "PatronStore already exists. Test is invalid."
cloud_call("add_patronstore", {
"patron_id": self.patron.objectId,
"store_id": self.store.objectId,
})
return PatronStore.objects().count(Patron=self.patron.objectId,
Store=self.store.objectId) == 1
def test_0(self):
"""
Add_patronstore creates a new PatronStore if does not exist
"""
if PatronStore.objects().count(Patron=self.patron.objectId,
Store=self.store.objectId) == 1:
return "PatronStore already exists. Test is invalid."
cloud_call("add_patronstore", {
"patron_id": self.patron.objectId,
"store_id": self.store.objectId,
})
return PatronStore.objects().count(Patron=self.patron.objectId,
Store=self.store.objectId) == 1
def manage_cloud_trigger(request):
"""
Simply calls the trigger_cloud_logger cloud code.
"""
if request.method == "GET":
key = request.GET.get("key")
if key == CLOUD_LOGGER_TRIGGER_KEY:
cloud_call("trigger_cloud_logger", {
"extra_message":\
request.GET.get("extra_message", "Still running")
})
return HttpResponse("<p>Successfully called "+\
"trigger_cloud_logger.</p><p>Please wait at most"+\
" 40 seconds to receive the notification in your email.</p>")
return HttpResponse("Bad Request")
def manage_cloud_trigger(request):
"""
Simply calls the trigger_cloud_logger cloud code.
"""
if request.method == "GET":
key = request.GET.get("key")
if key == CLOUD_LOGGER_TRIGGER_KEY:
cloud_call("trigger_cloud_logger", {
"extra_message":\
request.GET.get("extra_message", "Still running")
})
return HttpResponse("<p>Successfully called "+\
"trigger_cloud_logger.</p><p>Please wait at most"+\
" 40 seconds to receive the notification in your email.</p>")
return HttpResponse("Bad Request")
def _retailer_message(store_id,
subject,
body,
date_offer_expiration,
message_type,
offer_title,
gift_title,
gift_description,
sender_name="Test Store",
receiver_count=100,
is_read=False,
filter="all"):
# first create the message
message = Message(store_id=store_id, subject=subject, body=body,
filter=filter, sender_name=sender_name, offer_title=offer_title,
message_type=message_type, date_offer_expiration=\
date_offer_expiration, is_read=is_read, gift_description=\
gift_description, gift_title=gift_title)
message.create()
return cloud_call(
"retailer_message", {
"subject": subject,
"message_id": message.objectId,
"store_id": store_id,
"store_name": sender_name,
"filter": filter,
})
def register_employee(first_name,
last_name,
username=None,
password=None,
email=None,
retailer_pin=None):
if username is None:
username = first_name
if password is None:
password = first_name
if email is None:
email = first_name + "@" + last_name + ".com"
if retailer_pin is None:
retailer_pin = settings.retailer_pin
return cloud_call(
"register_employee", {
"first_name": first_name,
"last_name": last_name,
"username": username,
"password": password,
"email": email,
"retailer_pin": retailer_pin,
})
def test_0(self):
"""
Punch creates a new Punch object (from employee)
"""
if Punch.objects().count(Patron=self.patron.objectId) > 0:
return "Punches for the Store exists. Test is invalid."
cloud_call("punch", {
"punch_code": self.patron.punch_code,
"num_punches": 1,
"store_id": self.store.objectId,
"store_name": self.store.store_name,
"employee_id": self.employee.objectId,
})
return Punch.objects().count(Patron=self.patron.objectId) == 1
def test_11(self):
"""
Delete_patronstore deletes the PatronStore
"""
if PatronStore.objects().count(\
objectId=self.patron_store.objectId) == 0:
return "PatronStore does not exists. Test is invalid."
cloud_call("delete_patronstore", {
"patron_store_id": self.patron_store.objectId,
"patron_id": self.patron.objectId,
"store_id": self.store.objectId,
})
return PatronStore.objects().count(\
objectId=self.patron_store.objectId) == 0
def test_14(self):
"""
Punch creates a new Punch object (from dashboard - owner)
"""
self.punch.delete()
if Punch.objects().count(Patron=self.patron.objectId) > 0:
return "Punches for the Store exists. Test is invalid."
cloud_call("punch", {
"punch_code": self.patron.punch_code,
"num_punches": 1,
"store_id": self.store.objectId,
"store_name": self.store.store_name,
})
return Punch.objects().count(Patron=self.patron.objectId) == 1
def _request_redeem(patron_id, store_id, patron_store_id, title, reward_id,
num_punches, name, message_status_id, store_location_id):
"""
var patronId = request.params.patron_id;
var storeId = request.params.store_id;
var patronStoreId = request.params.patron_store_id;
var rewardTitle = request.params.title;
var rewardId = parseInt(request.params.reward_id);
var numPunches = parseInt(request.params.num_punches); //comes in as string!
var customerName = request.params.name;
var messageStatusId = request.params.message_status_id;
var isOfferOrGift = (messageStatusId != null);
"""
return cloud_call(
"request_redeem", {
"patron_id": patron_id,
"store_id": store_id,
"store_location_id": store_location_id,
"patron_store_id": patron_store_id,
"title": title,
"reward_id": reward_id,
"num_punches": num_punches,
"name": name,
"message_status_id": message_status_id,
})
def test_11(self):
"""
Delete_patronstore deletes the PatronStore
"""
if PatronStore.objects().count(\
objectId=self.patron_store.objectId) == 0:
return "PatronStore does not exists. Test is invalid."
cloud_call(
"delete_patronstore", {
"patron_store_id": self.patron_store.objectId,
"patron_id": self.patron.objectId,
"store_id": self.store.objectId,
})
return PatronStore.objects().count(\
objectId=self.patron_store.objectId) == 0
def test_8(self):
"""
Add_patronstore returns existing PatronStore
"""
if PatronStore.objects().count(\
objectId=self.patron_store.objectId) == 0:
return "PatronStore does not exists. Test is invalid."
cloud_call("add_patronstore", {
"patron_id": self.patron.objectId,
"store_id": self.store.objectId,
})
return PatronStore.objects().count(Patron=self.patron.objectId,
Store=self.store.objectId) == 1 and\
PatronStore.objects().get(Patron=self.patron.objectId,
Store=self.store.objectId).objectId == self.patron_store.objectId
def test_8(self):
"""
Add_patronstore returns existing PatronStore
"""
if PatronStore.objects().count(\
objectId=self.patron_store.objectId) == 0:
return "PatronStore does not exists. Test is invalid."
cloud_call("add_patronstore", {
"patron_id": self.patron.objectId,
"store_id": self.store.objectId,
})
return PatronStore.objects().count(Patron=self.patron.objectId,
Store=self.store.objectId) == 1 and\
PatronStore.objects().get(Patron=self.patron.objectId,
Store=self.store.objectId).objectId == self.patron_store.objectId
def delete(request, employee_id):
"""
This will also remove the employee from the ACL,
delete the employee object and also delete the Parse.User object
if and only if it has no pointer to a Store or a Patron.
"""
# get from the employees_approved_list in session cache
employees_approved_list = SESSION.get_employees_approved_list(\
request.session)
i_remove, employee = 0, None
for ind, m in enumerate(employees_approved_list):
if m.objectId == employee_id:
employee = m
i_remove = ind
break
if not employee:
return redirect(reverse('employees_index')+ "?%s" %\
urllib.urlencode({'success': 'Employee has already been removed.'}))
employees_approved_list.pop(i_remove)
request.session['employees_approved_list'] =\
employees_approved_list
acc = Account.objects().get(Employee=employee.objectId)
if not acc: # employee may have been deleted
return redirect(reverse('employees_index')+ "?%s" %\
urllib.urlencode({'success': 'Employee has already been deleted.'}))
# Always save session first whenever calling a cloud code
request.session.save()
res = cloud_call("delete_employee", {"employee_id": employee.objectId})
request.session.clear()
request.session.update(SessionStore(request.session.session_key))
if 'error' not in res:
store = SESSION.get_store(request.session)
payload = {COMET_RECEIVE_KEY_NAME: COMET_RECEIVE_KEY}
if acc.objectId in store.ACL and not store.is_owner(acc):
del store.ACL[acc.objectId]
store.update()
payload["updatedStore"] = store.jsonify()
request.session['store'] = store
# only need to pass in the objectId
deleted_employee = Employee(objectId=employee.objectId)
payload["deletedEmployee"] = deleted_employee.jsonify()
comet_receive(store.objectId, payload)
return redirect(reverse('employees_index')+ "?%s" %\
urllib.urlencode({'success': 'Employee has been deleted.'}))
return redirect(reverse('employees_index')+ "?%s" %\
urllib.urlencode({'success': 'Employee has already been deleted.'}))
def send_feedback(subject, body):
""" This is a consumer action - not dashboard """
return cloud_call("send_feedback", {
"store_id": store.objectId,
"patron_id": patron.objectId,
"sender_name": patron.get_fullname(),
"subject": subject,
"body": body,
})
def delete(request, employee_id):
"""
This will also remove the employee from the ACL,
delete the employee object and also delete the Parse.User object
if and only if it has no pointer to a Store or a Patron.
"""
# get from the employees_approved_list in session cache
employees_approved_list = SESSION.get_employees_approved_list(\
request.session)
i_remove, employee = 0, None
for ind, m in enumerate(employees_approved_list):
if m.objectId == employee_id:
employee = m
i_remove = ind
break
if not employee:
return redirect(reverse('employees_index')+ "?%s" %\
urllib.urlencode({'success': 'Employee has already been removed.'}))
employees_approved_list.pop(i_remove)
request.session['employees_approved_list'] =\
employees_approved_list
acc = Account.objects().get(Employee=employee.objectId)
if not acc: # employee may have been deleted
return redirect(reverse('employees_index')+ "?%s" %\
urllib.urlencode({'success': 'Employee has already been deleted.'}))
# Always save session first whenever calling a cloud code
request.session.save()
res = cloud_call("delete_employee", {"employee_id": employee.objectId})
request.session.clear()
request.session.update(SessionStore(request.session.session_key))
if 'error' not in res:
store = SESSION.get_store(request.session)
payload = { COMET_RECEIVE_KEY_NAME: COMET_RECEIVE_KEY }
if acc.objectId in store.ACL and not store.is_owner(acc):
del store.ACL[acc.objectId]
store.update()
payload["updatedStore"] = store.jsonify()
request.session['store'] = store
# only need to pass in the objectId
deleted_employee = Employee(objectId=employee.objectId)
payload["deletedEmployee"] = deleted_employee.jsonify()
comet_receive(store.objectId, payload)
return redirect(reverse('employees_index')+ "?%s" %\
urllib.urlencode({'success': 'Employee has been deleted.'}))
return redirect(reverse('employees_index')+ "?%s" %\
urllib.urlencode({'success': 'Employee has already been deleted.'}))
def deny(request, employee_id):
""" same as delete except this uses the pending list """
# get from the employees_pending_list in session cache
employees_pending_list = SESSION.get_employees_pending_list(\
request.session)
i_remove, employee = 0, None
for ind, m in enumerate(employees_pending_list):
if m.objectId == employee_id:
employee = m
i_remove = ind
break
if not employee:
return redirect(reverse('employees_index')+ "?%s" %\
urllib.urlencode({'success': 'Pending employee not found.'}))
# update session cache for employees_pending_list
employees_pending_list.pop(i_remove)
request.session['employees_pending_list'] =\
employees_pending_list
acc = Account.objects().get(Employee=employee.objectId)
if not acc: # employee may have been deleted
return redirect(reverse('employees_index')+ "?show_pending&%s" %\
urllib.urlencode({'success': 'Employee has already been denied.'}))
# Always save session first whenever calling a cloud code
request.session.save()
res = cloud_call("delete_employee", {"employee_id": employee.objectId})
request.session.clear()
request.session.update(SessionStore(request.session.session_key))
if 'error' not in res:
payload = { COMET_RECEIVE_KEY_NAME: COMET_RECEIVE_KEY }
store = SESSION.get_store(request.session)
# no need to check acl here but just in case
if acc.objectId in store.ACL and not store.is_owner(acc):
del store.ACL[acc.objectId]
store.update()
payload["updatedStore"] = store.jsonify()
request.session['store'] = store
# only need to pass in the objectId
deleted_employee = Employee(objectId=employee.objectId)
payload["deletedEmployee"] = deleted_employee.jsonify()
comet_receive(store.objectId, payload)
return redirect(reverse('employees_index')+ "?show_pending&%s" %\
urllib.urlencode({'success': 'Employee has been denied.'}))
return redirect(reverse('employees_index')+ "?%s" %\
urllib.urlencode({'success': 'Employee has already been deleted.'}))
def add_patronstore(self, punch_count=10):
patron_store = PatronStore(**cloud_call("add_patronstore", {
"patron_id": self.patron.objectId,
"store_id": self.store.objectId,
})["result"])
patron_store.all_time_punches = punch_count
patron_store.punch_count = punch_count
patron_store.update()
return patron_store
def send_feedback(subject, body):
""" This is a consumer action - not dashboard """
return cloud_call(
"send_feedback", {
"store_id": store.objectId,
"patron_id": patron.objectId,
"sender_name": patron.get_fullname(),
"subject": subject,
"body": body,
})
def test_27(self):
"""
Validate_redeem successful
"""
res = cloud_call("validate_redeem", {
"redeem_id": self.redeem_reward.objectId,
"store_id": self.store.objectId,
})
return "error" not in res
def register_employee(first_name, last_name, username,
email, password, retailer_pin):
return cloud_call("register_employee", {
"first_name": first_name,
"last_name": last_name,
"username": username,
"password": password,
"email": email,
"retailer_pin": retailer_pin,
})
def deny(request, employee_id):
""" same as delete except this uses the pending list """
# get from the employees_pending_list in session cache
employees_pending_list = SESSION.get_employees_pending_list(\
request.session)
i_remove, employee = 0, None
for ind, m in enumerate(employees_pending_list):
if m.objectId == employee_id:
employee = m
i_remove = ind
break
if not employee:
return redirect(reverse('employees_index')+ "?%s" %\
urllib.urlencode({'success': 'Pending employee not found.'}))
# update session cache for employees_pending_list
employees_pending_list.pop(i_remove)
request.session['employees_pending_list'] =\
employees_pending_list
acc = Account.objects().get(Employee=employee.objectId)
if not acc: # employee may have been deleted
return redirect(reverse('employees_index')+ "?show_pending&%s" %\
urllib.urlencode({'success': 'Employee has already been denied.'}))
# Always save session first whenever calling a cloud code
request.session.save()
res = cloud_call("delete_employee", {"employee_id": employee.objectId})
request.session.clear()
request.session.update(SessionStore(request.session.session_key))
if 'error' not in res:
payload = {COMET_RECEIVE_KEY_NAME: COMET_RECEIVE_KEY}
store = SESSION.get_store(request.session)
# no need to check acl here but just in case
if acc.objectId in store.ACL and not store.is_owner(acc):
del store.ACL[acc.objectId]
store.update()
payload["updatedStore"] = store.jsonify()
request.session['store'] = store
# only need to pass in the objectId
deleted_employee = Employee(objectId=employee.objectId)
payload["deletedEmployee"] = deleted_employee.jsonify()
comet_receive(store.objectId, payload)
return redirect(reverse('employees_index')+ "?show_pending&%s" %\
urllib.urlencode({'success': 'Employee has been denied.'}))
return redirect(reverse('employees_index')+ "?%s" %\
urllib.urlencode({'success': 'Employee has already been deleted.'}))
def punch(request):
if request.method == "POST":
try:
nump = int(request.POST['num_punches'])
except ValueError:
return HttpResponse(json.dumps({'error': 'float'}),
content_type="application/json")
settings = SESSION.get_settings(request.session)
if nump > settings.get("punches_employee"):
return HttpResponse(json.dumps({
'error': 'over',
'limit': nump
}),
content_type="application/json")
store = SESSION.get_store(request.session)
data = {
"store_location_id":\
SESSION.get_active_store_location_id(request.session),
"store_id":store.objectId,
"store_name":str(store.get('store_name')),
"punch_code":str(request.POST['punch_code']),
"num_punches":nump,
}
# Check if the user is an employee
employee = request.session.get("employee")
if employee:
data['employee_id'] = employee.objectId
res = cloud_call("punch", data)
if 'error' not in res:
res['patron_name'] = res['result']
# always make sure to get the latest session since the session
# will be saved on return!!!
request.session.clear()
request.session.update(SessionStore(request.session.session_key))
return HttpResponse(json.dumps(res),
content_type="application/json")
else:
if res['error'] == "PATRON_NOT_FOUND":
request.session.clear()
request.session.update(
SessionStore(request.session.session_key))
return HttpResponse(json.dumps({"error":\
"PATRON_NOT_FOUND"}),
content_type="application/json")
# always make sure to get the latest session since the session
# will be saved on return!!!
request.session.clear()
request.session.update(SessionStore(request.session.session_key))
return HttpResponse(json.dumps({'error': 'error'}),
content_type="application/json")
def test_39(self):
"""
Validate_redeem fails with REDEEMREWARD_NOT_FOUND if the
RedeemReward has been deleted
"""
self.redeem_reward.delete()
return cloud_call("validate_redeem", {
"redeem_id": self.redeem_reward.objectId,
"store_id": self.store.objectId,
"reward_id": self.reward["reward_id"]
})["error"] == "REDEEMREWARD_NOT_FOUND"
def register_employee(first_name, last_name, username, email, password,
retailer_pin):
return cloud_call(
"register_employee", {
"first_name": first_name,
"last_name": last_name,
"username": username,
"password": password,
"email": email,
"retailer_pin": retailer_pin,
})
def test_20(self):
"""
Using unused punch_code returns error with PATRON_NOT_FOUND
"""
res = cloud_call("punch", {
"punch_code": "xxxxx",
"num_punches": 1,
"store_id": self.store.objectId,
"store_name": self.store.store_name,
})
return res["error"] == "PATRON_NOT_FOUND"
def punch(request):
if request.method == "POST":
try:
nump = int(request.POST['num_punches'])
except ValueError:
return HttpResponse(json.dumps({'error': 'float'}),
content_type="application/json")
settings = SESSION.get_settings(request.session)
if nump > settings.get("punches_employee"):
return HttpResponse(json.dumps({'error': 'over',
'limit': nump}), content_type="application/json")
store = SESSION.get_store(request.session)
data = {
"store_location_id":\
SESSION.get_active_store_location_id(request.session),
"store_id":store.objectId,
"store_name":str(store.get('store_name')),
"punch_code":str(request.POST['punch_code']),
"num_punches":nump,
}
# Check if the user is an employee
employee = request.session.get("employee")
if employee:
data['employee_id'] = employee.objectId
res = cloud_call("punch", data)
if 'error' not in res:
res['patron_name'] = res['result']
# always make sure to get the latest session since the session
# will be saved on return!!!
request.session.clear()
request.session.update(SessionStore(request.session.session_key))
return HttpResponse(json.dumps(res),
content_type="application/json")
else:
if res['error'] == "PATRON_NOT_FOUND":
request.session.clear()
request.session.update(SessionStore(request.session.session_key))
return HttpResponse(json.dumps({"error":\
"PATRON_NOT_FOUND"}),
content_type="application/json")
# always make sure to get the latest session since the session
# will be saved on return!!!
request.session.clear()
request.session.update(SessionStore(request.session.session_key))
return HttpResponse(json.dumps({'error': 'error'}),
content_type="application/json")
def test_35(self):
"""
Validate_redeem succeeds with PATRONSTORE_REMOVED if the
PatronStore has been deleted
"""
self.redeem_reward.is_redeemed = False
self.redeem_reward.update()
self.patron_store.delete()
return cloud_call("validate_redeem", {
"redeem_id": self.redeem_reward.objectId,
"store_id": self.store.objectId,
"reward_id": self.reward["reward_id"]
})["result"]["code"] == "PATRONSTORE_REMOVED"
def create_offer(self):
offer = Message.objects().create(**{
'subject': u'test_request_validate_redeem script message offer',
'body': u'test_request_validate_redeem script generate offer',
'sender_name': u'test_request_validate_redeem',
'store_id': self.store.objectId,
'is_read': False,
'offer_redeemed': False,
'date_offer_expiration': timezone.now()+relativedelta(days=1),
'filter': u'all',
'offer_title': u'test_request_validate_redeem script offer',
'message_type': 'offer',
})
cloud_call("retailer_message", {
"filter": offer.filter,
"store_name": self.store.store_name,
"message_id": offer.objectId,
"store_id": self.store.objectId,
"subject": offer.subject,
})
return offer
def request_redeem_offers(patron_store_id):
"""
Requests all offers in the given patron_store's MessageStatus
"""
ps = PatronStore.objects().get(objectId=patron_store_id,
include="Patron,Store")
patron, store = ps.patron, ps.store
message_statuses = patron.get("receivedMessages",
redeem_available="yes", limit=999)
for ms in message_statuses:
message = Message.objects().get(objectId=ms.Message)
cloud_call("request_redeem", {
"patron_id": ps.Patron,
"store_id": ps.Store,
"store_location_id": store.store_locations[0].objectId,
"patron_store_id": ps.objectId,
"title": message.offer_title,
"reward_id": None,
"num_punches": 0,
"name": patron.get_fullname(),
"message_status_id": ms.objectId,
})
def send_gift(receipient_patron_id):
gift_num = randint(0, 9999)
return cloud_call("send_gift", {
"store_id": "o72LmDy0YK",
"patron_id": "03yp6VcveQ",
"patron_store_id": "uNmwDYA7MN",
"sender_name": "Kentavious Teste",
"body": "My #%d gift to you. This is the body." % (gift_num, ),
"recepient_id": receipient_patron_id,
"gift_title": "The Gift Title",
"gift_description": "The gift description which is supposed "+\
"to be a bit lengthy",
"gift_punches": 1,
})
def test_10(self):
"""
Validate_redeem successful
"""
self.pt_punch_cout_b4 = self.patron_store.punch_count
self.reward_red_count_b4 = self.reward["redemption_count"]
res = cloud_call("validate_redeem", {
"redeem_id": self.redeem_reward.objectId,
"store_id": self.store.objectId,
"reward_id": self.reward["reward_id"],
})
return "error" not in res
def send_gift(receipient_patron_id):
gift_num = randint(0,9999)
return cloud_call("send_gift", {
"store_id": "o72LmDy0YK",
"patron_id": "03yp6VcveQ",
"patron_store_id": "uNmwDYA7MN",
"sender_name": "Kentavious Teste",
"body": "My #%d gift to you. This is the body." % (gift_num, ),
"recepient_id": receipient_patron_id,
"gift_title": "The Gift Title",
"gift_description": "The gift description which is supposed "+\
"to be a bit lengthy",
"gift_punches": 1,
})
def test_15(self):
"""
Reject_redeem successful
"""
# need a new redeem
self.request_redeem()
self.redeem_reward = RedeemReward.objects().get(\
PatronStore=self.patron_store.objectId, is_redeemed=False)
res = cloud_call("reject_redeem", {
"redeem_id": self.redeem_reward.objectId,
"store_id": self.store.objectId,
})
return "error" not in res
def test_37(self):
"""
Validate_redeem succeeds with insufficient if the
PatronStore does not have enough punches
"""
self.patron_store = self.add_patronstore(0)
self.request_redeem()
self.redeem_reward = RedeemReward.objects().get(\
PatronStore=self.patron_store.objectId, is_redeemed=False)
return cloud_call("validate_redeem", {
"redeem_id": self.redeem_reward.objectId,
"store_id": self.store.objectId,
"reward_id": self.reward["reward_id"]
})["result"]["code"] == "insufficient"
def test_41(self):
"""
Reject_redeem fails with REDEEMREWARD_NOT_FOUND if the
RedeemReward has been deleted
"""
self.patron_store.pending = False
self.patron_store.update()
self.request_redeem()
self.redeem_reward = RedeemReward.objects().get(\
PatronStore=self.patron_store.objectId, is_redeemed=False)
self.redeem_reward.delete()
return cloud_call("reject_redeem", {
"redeem_id": self.redeem_reward.objectId,
"store_id": self.store.objectId,
})["error"] == "REDEEMREWARD_NOT_FOUND"
def test_42(self):
"""
Reject_redeem fails with PATRONSTORE_REMOVED if the
PatronStore has been deleted
"""
self.patron_store.pending = False
self.patron_store.update()
self.request_redeem()
self.redeem_reward = RedeemReward.objects().get(\
PatronStore=self.patron_store.objectId, is_redeemed=False)
self.patron_store.delete()
return cloud_call("reject_redeem", {
"redeem_id": self.redeem_reward.objectId,
"store_id": self.store.objectId,
})["error"] == "PATRONSTORE_REMOVED"
def test_34(self):
"""
Validate_redeem succeeds with validated if the
RedeemReward has already been redeemed
"""
self.patron_store.pending_reward = False
self.patron_store.update()
self.request_redeem()
self.redeem_reward = RedeemReward.objects().get(\
PatronStore=self.patron_store.objectId, is_redeemed=False)
self.redeem_reward.is_redeemed = True
self.redeem_reward.update()
return cloud_call("validate_redeem", {
"redeem_id": self.redeem_reward.objectId,
"store_id": self.store.objectId,
"reward_id": self.reward["reward_id"]
})["result"]["code"] == "validated"
def test_40(self):
"""
Reject_redeem fails with REDEEMREWARD_VALIDATED
if the RedeemReward has already been validated
"""
self.patron_store.all_time_punches = 10
self.patron_store.punch_count = 10
self.patron_store.update()
self.request_redeem()
self.redeem_reward = RedeemReward.objects().get(\
PatronStore=self.patron_store.objectId, is_redeemed=False)
self.redeem_reward.is_redeemed = True
self.redeem_reward.update()
return cloud_call("reject_redeem", {
"redeem_id": self.redeem_reward.objectId,
"store_id": self.store.objectId,
})["error"] == "REDEEMREWARD_VALIDATED"
def request_redeem(self, reward_id=False, title=False,
message_status_id=None):
if type(reward_id) is bool:
reward_id = self.reward["reward_id"]
if type(title) is bool:
title = self.reward["reward_name"]
return cloud_call("request_redeem", {
"patron_id": self.patron.objectId,
"store_id": self.store.objectId,
"patron_store_id": self.patron_store.objectId,
"reward_id": reward_id,
"num_punches": self.reward["punches"],
"name": self.patron.get_fullname(),
"title": title,
"message_status_id": message_status_id,
})
def _retailer_message(store_id, subject, body,
date_offer_expiration, message_type, offer_title, gift_title,
gift_description, sender_name="Test Store", receiver_count=100,
is_read=False, filter="all"):
# first create the message
message = Message(store_id=store_id, subject=subject, body=body,
filter=filter, sender_name=sender_name, offer_title=offer_title,
message_type=message_type, date_offer_expiration=\
date_offer_expiration, is_read=is_read, gift_description=\
gift_description, gift_title=gift_title)
message.create()
return cloud_call("retailer_message", {
"subject": subject,
"message_id": message.objectId,
"store_id": store_id,
"store_name": sender_name,
"filter": filter,
})
def test_30(self):
"""
Reject_redeem successful
"""
# create another redeem
self.offer = self.create_offer()
self.message_status = self.patron.get("receivedMessages",
redeem_available="yes", limit=1)[0]
self.patron.receivedMessages = None
self.request_redeem(None, self.offer.offer_title,
self.message_status.objectId)
self.redeem_reward = RedeemReward.objects().get(\
MessageStatus=self.message_status.objectId,
is_redeemed=False)
res = cloud_call("reject_redeem", {
"redeem_id": self.redeem_reward.objectId,
"store_id": self.store.objectId,
})
return "error" not in res
def register_employee(first_name, last_name, username=None,
password=None, email=None, retailer_pin=None):
if username is None:
username = first_name
if password is None:
password = first_name
if email is None:
email = first_name + "@" + last_name + ".com"
if retailer_pin is None:
retailer_pin = settings.retailer_pin
return cloud_call("register_employee", {
"first_name": first_name,
"last_name": last_name,
"username": username,
"password": password,
"email": email,
"retailer_pin": retailer_pin,
})
def _request_redeem(patron_id, store_id, patron_store_id, title,
reward_id, num_punches, name, message_status_id, store_location_id):
"""
var patronId = request.params.patron_id;
var storeId = request.params.store_id;
var patronStoreId = request.params.patron_store_id;
var rewardTitle = request.params.title;
var rewardId = parseInt(request.params.reward_id);
var numPunches = parseInt(request.params.num_punches); //comes in as string!
var customerName = request.params.name;
var messageStatusId = request.params.message_status_id;
var isOfferOrGift = (messageStatusId != null);
"""
return cloud_call("request_redeem", {
"patron_id": patron_id,
"store_id": store_id,
"store_location_id": store_location_id,
"patron_store_id": patron_store_id,
"title": title,
"reward_id": reward_id,
"num_punches": num_punches,
"name": name,
"message_status_id": message_status_id,
})
def register(request):
"""
Adds a new employee to the currently logged in Store.
This automatically sets this employee to approved.
"""
data = {'employees_nav': True}
settings = SESSION.get_settings(request.session)
store = SESSION.get_store(request.session)
if request.method == "POST":
from_associated_account = False
# check if this post is from the associated account dialog
# if it is then skip form validations
aaf_nonce_id = request.POST.get('aaf-nonce')
aaf_account_id = request.POST.get('aaf-account_id')
if len(aaf_nonce_id) > 0 and len(aaf_account_id) > 0:
aa_nonce = AssociatedAccountNonce.objects.filter(\
id=aaf_nonce_id, account_id=aaf_account_id)
if len(aa_nonce) > 0 and aa_nonce[0].verified:
aa_nonce[0].delete()
from_associated_account = True
account_form = EmployeeAccountSignUpForm(request.POST)
employee_form = EmployeeForm(request.POST)
if not from_associated_account:
all_forms_valid = account_form.is_valid() and\
employee_form.is_valid()
else:
all_forms_valid = True
if all_forms_valid:
postDict = request.POST.dict()
# make the cloud call
# see cloud param for possible access level values
acl = postDict['acl']
if acl == ACCESS_ADMIN[0]:
access_level = "admin"
elif acl == ACCESS_PUNCHREDEEM[0]:
access_level = "punch_redeem"
else:
access_level = None
params = {
"retailer_pin": settings.get("retailer_pin"),
"username": postDict['email'].strip().lower(),
"first_name": postDict['first_name'].capitalize(),
"last_name": postDict['last_name'].capitalize(),
"email": postDict['email'].strip().lower(),
"status": APPROVED,
"access_level": access_level,
}
if from_associated_account:
res = cloud_call("link_employee", params)
else:
params["password"] = postDict['password']
res = cloud_call("register_employee", params)
# don't forget to retrieve the latest session
request.session.clear()
request.session.update(SessionStore(request.session.session_key))
# check if email already taken here to handle the case where
# the user already has a patron/employee account
# but also want to sign up for a Store account
if "error" in res and res['error'] in ("EMAIL_TAKEN_AVAILABLE",
"USERNAME_TAKEN_AVAILABLE"):
aa = Account.objects().get(email=postDict['email'].strip().lower())
aan = AssociatedAccountNonce.objects.create(\
account_id=aa.objectId)
return HttpResponse(json.dumps({"associated_account":\
aa.objectId, "associated_account_nonce":aan.id,
"email": aa.email, "code": 0}),
content_type="application/json")
elif "error" in res and res['error'] in ("EMAIL_TAKEN",
"USERNAME_TAKEN"):
account_form._errors.setdefault("email",
ErrorList()).append(u"Email is already being used.")
elif "error" not in res:
# add the employee to the approved list
employees_approved_list =\
SESSION.get_employees_approved_list(request.session)
employees_approved_ids =\
[ emp.objectId for emp in employees_approved_list ]
new_employee = Employee(**res["result"])
if new_employee.objectId not in employees_approved_ids:
employees_approved_list.insert(0, new_employee)
request.session['employees_approved_list'] =\
employees_approved_list
# update our local store's acl - don't wait for
# the cloud post
store = SESSION.get_store(request.session)
store.set_access_level(Account.objects().get(\
email=postDict['email'].strip().lower()), acl)
request.session['store'] = store
# notify other dashboards of this change
payload = {
COMET_RECEIVE_KEY_NAME: COMET_RECEIVE_KEY,
"updatedStore":store.jsonify()
}
comet_receive(store.objectId, payload)
return HttpResponse(json.dumps({"code": 2}),
content_type="application/json")
else:
return HttpResponse(json.dumps({"code": 3}),
content_type="application/json")
else:
employee_form = EmployeeForm(initial={"acl":\
ACCESS_PUNCHREDEEM[0]})
account_form = EmployeeAccountSignUpForm()
data["employee_form"] = employee_form
data["account_form"] = account_form
return render(request, 'manage/employee_register.djhtml', data)
def redeem(request):
""" returns json object. result is 0 if fail, 1 if success,
2 if insufficient punches, 3 if already validated,
4 if successfully deleted/denied, 5 has been deleted elsewhere and
action is deny, 6 PatronStore has been removed,
7 deleted elsewhere and action is approve.
"""
if request.method == "GET":
# approve or deny
action = request.GET.get("action")
redeemId = request.GET.get('redeemRewardId')
# may come in as "None" or "null" or "undefined"
rewardId = request.GET.get('rewardId')
if str(rewardId).isdigit():
rewardId = int(rewardId)
else:
rewardId = None
store = SESSION.get_store(request.session)
if action == "approve":
res = cloud_call("validate_redeem", {
"redeem_id":redeemId,
"store_id":store.get("objectId"),
"reward_id":rewardId,
})
elif action == "deny":
res = cloud_call("reject_redeem", {
"redeem_id":redeemId,
"store_id":store.get("objectId"),
})
# retrieve latest session since user may click a bunch
# of redemptions consecutively
session = SessionStore(request.session.session_key)
data = {"result" : 0}
# success result removed means patronstore is null!
if 'error' not in res:
redemptions_pending =\
SESSION.get_redemptions_pending(session)
i_remove = -1
if action == "approve":
result = res.get("result").get("code")
result_red =\
RedeemReward(**res.get("result").get("result"))
else:
result = res.get("result")
# remove from redemptions_pending
for i, red in enumerate(redemptions_pending):
if red.objectId == redeemId:
i_remove = i
break
# IMPORTANT! Since comet receive immediately commits
# changes to a session, i_remove will probably be -1
if action == "approve":
redemptions_past =\
SESSION.get_redemptions_past(session)
if result and result in ("insufficient",
"PATRONSTORE_REMOVED") and i_remove != -1:
redemptions_pending.pop(i_remove)
elif i_remove != -1: # success
redemption = redemptions_pending.pop(i_remove)
redemption.is_redeemed = True
redemption.updatedAt = result_red.updatedAt
redemptions_past.append(redemption)
session['redemptions_past'] =\
redemptions_past
# session changed only if i_remove was not 1
if i_remove != -1:
session['redemptions_pending'] =\
redemptions_pending
if result and result == "insufficient":
data["result"] = 2
elif result and result == "validated":
data["result"] = 3
elif result and result == "PATRONSTORE_REMOVED":
data["result"] = 6
else:
data["result"] = 1
# request.session will be saved after return
request.session.clear()
request.session.update(session)
return HttpResponse(json.dumps(data),
content_type="application/json")
elif action == "deny":
if i_remove != -1:
del_red = redemptions_pending.pop(i_remove)
session['redemptions_pending'] =\
redemptions_pending
data["result"] = 4
request.session.clear()
request.session.update(session)
return HttpResponse(json.dumps(data),
content_type="application/json")
elif 'error' in res:
if res['error'] == "REDEEMREWARD_NOT_FOUND":
if action == "approve":
data["result"] = 7
elif action == "deny":
data["result"] = 5
elif res['error'] == "REDEEMREWARD_VALIDATED":
data["result"] = 3
elif res['error'] == "PATRONSTORE_REMOVED":
data["result"] = 6
# always make sure to get the latest session since the session
# will be saved on return!!!
request.session.clear()
request.session.update(SessionStore(request.session.session_key))
return HttpResponse(json.dumps(data),
content_type="application/json")
