def add_event(self, obj):
updates = dict([('Msg %d' % i, msg)
for i, msg in enumerate(self.updates)])
add_event.delay(customer_id=obj.customer_id,
event='changed-order-preferences',
data=updates,
order_id=obj.id)
def add_event(self):
"""Fire Intercom event about processed order."""
if self.is_gear:
event_name = 'gear-order-processed'
extra_event_data = {'gear-order': self.order.id}
order_id = None
else:
event_name = 'order-processed'
extra_event_data = {}
order_id = self.order.id
charge = self.result.get('charge', {})
event_data = {
'old_status': self.original_status,
'new_status': self.order.get_status_display(),
'stripe_charge': charge.get('id'),
'error': self.result.get('error'),
}
event_data.update(extra_event_data)
add_event.delay(
customer_id=self.customer.id,
event=event_name,
data=event_data,
order_id=order_id,
)
def logged_out(sender, request, user, **kwargs):
# FIXME: How and why an user haven't relation to customer?
if user:
try:
customer_id = user.customer.id
except Customer.DoesNotExist:
pass
else:
add_event.delay(customer_id=customer_id, event='logged-out')
def add_event(self, obj):
add_event.delay(customer_id=obj.order.customer_id,
event='leave_coffee_review',
data={
'rating': obj.rating,
'comment': obj.comment,
'used brew': obj.brew.name
},
order_id=obj.order_id)
def add_event(self, obj):
add_event.delay(
customer_id=obj.user.customer.id,
event='redeemed-reward',
data={
'redem': {
'value':
obj.item.name,
'url': ('https://hookcoffee.com.sg/admin/loyale/redemitem'
'/%d/' % obj.id)
}
})
def add_event(self, obj):
add_event.delay(
customer_id=obj.customer_id,
event='created_address',
data={
'address': {
'value':
str(obj),
'url': ('https://hookcoffee.com.sg/admin/customers/address'
'/%d/' % obj.id)
}
})
def add_event(self, obj):
# will not be called if it's base address (address_id == -1)
add_event.delay(
customer_id=obj.customer_id,
event='changed_primary_address',
data={
'primary_address': {
'value':
str(obj),
'url': ('https://hookcoffee.com.sg/admin/customers/address'
'/%d/' % obj.id)
}
})
def logged_in(sender, request, user, **kwargs):
# FIXME: How and why an user haven't relation to customer?
try:
customer_id = user.customer.id
except Customer.DoesNotExist:
pass
else:
add_event.delay(customer_id=customer_id, event='logged-in')
try:
cart = ShoppingCart.objects.get(customer=user.customer)
request.session['shopping-cart'] = json.loads(cart.content)
except ShoppingCart.DoesNotExist:
pass
def get(self, request, *args, **kwargs):
now = CTZ.normalize(timezone.now())
self.token = self.kwargs.get('token')
self.object = self.get_object(request)
if self.object:
f = self.form_class(request.GET, instance=self.object.order)
if self.form_valid(f):
if type(f) == SkipDeliveryForm:
f.save()
# self.object.order.shipping_date = self.object.order.get_next_shipping_date(
# after=self.object.order.shipping_date)
# self.object.order.save()
if self.object.order.interval >= 7:
rsd = ReminderSkipDelivery(
username=self.object.order.customer.first_name,
order=self.object.order,
email=self.object.order.customer.get_email(),
from_email='Hook Coffee Roastery <*****@*****.**>',
subject='Your upcoming Hook Coffee Order',
template_name=OrderProcessing.EMAIL_REMINDING_TEMPLATE_SKIP_LINK,
created=now,
# TODO: check scheduled date
scheduled=self.object.order.shipping_date - timedelta(days=4),
)
rsd.save()
messages.add_message(request, messages.INFO, "Your subscription shipping date has been changed successfuly", extra_tags="skip")
add_event.delay(
customer_id=self.object.customer.id,
event='skipped',
data={
'order-id': self.object.order.id,
'shipping-date': self.object.order.shipping_date,
}
)
self.object.active = False
self.object.save()
return redirect('profile')
def send_invites(self):
user = self.request.user
customer = user.customer
contacts = self.cleaned_data.get('contacts', [])
ref, created = Referral.objects.get_or_create(
user=user,
defaults={'code': Referral.get_random_code(customer=customer)})
ref_link = self.request.build_absolute_uri(ref.get_absolute_url())
total_invited = customer.get_friends_invited()
for email, name in contacts:
try:
with transaction.atomic():
# Send invitation email
self._send_email(customer=customer,
recipient_name=name,
recipient_email=email,
ref_link=ref_link)
# Grant beanie points for invited friend
# ernest asked not to grant points anymore
# point_mixin.grant_points(
# user=user, points=POINTS_FOR_INVITED_FRIEND)
# Give special surprise for every 20 friends
# if (total_invited + 1) % 20 == 0:
# point_mixin.redem_item(user=user, item=self.reward)
except Exception:
logger.error('Send ref email. From: %s To: %s',
customer,
email,
exc_info=True)
else:
total_invited += 1
# self.result['points_earned'] += POINTS_FOR_INVITED_FRIEND
self.result['friends_invited'] += 1
if self.result['friends_invited']:
self.result['success'] = True
add_event.delay(customer_id=customer.id,
event='referral-friends',
data=self.result)
return self.result
def post(self, request, *args, **kwargs):
customer = request.user.customer
already_answered = customer.extra.get('answered_exp_survey', False)
if already_answered:
logger.info(
'User %s trying to submit the exp survey more than once.' %
customer)
return HttpResponse(status=200)
customer.extra['answered_exp_survey'] = True
customer.save()
# Give beanie points in 24h, when the system get his answers
give_points_for_exp_survey.apply_async(
(customer.id, ), countdown=180) # run in 2 minutes
# Fire intercom event
add_event.delay(customer_id=customer.id,
event='answered-the-exp-survey')
return HttpResponse(status=200)
def add_event(self, obj):
if isinstance(obj, Order):
event = ('canceled-subscription'
if obj.recurrent else 'cancel-one-off')
add_event.delay(customer_id=obj.customer.id,
event=event,
order_id=obj.id)
else:
event = 'cancel-gear-order'
add_event.delay(
customer_id=obj.customer.id,
event=event,
data={
'gear': {
'value':
obj.gear.name,
'url':
('https://hookcoffee.com.sg/admin/customers/gearorder'
'/%d/' % obj.id)
}
})
def process_global_orders(request):
ctz = timezone.get_current_timezone()
now = ctz.normalize(timezone.now())
day = now.isoweekday()
# today = now.replace(
# hour=12, minute=0, second=0, microsecond=0)
tomorrow = now.replace(hour=12, minute=0, second=0,
microsecond=0) + timedelta(days=1)
two_days_later = now.replace(hour=12, minute=0, second=0,
microsecond=0) + timedelta(days=2)
three_days_later = now.replace(hour=12, minute=0, second=0,
microsecond=0) + timedelta(days=3)
my_shipping_date = tomorrow
if day == 5:
my_shipping_date = three_days_later
elif day == 6:
my_shipping_date = two_days_later
customer = Customer.objects.select_related('user').get(
id=int(request.POST.get('customer')))
orders = Order.objects.filter(
customer=customer,
shipping_date__lte=my_shipping_date,
status__in=[Order.ACTIVE, Order.PAUSED, Order.ERROR])
event_name = 'global-order-processed'
for order in orders:
order_orig_status = order.get_status_display()
order.status = Order.SHIPPED
order.save()
logger.debug(
'PROCESS GLOBAL ORDER: order id: {}, customer: {}, country: {}'.
format(order.id, order.customer, order.customer.country))
if order.coffee.brew_method.name == 'Nespresso':
points = OrderPoints.objects.latest('id').one_pod
elif order.coffee.special:
points = OrderPoints.objects.latest('id').one_special
else:
points = OrderPoints.objects.latest('id').one_regular
point_mixin.grant_points(user=order.customer.user, points=points)
logger.debug(
'GRANT BEANIE POINTS: order id: {}, customer: {}, points: {}'.
format(order.id, order.customer, points))
event_data = {
'old_status': order_orig_status,
'new_status': order.get_status_display(),
}
add_event.delay(
customer_id=customer.id,
event=event_name,
data=event_data,
order_id=order.id,
)
messages.add_message(request, messages.INFO, "activate worldwide tab")
return redirect('dashboard')
else:
event_name = 'order-processed'
extra_event_data = {}
order_id = order.id
event_data = {
'old_status': order_orig_status,
'new_status': order.get_status_display(),
'stripe_charge': charge.get('id'),
'error': context.get('error'),
}
event_data.update(extra_event_data)
add_event.delay(
customer_id=customer.id,
event=event_name,
data=event_data,
order_id=order_id,
)
return order
def process_global_orders(request):
ctz = timezone.get_current_timezone()
now = ctz.normalize(timezone.now())
day = now.isoweekday()
# today = now.replace(
# hour=12, minute=0, second=0, microsecond=0)
tomorrow = now.replace(hour=12, minute=0, second=0,
microsecond=0) + timedelta(days=1)
def do_registration(request, is_nespresso):
now = CTZ.normalize(timezone.now())
result = context = {}
isBottled = request.session.get('isBottled')
if request.method == "POST":
email = request.session.get('email')
if 'one-password1' in request.POST:
rf = CustomRegistrationForm(request.POST, prefix='one')
if rf.is_valid():
result['success'] = True
details = json.loads(request.POST.get('array'))
logger.debug('Registration: first step: %s; details: %s',
email, details)
request.session['email'] = rf.cleaned_data['email']
request.session['password'] = generate_securerandompass(64) if 'accesstoken' in request.session \
else request.POST['one-password1']
request.session['brew'] = details['brew']
request.session['package'] = details['package']
request.session['interval'] = details['interval']
request.session['different'] = details['different']
mailchimp_subscribe.delay(email=request.session.get('email'))
else:
return HttpResponse(json.dumps(rf.errors))
if 'two-first_name' in request.POST:
cf = GS_CustomerForm(request.POST, prefix='two')
pf = GS_PreferencesForm(request.POST, prefix='tri')
if cf.is_valid():
result['success'] = True
request.session['first_name'] = request.POST['two-first_name']
request.session['last_name'] = request.POST['two-last_name']
request.session['country'] = request.POST.get(
'two-country', 'SG')
request.session['line1'] = request.POST['two-line1']
request.session['line2'] = request.POST['two-line2']
request.session['postcode'] = request.POST['two-postcode']
request.session['phone'] = request.POST['two-phone']
mailchimp_subscribe.delay(
email=request.session.get('email'),
merge_vars={
'FNAME': request.session.get('first_name'),
'LNAME': request.session.get('last_name'),
},
)
else:
return HttpResponse(json.dumps(cf.errors))
if 'voucher' in request.POST:
try:
user = MyUser(email=request.session['email'])
user.set_password(request.session['password'])
user.save()
logger.debug('User created: %s', user)
except Exception:
logger.error('User not created: %s', email, exc_info=True)
try:
customer = Customer.objects.create(
user=user,
first_name=request.session['first_name'],
last_name=request.session['last_name'],
amount=request.session.get('credits', 0),
country=request.session['country'],
line1=request.session['line1'],
line2=request.session['line2'],
postcode=request.session['postcode'],
phone=request.session['phone'],
stripe_id=request.session['stripe_id'],
card_details='{}{}{}'.format(
request.session.get('last4'),
'{:0>2}'.format(request.session.get('exp_month')),
request.session.get('exp_year')))
logger.debug('Customer created: %s', customer)
# Add newly created customauth as a Foreign Key reference to FacebookCustomer
try:
facebook_customer = FacebookCustomer.objects.filter(
email=email).update(customer=user)
if facebook_customer:
add_tag.delay(customer_id=customer.id, tag='Facebook')
except Exception:
logger.error('Cannot update FacebookCustomer: %s',
email,
exc_info=True)
except Exception:
logger.error('Customer not created: %s', email, exc_info=True)
try:
if request.session.get('from_preregister'):
response = None
preferences = Preferences(customer=customer)
preferences.coffee = coffee = CoffeeType.objects.get(
id=request.session.get('coffee'))
else:
response = GetStartedResponse.objects.filter(
email=user.email).latest('created')
flavor_ids = []
for ch in response.form_details['flavour']:
if ch.isdigit():
flavor_ids.append(int(ch))
flavors = []
for flav in flavor_ids:
flavors.append(Flavor.objects.get(id=flav))
preferences = Preferences(customer=customer)
preferences.coffee = coffee = CoffeeType.objects.get(
id=request.session.get('coffee', response.ct))
preferences.save()
preferences.intense = response.form_details['intensity']
preferences.flavor = flavors
except Exception:
preferences = Preferences(customer=customer)
preferences.coffee = coffee = CoffeeType.objects.get(
id=request.session.get('coffee'))
if request.session.get('alacarte'):
price = coffee.amount_one_off
else:
price = coffee.amount
preferences.interval = int(request.session['interval'])
preferences.interval_pods = int(request.session['interval'])
preferences.different = True if request.session[
'different'] else False
preferences.different_pods = True if request.session[
'different'] else False
if is_nespresso:
preferences.brew = BrewMethod.objects.get(name_en='None')
preferences.package = Preferences.DRIP_BAGS
else:
try:
if response:
brew = BrewMethod.objects.get(
id=response.form_details['method'])
else:
brew_id = request.session.get('brew')
if brew_id:
brew = BrewMethod.objects.get(id=brew_id)
else:
brew_title = request.session.get(
'brew_title') or _('None')
brew = BrewMethod.objects.get(name=brew_title)
preferences.brew = brew
except Exception:
brew_title = request.session.get('brew_title') or _('None')
brew = BrewMethod.objects.get(name=brew_title)
preferences.brew = brew
preferences.package = request.session['package']
preferences.save()
# common voucher
try:
voucher = Voucher.objects.get(
name=request.session.get('voucher'))
price -= price * voucher.discount / 100 + voucher.discount2
# Mark voucher as used for current customer
customer.vouchers.add(voucher)
customer.save()
voucher.count += 1
voucher.save()
except:
voucher = None
try:
# referral voucher
referral_voucher = ReferralVoucher.objects.get(
code=request.session.get('referral_voucher'))
price -= price * referral_voucher.discount_percent / 100 + referral_voucher.discount_sgd
referral_voucher.used = True
referral_voucher.save()
except Exception:
referral_voucher = None
if request.session.get('alacarte') or \
request.session.get('gift'):
is_recurrent = False
else:
is_recurrent = True
if START_DATE <= now <= END_DATE:
shipping_date = NEW_DATE
else:
shipping_date = get_shipping_date()
if isBottled:
brew_method = BrewMethod.objects.get(name_en='Cold Brew')
preferences.brew = brew_method
preferences.package = Preferences.BOTTLED
preferences.different = False
preferences.save()
elif is_nespresso:
brew_method = BrewMethod.objects.get(name_en='Nespresso')
else:
try:
brew_method = BrewMethod.objects.get(
id=request.session['brew'])
preferences.brew = brew_method
preferences.save()
except Exception:
brew_method = preferences.brew
try:
order = createOrder(p_customer=customer,
p_coffee=coffee,
p_shipping_date=shipping_date,
p_price=price,
p_preferences=preferences,
p_is_recurrent=is_recurrent,
p_brew_method=brew_method,
p_voucher=voucher,
p_package=preferences.package,
is_nespresso=is_nespresso)
order.save()
if voucher:
if voucher.name in settings.GIFT_VOUCHERS:
order.details[voucher.name] = True
order.save()
if referral_voucher:
order.details['referred_by'] = '{} {}'.format( \
referral_voucher.sender.first_name, referral_voucher.sender.last_name)
order.save()
add_event.delay(customer_id=customer.id,
event='signed-up',
data={'credits': round(customer.amount, 2)})
add_event.delay(customer_id=customer.id,
event='created-subscription'
if is_recurrent else 'created-one-off',
order_id=order.id)
except Exception:
order = None
if not request.session.get('active_tab') and is_nespresso:
request.session['active_tab'] = 'active_subscriptions_pods'
# Create referral code for new user
Referral.objects.create(
user=user, code=Referral.get_random_code(customer=customer))
# Use referral link
ref = request.session.get('ref')
if ref or referral_voucher:
referrer = user
if ref:
referred = Referral.objects.get(code=ref).user
else:
referred = referral_voucher.sender.user
Reference.objects.create(referrer=referrer, referred=referred)
logger.debug('Reference created: %s <-- %s', referred,
referrer)
current_customer = referred.customer
add_event.delay(customer_id=current_customer.id,
event='reference-created',
data={
'referred': referred.email,
'referrer': referrer.email
})
referrer_customer = Customer.objects.get(user_id=referrer.id)
add_event.delay(customer_id=referrer_customer.id,
event='reference-created',
data={
'referred': referred.email,
'referrer': referrer.email
})
# add %50 discount to customer's available discounts
referrals = json.loads(referred.customer.discounts['referral'])
new_discount = (50,
timezone.now().strftime('%Y-%m-%dT%H:%M:%S%z'))
referrals.append(new_discount)
referred.customer.discounts['referral'] = referrals
referred.customer.save()
add_event.delay(customer_id=current_customer.id,
event='give-$50-to-referrer',
data={
'discount': new_discount[0],
'date': new_discount[1]
})
cnt = Reference.objects.filter(referred=referred).count()
if cnt == 2:
try:
current_order = Order.objects \
.filter(customer=current_customer) \
.filter(status__in=['AC', 'PA']) \
.latest('date')
current_order.details['KeepCup'] = True
current_order.save()
except Order.DoesNotExist:
pass
Reminder.objects.filter(email=user.email).update(completed=True)
for reminder in Reminder.objects.filter(email__iexact=user.email):
reminder.disable_voucher()
new_user = authenticate(email=user.email,
password=request.session['password'])
login(request, new_user)
context = {
'coffee': coffee.name,
'image': coffee.img.url,
'order_price': order.amount if order else coffee.amount,
}
Reminder.objects.create(
username="******".format(customer.first_name.title(),
customer.last_name.title()),
email=customer.user.email,
order=order,
from_email='Ernest from Hook Coffee <*****@*****.**>',
subject="Ahoy, {}!".format(customer.first_name.title()),
template_name='EJ1',
# scheduled=now + timedelta(hours=1),
scheduled=now + timedelta(minutes=1), # TODO: remove
voucher=voucher)
ReminderSMS.objects.create(
customer=customer,
# WARNING: actual message generated in tasks module
message=ReminderSMS.MESSAGE % customer.first_name.title(),
# will be replaced with sms schedule date on save
scheduled=shipping_date,
)
# update campaign status to subscribed if from a campaign
mailing_list.update_mailchimp_tracking(
request, order, MailchimpCampaignStats.PURCHASED)
request.session['voucher'] = ""
new_purchase_amount = float(price)
request.session['new_purchase_amount'] = new_purchase_amount
return render(request, 'get_started/thankyou.html', context)
return result
else:
username = email = coffee = default_pack = brew_title = voucher_name = ''
price = 0
data = {}
render_data = {}
logger.debug('Registration:init:%s:%s', get_client_ip(request),
get_session_data(request))
if not request.session.get('from_shopping_cart'):
try:
data['username'] = request.session.get('name')
data['email'] = request.session.get('email')
default_pack = request.session.get('default_pack') \
or Preferences.WHOLEBEANS
if request.session.get('V60STARTER'):
default_pack = Preferences.GRINDED
brew_title = request.session.get('brew_title') or _('Espresso')
except Exception:
logger.error('Registration:init:%s:%s',
get_client_ip(request),
get_session_data(request),
exc_info=True)
# Check if it's registration by ref link without ReferralVoucher
# for example by FB or [copy ref link and share your own way]
ref_code = request.session.get('ref')
if ref_code:
try:
referral = Referral.objects.get(code=ref_code)
except Referral.DoesNotExist:
pass
else:
# If referral voucher doesn't exists - create and use it
ref_voucher, created = ReferralVoucher.objects.get_or_create(
sender=referral.user.customer,
recipient_email=request.session.get('email', ''),
defaults={
# 'discount_percent': 50,
'discount_sgd': 12,
'code': ReferralVoucher.get_random_code(size=8),
})
# If referral voucher created right now it means that
# customer didn't get points for inviting the friend
# (one of the methods above).
if created:
point_mixin.grant_points(
user=referral.user,
points=POINTS_FOR_INVITED_FRIEND)
request.session['chosen_voucher'] = ref_voucher.code
try:
coffee = CoffeeType.objects.get(
id=request.session.get('coffee'))
if request.session.get('alacarte'):
price = coffee.amount_one_off
else:
price = coffee.amount
except Exception:
coffee = None
try:
voucher = Voucher.objects.get(name=request.session['voucher'])
if voucher:
price -= price * voucher.discount / 100 + voucher.discount2
except:
pass
try:
referral_voucher = ReferralVoucher.objects.get(
code=request.session.get('referral_voucher'))
if referral_voucher:
price -= price * referral_voucher.discount_percent / 100 + referral_voucher.discount_sgd
except:
pass
brew_methods = BrewMethod.objects.sorted(~Q(name_en='Nespresso'))
rf = CustomRegistrationForm(prefix='one', initial=data)
cf = GS_CustomerForm(prefix='two')
pf = GS_PreferencesForm(prefix='tri')
af = AuthenticationForm(prefix='four')
naf = AddressForm()
show_login_form = request.session.get(
'from_preregister') and not request.user.is_authenticated
show_active_subs = False
show_subscription_form = False
show_sub_details = False
active_subscriptions = []
if request.user.is_authenticated:
customer = request.user.customer
try:
coffee = CoffeeType.objects.get(id=request.session.get('coffee'))
except CoffeeType.DoesNotExist:
coffee = None
nespresso = BrewMethod.objects.get(name='Nespresso')
is_pods = False
if coffee != None:
if nespresso in coffee.brew_method.all():
is_pods = True
all_active_subscriptions = Order.objects.filter(customer=customer,
status=Order.ACTIVE,
recurrent=True)
active_subscriptions = [[x.id, x.coffee.name, x.coffee.img.url, x.address.name if x.address else 'Base address']\
for x in all_active_subscriptions
if ((nespresso in x.coffee.brew_method.all()) == is_pods and x.is_editable)]
if len(active_subscriptions):
show_active_subs = True
else:
show_sub_details = not (show_login_form and show_subscription_form
and show_active_subs)
# get available addresses
addresses = Address.objects.filter(customer=customer)
addresses = [{
'id':
x.id,
'name':
x.name,
'country':
str(x.country),
'line1':
x.line1,
'line2':
x.line2,
'postcode':
x.postcode,
'customer_name':
'{} {}'.format(customer.first_name, customer.last_name),
} for x in addresses]
render_data['base_address'] = json.dumps({
'id':
-1,
'country':
str(customer.country),
'line1':
customer.line1,
'line2':
customer.line2,
'postcode':
customer.postcode,
'customer_name':
'{} {}'.format(customer.first_name, customer.last_name),
})
render_data['addresses'] = json.dumps(addresses)
else:
show_subscription_form = not show_login_form
render_data['addresses'] = []
render_data['base_address'] = {}
active_subscriptions = json.dumps(active_subscriptions)
render_data['reg_form'] = rf
render_data['cus_form'] = cf
render_data['pre_form'] = pf
render_data['auth_form'] = af
render_data['new_address_form'] = naf
render_data['coffee'] = coffee
render_data['isNespresso'] = is_nespresso
render_data['price'] = "{0:.0f}".format(price)
render_data['brew_title'] = brew_title
render_data['brew_methods'] = brew_methods
render_data['alacarte'] = request.session.get('alacarte')
render_data['isBottled'] = isBottled
render_data['default_pack'] = default_pack
render_data['shipping_date'] = get_shipping_date()
render_data['stripe_key'] = settings.PUBLISHABLE_KEY
render_data['show_login_form'] = show_login_form
render_data['show_subscription_form'] = show_subscription_form
render_data['show_active_subs'] = show_active_subs
render_data['show_sub_details'] = show_sub_details
render_data['active_subscriptions'] = active_subscriptions
render_data['estimated_date'] = get_estimated_date
return render(request, 'get_started/registration.html', render_data)
def add_event(self, obj):
add_event.delay(customer_id=obj.customer_id,
event=('created-subscription'
if obj.recurrent else 'created-one-off'),
order_id=obj.id)
def taster5x(request):
result = context = {}
if request.method == "POST":
if 'one-password1' in request.POST:
rf = CustomRegistrationForm(request.POST, prefix='one')
if rf.is_valid():
result['success'] = True
request.session['email'] = rf.cleaned_data['email']
request.session['password'] = request.POST['one-password1']
mailchimp_subscribe.delay(email=request.session.get('email'))
else:
errors = rf.errors
return HttpResponse(json.dumps(errors))
if 'two-first_name' in request.POST:
cf = GS_CustomerForm(request.POST, prefix='two')
pf = GS_PreferencesForm(request.POST, prefix='tri')
if cf.is_valid():
result['success'] = True
request.session['first_name'] = request.POST['two-first_name']
request.session['last_name'] = request.POST['two-last_name']
request.session['line1'] = request.POST['two-line1']
request.session['line2'] = request.POST['two-line2']
request.session['postcode'] = request.POST['two-postcode']
mailchimp_subscribe.delay(
email=request.session.get('email'),
merge_vars={
'FNAME': request.session.get('first_name'),
'LNAME': request.session.get('last_name'),
},
)
else:
errors = cf.errors
return HttpResponse(json.dumps(errors))
if 'stripeToken' in request.POST:
try:
user = MyUser(email=request.session['email'])
user.set_password(request.session['password'])
user.save()
except Exception as e:
print e
try:
customer = Customer(
user=user,
first_name=request.session['first_name'],
last_name=request.session['last_name'],
line1=request.session['line1'],
line2=request.session['line2'],
postcode=request.session['postcode'],
stripe_id=request.session['stripe_id']
)
customer.save()
add_event.delay(
customer_id=customer.id,
event='signed-up',
data={'taster5x': True})
except Exception as e:
print e
random_coffee = CoffeeType.objects.bags().filter(
special=False).first()
preferences = Preferences(
customer=customer,
coffee=random_coffee,
brew=BrewMethod.objects.get(name_en='None'),
package=Preferences.DRIP_BAGS
)
preferences.save()
taster5x = CoffeeType.objects.get(name='Taster 5x')
try:
voucher = Voucher.objects.get(name='Taster 5x')
voucher.count += 1
voucher.save()
except:
voucher = Voucher(
name='Taster 5x',
discount=0,
count=1
)
voucher.save()
try:
order = Order.objects.create(
customer=customer,
coffee=taster5x,
date=timezone.now(),
shipping_date=get_shipping_date(),
amount=taster5x.amount,
status=Order.ACTIVE,
brew=preferences.brew,
package=preferences.package,
interval=0,
voucher=voucher
)
add_event.delay(
customer_id=customer.id,
event='created-taster5x',
order_id=order.id)
except Exception as e:
print e
new_user = authenticate(email=user.email,
password=request.session['password'])
login(request, new_user)
context = {
'coffee': taster5x.name,
'image': taster5x.img.url,
}
# Send reminding email in a week
ctz = timezone.get_current_timezone()
now = ctz.normalize(timezone.now())
# If there are other reminders (for example from Gets Started)
# mark they as completed
Reminder.objects.filter(email=user.email).update(completed=True)
# Send email in a week if taster pack
Reminder.objects.create(
username=customer.first_name,
email=customer.user.email,
from_email='Hook Coffee <*****@*****.**>',
subject='Which was your favourite?',
template_name='Which was your favourite?',
scheduled=now + timedelta(days=7),
)
# Send summary email
send_email_async.delay(
subject='Welcome on board!',
template='O1 - First order on a subscription (done)',
to_email=customer.get_email(),
from_email='Ernest from Hook Coffee <*****@*****.**>',
merge_vars={
'USERNAME': customer.first_name,
'DOMAIN_NAME': request.META.get('HTTP_HOST'),
}
)
return render(request, 'get_started/thankyou-trial.html', context)
return result
else:
rf = CustomRegistrationForm(prefix='one')
cf = GS_CustomerForm(prefix='two')
pf = GS_PreferencesForm(prefix='tri')
context['reg_form'] = rf
context['cus_form'] = cf
context['pre_form'] = pf
context['stripe_key'] = settings.PUBLISHABLE_KEY
return render(request, 'taster/taster5x.html', context)
def detail(request, coffee_id):
if request.method == 'POST':
print 'detail, POST =', request.POST.items()
coffee_id = request.POST.get('coffee-id')
try:
coffee = CoffeeType.objects.get(id=coffee_id)
customer = request.user.customer
preferences = customer.preferences
except:
coffee = customer = preferences = None
if 'one-off' in request.POST:
if coffee:
if not request.POST.get('isNespresso'):
selected_brew = BrewMethod.objects.get(
id=request.POST.get('brew-method'))
selected_package = request.POST.get('package-method', )
else:
selected_brew = BrewMethod.objects.get(name_en='Nespresso')
selected_package = Preferences.DRIP_BAGS
order = Order.objects.create(
customer=customer,
coffee=coffee,
date=timezone.now(),
shipping_date=get_shipping_date(),
amount=coffee.amount_one_off,
interval=0,
recurrent=False,
status=Order.ACTIVE,
brew=selected_brew,
package=selected_package,
)
mailing_list.update_mailchimp_tracking(
request, order, MailchimpCampaignStats.PURCHASED)
request.session['active_tab'] = 'active_one_offs'
new_purchase_amount = float(order.amount)
request.session['new_purchase_amount'] = new_purchase_amount
add_event.delay(customer_id=order.customer.id,
event='created-one-off',
order_id=order.id)
if 'subscription' in request.POST:
if preferences and coffee:
if request.POST.get('isNespresso') == 'False':
request.session['active_tab'] = 'active_subscriptions'
brew = preferences.brew or BrewMethod.objects.get(
name_en='Espresso')
else:
request.session['active_tab'] = 'active_subscriptions_pods'
brew = BrewMethod.objects.get(name_en='Nespresso')
order = Order.objects.create(
customer=customer,
coffee=coffee,
date=timezone.now(),
shipping_date=get_shipping_date(),
amount=coffee.amount,
interval=get_interval(preferences.interval),
recurrent=True,
status=Order.ACTIVE,
brew=brew,
package=preferences.package,
different=preferences.different,
)
mailing_list.update_mailchimp_tracking(
request, order, MailchimpCampaignStats.PURCHASED)
add_event.delay(customer_id=order.customer.id,
event='created-subscription',
order_id=order.id)
Reminder.objects.filter(email=customer.user.email,
resumed=None).update(completed=True)
return redirect('profile')
else:
customer = Customer.objects.get(user=request.user)
preferences = customer.preferences
subscribe = True
if request.GET.get('subscribe'):
if request.GET['subscribe'] == '0':
subscribe = False
isNespresso = True
if request.GET.get('isNespresso'):
if request.GET['isNespresso'] == '0':
isNespresso = False
context = {
'key': settings.PUBLISHABLE_KEY,
'coffee': CoffeeType.objects.get(id=coffee_id),
'subscribe': subscribe,
'isNespresso': isNespresso,
}
context['brew_methods'] = BrewMethod.objects.sorted(~Q(
name_en='Nespresso'))
context['preferences_form'] = PreferencesForm()
# Need to clean up
context['current_brew'] = preferences.brew or BrewMethod.objects.get(
name_en="None")
context['current_package'] = preferences.package
return render(request, 'coffees/detail.html', context)
def add_event(self, obj):
add_event.delay(customer_id=obj.customer_id,
event='deleted_address',
data={'address': str(obj)})
def add_event(self, obj):
add_event.delay(customer_id=obj.customer_id,
event='changed_order_shipping_address',
order_id=obj.id)
def add_event(self, obj):
add_event.delay(customer_id=obj.customer_id,
event='update-subscription',
order_id=obj.id)
