def account_alert_billing(session):
sub = SESSION.get_subscription(session)
if sub.get('subscriptionType') != 0 and\
sub.date_charge_failed:
return True
return False
def account_alert_billing(session):
sub = SESSION.get_subscription(session)
if sub.get('subscriptionType') != 0 and\
sub.date_charge_failed:
return True
return False
def account_message_usage(session, percent_of=None):
atype = sub_type[SESSION.get_subscription(\
session).get('subscriptionType')]
message_count = SESSION.get_message_count(session)
percent = message_count/atype['max_messages']
if(percent > 1): #don't go past 1
percent = 1
if percent_of != None:
return int(percent * percent_of)
return percent;
def account_message_usage(session, percent_of=None):
atype = sub_type[SESSION.get_subscription(\
session).get('subscriptionType')]
message_count = SESSION.get_message_count(session)
percent = message_count / atype['max_messages']
if (percent > 1): #don't go past 1
percent = 1
if percent_of != None:
return int(percent * percent_of)
return percent
def account_user_usage(session, percent_of=None):
atype = sub_type[SESSION.get_subscription(\
session).get('subscriptionType')]
num_patrons = SESSION.get_patronStore_count(session)
if atype['max_users'] == UNLIMITED:
percent = 0
else:
# may cause division by 0!!!
percent = float(num_patrons) / float(atype['max_users'])
if(percent > 1.0):
percent = 1.0
if percent_of != None:
return int(percent * percent_of)
return percent
def account_user_usage(session, percent_of=None):
atype = sub_type[SESSION.get_subscription(\
session).get('subscriptionType')]
num_patrons = SESSION.get_patronStore_count(session)
if atype['max_users'] == UNLIMITED:
percent = 0
else:
# may cause division by 0!!!
percent = float(num_patrons) / float(atype['max_users'])
if (percent > 1.0):
percent = 1.0
if percent_of != None:
return int(percent * percent_of)
return percent
def account_alert_users(session):
subscription = SESSION.get_subscription(session)
atype = sub_type[subscription.get('subscriptionType')]
num_patrons = SESSION.get_patronStore_count(session)
if atype['max_users'] == UNLIMITED:
percent = 0
else:
# may cause division by 0!!!
percent = float(num_patrons) / float(atype['max_users'])
if(percent > 1.0):
percent = 1.0
#if they are at 80 percent of their users, alert
if percent >= 1.0 or subscription.date_passed_user_limit:
return 2
elif percent >= .8:
return 1
return 0
def account_alert_users(session):
subscription = SESSION.get_subscription(session)
atype = sub_type[subscription.get('subscriptionType')]
num_patrons = SESSION.get_patronStore_count(session)
if atype['max_users'] == UNLIMITED:
percent = 0
else:
# may cause division by 0!!!
percent = float(num_patrons) / float(atype['max_users'])
if (percent > 1.0):
percent = 1.0
#if they are at 80 percent of their users, alert
if percent >= 1.0 or subscription.date_passed_user_limit:
return 2
elif percent >= .8:
return 1
return 0
def update_subscription(request):
"""
This view is also used for explicit upgrades.
"""
do_upgrade = request.GET.get("do_upgrade") is not None
if do_upgrade:
data = {'account_nav': True, 'upgrade': True}
else:
data = {'account_nav': True, 'update': True}
store = SESSION.get_store(request.session)
subscription = SESSION.get_subscription(request.session)
if request.method == 'POST':
form = SubscriptionForm(request.POST)
form.subscription = subscription # to validate cc_number
all_forms_valid = form.is_valid()
if all_forms_valid:
# upgrade account if date_passed_user_limit is on
# should fetch the most up-to-date subscription first
subscription = Subscription.objects().get(objectId=\
subscription.objectId)
upgraded = False
if subscription.date_passed_user_limit or do_upgrade:
level = subscription.get("subscriptionType")
if level == 0:
subscription.set("subscriptionType", 1)
subscription.date_passed_user_limit = None
upgraded = True
elif level == 1:
subscription.date_passed_user_limit = None
subscription.set("subscriptionType", 2)
upgraded = True
# subscription.update() called in store_cc
subscription.update_locally(request.POST.dict(), False)
d = datetime(int(request.POST['date_cc_expiration_year']),
int(request.POST['date_cc_expiration_month']), 1)
subscription.set(
"date_cc_expiration",
make_aware_to_utc(d,
SESSION.get_store_timezone(request.session)))
def invalid_card():
# add some asterisk to cc_number
if form.initial.get("cc_number"):
form.initial['cc_number'] = "*" * 12 +\
form.initial.get('cc_number')[-4:]
errs = form._errors.setdefault(\
"cc_number", ErrorList())
errs.append("Invalid credit " +\
"card. Please make sure that you provide " +\
"correct credit card information and that you " +\
"have sufficient funds, then try again.")
data['form'] = form
return render(request, 'manage/subscription_update.djhtml',
data)
res = True
# only store_cc if it is a digit (new)
if str(form.data['cc_number']).isdigit():
res = subscription.store_cc(form.data['cc_number'],
form.data['cc_cvv'], False)
if not res:
return invalid_card()
# if monthly billing failed
if subscription.date_charge_failed:
sub_cost = sub_type[subscription.get(\
"subscriptionType")]["monthly_cost"]
invoice = subscription.charge_cc(\
sub_cost, EMAIL_MONTHLY_SUBJECT, MONTHLY)
if invoice:
subscription.date_last_billed =\
subscription.date_last_billed +\
relativedelta(days=30)
subscription.date_charge_failed = None
subscription.update()
send_email_receipt_monthly_success(\
request.session['account'],
store, subscription, invoice)
else:
return invalid_card()
###########
if upgraded:
max_users = sub_type[\
subscription.subscriptionType]["max_users"]
if max_users == UNLIMITED:
max_users = "Unlimited"
package = {
"sub_type": sub_type[\
subscription.subscriptionType-1]["name"],
"new_sub_type": sub_type[\
subscription.subscriptionType]["name"],
"new_sub_type_cost": sub_type[\
subscription.subscriptionType]["monthly_cost"],
"new_max_patronStore_count": max_users,
}
send_email_account_upgrade(request.session['account'], store,
package)
# Important that this is last since invalid_card may be
# returned!
subscription.update()
# update the session cache
request.session['store'] = store
request.session['subscription'] = subscription
# notify other dashboards of these changes
payload = {
COMET_RECEIVE_KEY_NAME: COMET_RECEIVE_KEY,
"updatedSubscription": subscription.jsonify()
}
comet_receive(store.objectId, payload)
# if coming from the message edit limit reached
if do_upgrade:
if request.session.get('from_limit_reached') and\
request.session.get('message_b4_upgrade'):
# redirect back to message_edit view to process
return redirect(reverse('message_edit',
args=(0,)) + "?%s" %\
urllib.urlencode({'send_message': '1'}))
if do_upgrade:
return redirect(reverse('store_index')+ "?%s" %\
urllib.urlencode({'success':\
'Your subscription has been upgraded.'}))
else:
return redirect(reverse('store_index')+ "?%s" %\
urllib.urlencode({'success':\
'Your subscription has been updated.'}))
else:
form = SubscriptionForm()
form.initial = subscription.__dict__.copy()
# add some asterisk to cc_number
if form.initial.get("cc_number"):
form.initial['cc_number'] = "*" * 12 +\
form.initial.get('cc_number')[-4:]
if do_upgrade:
from_limit_reached =\
request.session.get("from_limit_reached")
if from_limit_reached:
data['from_limit_reached'] = from_limit_reached
# update the session cache
request.session['store'] = store
request.session['subscription'] = subscription
data['form'] = form
return render(request, 'manage/subscription_update.djhtml', data)
def edit(request, message_id):
"""
Render the message edit template for a new message and handles
send message forms.
"""
data = {'messages_nav': True, 'message_id': message_id, "filters": FILTERS}
store = SESSION.get_store(request.session)
# number of patron stores
mp = SESSION.get_patronStore_count(request.session)
# make sure cache attr is None for future queries!
store.patronStores = None
data['mp_slider_value'] = int(ceil(float(mp) * 0.50))
data['mp_slider_min'] = 1
data['mp_slider_max'] = mp
# redirect if no patrons
if not store.get("patronStores", count=1, limit=0):
return redirect(reverse("messages_index"))
# user submitted a form by form submission through POST request
# or user is coming from an upgrade sequence from subscription_update
if request.method == 'POST' or (request.method == "GET" and\
request.GET.get("send_message") and "message_b4_upgrade" in\
request.session):
if request.method == "GET":
# user is coming from an upgrade sequence from subscription_update
postDict = request.session['message_b4_upgrade'].copy()
# cleanup temp vars in session
del request.session['message_b4_upgrade']
del request.session['from_limit_reached']
else:
# user submitted a form by form submission through POST request
postDict = request.POST.dict().copy()
# populate a message form with the POST data for validation
form = MessageForm(postDict)
if form.is_valid():
# form is valid so continue to send the message
subscription = SESSION.get_subscription(request.session)
subType = subscription.get('subscriptionType')
# refresh the message count - make sure we get the one in the cloud
if 'message_count' in request.session:
del request.session['message_count']
message_count = SESSION.get_message_count(request.session)
# get the max_messages from the user's subscriptionType
# or the highest level if god_mode is on
if subscription.god_mode:
max_messages = sub_type[2]['max_messages']
else:
max_messages = sub_type[subType]['max_messages']
# limit is reached if the amount of messages sent this
# billing cycle passed the amount for that subscription type
limit_reached = message_count >= max_messages
# We always enforce the limit when we are in production
# otherwise, we ignore it if we have message_limit_off in our session
if limit_reached and (PRODUCTION_SERVER or\
(not PRODUCTION_SERVER and "message_limit_off" not in request.session)):
data['limit_reached'] = limit_reached
# not the highest level of subscription so an upgrade
# is still possible
if subType != 2:
# save the dict to the session
request.session['message_b4_upgrade'] =\
request.POST.dict().copy()
# the highest level of subscription so no more
# upgrades can occur - therefore maxed_out
elif subType == 2:
data['maxed_out'] = True
else:
# limit has not yet been reached - send the message
# build the message from session and POST data
message = Message(\
sender_name=store.get('store_name'),
store_id=store.objectId
)
message.update_locally(postDict, False)
# check if attach offer is selected
if 'attach_offer' in postDict:
# message has an offer - extract it from the post
# post data ensuring proper datetime format
d = parser.parse(postDict['date_offer_expiration'])
d = make_aware_to_utc(
d, SESSION.get_store_timezone(request.session))
message.set('date_offer_expiration', d)
message.set('message_type', OFFER)
else:
# make sure to delete offer information in the case
# that attach offer is not checked but the form
# submitted still contained offer information
message.set('offer_title', None)
message.set('date_offer_expiration', None)
message.set('message_type', BASIC)
# actually create the message to Parse
message.create()
# put the message in the template context for rendering
data['message'] = message
# add to the store's relation
store.add_relation("SentMessages_", [message.objectId])
# prepare the parameters for the cloud call
params = {
"store_id": store.objectId,
"store_name": store.get('store_name'),
"subject": message.get('subject'),
"message_id": message.objectId,
"filter": message.filter,
}
# process the filter option
if message.filter == "idle":
# pass in the correct idle_date which is today
# minus the days specified by idle_latency
idle_days = postDict['idle_latency']
d = timezone.now() + relativedelta(days=\
-1*int(idle_days))
params.update({"idle_date": d.isoformat()})
elif message.filter == "most_loyal":
# pass in the number of patrons
params.update({"num_patrons": postDict['num_patrons']})
# update store and message_count in session cache
request.session['message_count'] = message_count
request.session['store'] = store
# save session- cloud_call may take a while!
request.session.save()
# make the cloud call
res = cloud_call("retailer_message", params)
if "error" not in res and res.get("result"):
message.set("receiver_count",
res.get("result").get("receiver_count"))
# notify other tabs and windows that are logged into
# this store about the new message sent.
payload = {
COMET_RECEIVE_KEY_NAME: COMET_RECEIVE_KEY,
"newMessage": message.jsonify()
}
comet_receive(store.objectId, payload)
# Note that the new message is saved in comet_receive
# make sure we have the latest session to save!
request.session.clear()
request.session.update(
SessionStore(request.session.session_key))
return HttpResponseRedirect(message.get_absolute_url())
elif 'num_patrons' in form.errors:
# form is invalid due to the number of patrons input
# for most_loyal filter
data['error'] = "Number of customers must be a "+\
"whole number and greater than 0."
else:
# form has some errors
data['error'] = "The form you submitted has errors."
else:
# check if the incoming request is for an account upgrade
if request.GET.get("do_upgrade"):
# flag the upgrade view
request.session["from_limit_reached"] = True
# redirect to upgrade account
return HttpResponseRedirect(reverse("subscription_update") +\
"?do_upgrade=1")
if message_id in (0, '0'):
# this is a new message so just instantiate a new form
form = MessageForm()
else:
# this is an existing message that the user wants to view
# inserting this success and error message into the template
# should be done in a cleaner way - this was done by the
# first guy. I just didn't bother changing it.
if request.GET.get("error"):
data['error'] = request.GET.get("error")
if request.GET.get("success"):
data['success'] = request.GET.get("success")
# get from the messages_sent_list in session cache
messages_sent_list = SESSION.get_messages_sent_list(\
request.session)
for m in messages_sent_list:
if m.objectId == message_id:
data['message'] = m
if data['message']:
# message is found so fill up the form with its data
form = MessageForm(data['message'].__dict__.copy())
else:
# message not found so just instantiate a new form
form = MessageForm()
# update store session cache
request.session['store'] = store
# inject the form in the template context for rendering
data['form'] = form
return render(request, 'manage/message_edit.djhtml', data)