def account_details(self, request):
if request.method == 'POST':
form = ChangeDetailsForm(request.POST)
else:
form = ChangeDetailsForm()
form.configure(request)
if form.is_valid():
data = form.cleaned_data
u = request.user
p = get_customer_model().objects.get(user=u)
if request.settings.mailchimp_enabled:
# subscription details
ms = MailSnake(request.settings.mailchimp_api)
person_name = [data.get('first_name'), data.get('last_name')]
merge_vars = {'FNAME': ' '.join(person_name)}
# unsubscribe if email changed or we no longer want to be subscribed
if 'email_address' in form.changed_data or ('newsletter' in form.changed_data and not data.get('newsletter')):
try:
ms.listUnsubscribe(id=request.settings.mailchimp_list_id, email_address=u.email)
except:
pass
# subscribe if newsletter subscription changed or email was changed
if ('email_address' in form.changed_data or 'newsletter' in form.changed_data) and data.get('newsletter'):
try:
ms.listSubscribe(id=request.settings.mailchimp_list_id, email_address=data.get('email_address'), merge_vars=merge_vars)
except:
pass
# update newletter state in profile
p.newsletter = data.get('newsletter')
# update personal details on user record
u.first_name = data.get('first_name')
u.last_name = data.get('last_name')
u.email = data.get('email_address')
u.save()
# update personal details on profile record
p.title = data.get('title')
p.first_name = data.get('first_name')
p.last_name = data.get('last_name')
p.telephone = data.get('phone')
p.email = data.get('email_address')
p.save()
# success message and redirect to dashboard
messages.success(request, 'Your details have been changed.')
return HttpResponseRedirect(reverse('shop.account.index'))
return {
'account_section': True,
'form': form
}
def add_customer_to_mailing_list(customer):
'''
When called, this adds the customer's email to the mailing list.
'''
if not hasattr(settings, 'MAILCHIMP_API_KEY') or not hasattr(
settings, 'MAILCHIMP_LIST_ID'):
logger.info(
'Did not update mailing list to add customer %s, MailChimp is not set up.'
% customer.id)
return
logger.info('Updating mailing list in MailChimp, adding customer %s.' %
customer.id)
ms = MailSnake(settings.MAILCHIMP_API_KEY)
listId = settings.MAILCHIMP_LIST_ID
ms.listSubscribe(id=listId,
email_address=customer.email,
email_type='html',
double_optin=False,
update_existing=True,
merge_vars={
'FNAME': customer.first_name,
'LNAME': customer.last_name
})
def earlyAccessSubmit(request):
from signup.forms import SignupForm
if request.method == 'POST': # If the form has been submitted...
form = SignupForm(request.POST) # A form bound to the POST data
if form.is_valid():
ms = MailSnake('60a810702ef83b7de50b150df5008109-us5')
lists = ms.lists()
ms.listSubscribe(
id = lists['data'][0]['id'],
email_address = form.cleaned_data['email'],
merge_vars = {
'GROUPINGS': [
{'id': 7197,
'groups': 'Pre-Launch',},]
},
update_existing = True,
double_optin = False,
)
return HttpResponseRedirect('/signup/thanks/') # Redirect after POST
else:
form = SignupForm() # An unbound form
return render(request, 'signup.html', {
'form': form,
})
def main_post():
ms = MailSnake(app.config['MAILCHIMP_KEY'])
try:
email = request.form.get('email')
ms.listSubscribe(id=app.config['MAILCHIMP_LIST'], email_address=email)
flash(
'Thanks for subscribing! You will receive a confirmation email shortly.'
)
except InvalidEmailException as e:
app.logger.info('Invalid email address: %r', email)
flash(
"Your email address was not accepted - please check and try again."
)
except ListAlreadySubscribedException as e:
app.logger.info('Already subscribed: %s', email)
if e.message:
msg = Markup(e.message)
else:
msg = """You are already subscribed to our list.
Please contact %s to update your settings.""" % app.config[
'TICKETS_EMAIL'][1]
flash(msg)
except MailSnakeException as e:
app.logger.error('Error subscribing: %r', e)
flash('Sorry, an error occurred.')
return redirect(url_for('.main'))
def update_user_details(backend, details, uid, response, user=None, is_new=False,
*args, **kwargs):
if user is None:
return
changed = False # flag to track changes
for name, value in details.iteritems():
# configured fields if user already existed
if not _ignore_field(name, is_new):
if value and value != getattr(user, name, None):
setattr(user, name, value)
changed = True
user.profile.activate()
user.profile.fb_pic(uid)
user.save()
#add to mailchimp list
if user.first_name:
try:
ms = MailSnake('f92abfa01e0a9cecc885186de4e37106-us7')
key = ''
ms.listSubscribe( id = 'ed61191f4e', email_address = user.email, merge_vars = { 'FNAME': user.first_name, 'LNAME': user.last_name, 'EKEY': key }, double_optin = False, send_welcome = False )
except:
print "Facebook login error: Couldn't add user to MailChimp list"
else:
user.profile.send_welcome_email(activate=False)
def main_post():
ms = MailSnake(app.config['MAILCHIMP_KEY'])
try:
email = request.form.get('email')
ms.listSubscribe(id=app.config['MAILCHIMP_LIST'], email_address=email)
flash('Thanks for subscribing! You will receive a confirmation email shortly.')
except InvalidEmailException as e:
app.logger.info('Invalid email address: %r', email)
flash("Your email address was not accepted - please check and try again.")
except ListAlreadySubscribedException as e:
app.logger.info('Already subscribed: %s', email)
if e.message:
msg = Markup(e.message)
else:
msg = """You are already subscribed to our list.
Please contact %s to update your settings.""" % app.config['TICKETS_EMAIL'][1]
flash(msg)
except MailSnakeException as e:
app.logger.error('Error subscribing: %r', e)
flash('Sorry, an error occurred.')
return redirect(url_for('.main'))
def submit(request):
# grab info
email = request.POST['email']
referrer = request.POST['referrer']
# save locally
# lead_to_submit = Lead(email=email, referrer=referrer)
# lead_to_submit.save()
# send to Mailchimp
key = settings.MAILCHIMP_API_KEY
list_num = settings.MAILCHIMP_LIST_NUM
# see: http://www.nerdydork.com/integrate-mailchimp-with-your-django-app.html
mailsnake = MailSnake(key)
try:
mailsnake.listSubscribe(id=list_num,
email_address=email,
double_optin=False,
send_welcome=False,
merge_vars={'referrer': referrer})
except:
pass
return HttpResponseRedirect(reverse('landingpage.views.thanks'))
def submit(request):
# grab info
email = request.POST['email']
referrer = request.POST['referrer']
# save locally
lead_to_submit = Lead(email=email, referrer=referrer)
lead_to_submit.save()
# send to Mailchimp
key = settings.MAILCHIMP_API_KEY
list_num = settings.MAILCHIMP_LIST_NUM
# see: http://www.nerdydork.com/integrate-mailchimp-with-your-django-app.html
mailsnake = MailSnake(key)
try:
mailsnake.listSubscribe(
id=list_num,
email_address=email,
double_optin=False,
send_welcome=False,
merge_vars={
'referrer': referrer
}
)
except:
pass
return HttpResponseRedirect(reverse('landingpage.views.thanks'))
def earlyAccessSubmit(request):
from signup.forms import SignupForm
if request.method == 'POST': # If the form has been submitted...
form = SignupForm(request.POST) # A form bound to the POST data
if form.is_valid():
ms = MailSnake('60a810702ef83b7de50b150df5008109-us5')
lists = ms.lists()
ms.listSubscribe(
id=lists['data'][0]['id'],
email_address=form.cleaned_data['email'],
merge_vars={
'GROUPINGS': [
{
'id': 7197,
'groups': 'Pre-Launch',
},
]
},
update_existing=True,
double_optin=False,
)
return HttpResponseRedirect(
'/signup/thanks/') # Redirect after POST
else:
form = SignupForm() # An unbound form
return render(request, 'signup.html', {
'form': form,
})
def main_post():
ms = MailSnake(app.config['MAILCHIMP_KEY'])
try:
email = request.form.get('email')
ms.listSubscribe(id='d1798f7c80', email_address=email)
flash('Thanks for subscribing! You will receive a confirmation email shortly.')
except MailSnakeException, e:
print e
flash('Sorry, an error occurred.')
def main_post():
ms = MailSnake(app.config['MAILCHIMP_KEY'])
try:
email = request.form.get('email')
ms.listSubscribe(id='d1798f7c80', email_address=email)
flash('Thanks for subscribing! You will receive a confirmation email shortly.')
except MailSnakeException, e:
app.logger.error('Error subscribing: %s', e)
flash('Sorry, an error occurred.')
def main_post():
ms = MailSnake(app.config["MAILCHIMP_KEY"])
try:
email = request.form.get("email")
ms.listSubscribe(id="d1798f7c80", email_address=email)
flash("Thanks for subscribing! You will receive a confirmation email shortly.")
except MailSnakeException, e:
print e
flash("Sorry, an error occurred.")
def form_valid(self, form):
ms = MailSnake(getattr(settings, 'MAILCHIMP_KEY'))
double_optin = getattr(settings, 'MAILCHIMP_CONFIRM', True)
list_id = getattr(settings, 'MAILCHIMP_LIST_ID', None)
if not list_id:
list_id = ms.lists()['data'][0]['id']
ms.listSubscribe(id=list_id, email_address=form.cleaned_data['email'],
merge_vars={'NAME': form.cleaned_data['name']},
update_existing=True, double_optin=double_optin)
return super(SubscribeView, self).form_valid(form)
def __add_to_mailchimp(user):
if settings.MAILCHIMP_AUTO_SUBSCRIBE:
ms = MailSnake(settings.MAILCHIMP_API_KEY)
ms.listSubscribe(
id=settings.MAILCHIMP_LIST_ID,
email_address=user.email,
merge_vars={
'FNAME': user.first_name,
'LNAME': user.last_name,
},
double_optin=False, # no confirm message
send_welcome=True, # if new, send welcome
update_existing=True, # if existing, update
)
def __add_to_mailchimp(user):
if settings.MAILCHIMP_AUTO_SUBSCRIBE:
ms = MailSnake(settings.MAILCHIMP_API_KEY)
ms.listSubscribe(
id=settings.MAILCHIMP_LIST_ID,
email_address=user.email,
merge_vars={
'FNAME': user.first_name,
'LNAME': user.last_name,
},
double_optin=False, # no confirm message
send_welcome=True, # if new, send welcome
update_existing=True, # if existing, update
)
def connect(request):
ms = MailSnake(settings.MAILCHIMP_API_KEY)
lists = ms.lists()
if request.method == 'POST':
form = ConnectForm(request.POST)
message = 'the sky is falling'
if form.is_valid():
ms.listSubscribe(
id = lists['data'][0]['id'],
email_address = (form.cleaned_data['email_signup']),
update_existing = True,
double_optin = False,
)
#ms.listStaticSegmentMembersAdd(
# id = lists['data'][0]['id'],
# seg_id = 157, #Fake Development People... kill this in production!
# batch = {
# 'email_address': form.cleaned_data['email_signup']
# },
#)
if request.is_ajax(): #success with js
message = 'success!'
status = True
return HttpResponse(json.dumps({'message':message, 'status':status}), 'application/json')
else: #success with no js
return redirect('success')
else:
if request.is_ajax(): #error with js
message = 'Invalid email address'
status = False
return HttpResponse(json.dumps({'message':message, 'status':status}), 'application/json')
else: # error with no js
form.addError('Invalid email address')
else:
form = ConnectForm()
return render_to_response(
'signups/connect.html',
{
'form': form,
},
context_instance=RequestContext(request)
)
def api_createuser(request):
code = 100
data = {'code':code, 'error': 'Request Error'}
if request.POST:
if 'name' in request.POST and 'email' in request.POST and 'password' in request.POST:
name = request.POST['name']
email_x = request.POST['email']
password = request.POST['password']
email = email_x.lower()
if validateEmail(email):
ck_u = User.objects.filter(email=email)
if len(ck_u) > 0:
existing_user = True
code = 100
data = {'code':code, 'error': 'User Already Exists'}
else:
existing_user = False
u = User(username=email, password=password, email=email)
u.save()
"""create invitation"""
store = Store.objects.filter(active=True,city='San Francisco')[0]
inv = Invitation(user=u, default_store=store, email=u.username, used=True)
inv.save()
up = UserProfile(user=u, default_store=store)
up.save()
"""create default subscription"""
sub = Subscription(userprofile=up, subscription=False, subscription_type='un-subscribed')
sub.save()
"""Send admin email"""
sendSignupAdminEmail(u, 'San Francisco')
"""Send user email"""
sendWelcomeEmail(email,'sanfrancisco', 'San Francisco')
"""subscribe user to daily email"""
LIST_IDS = {'san-francisco':'eaa0a378ba'}
l_id = LIST_IDS['san-francisco']
ms = MailSnake(settings.MAILCHIMP_API_KEY)
success = ms.listSubscribe(id=l_id, email_address=u.email, double_optin=False)
d, code = api_auth_helper(u)
code = 200
data = {'code':code, 'account':d['account']}
else:
code = 100
data = {'code':code, 'error': 'Invalid Email'}
else:
code = 100
data = {'code':code, 'error': 'Invalid Sign-up'}
return HttpResponse(simplejson.dumps(data, cls=MyJSONEncoder),content_type = 'application/javascript; charset=utf8')
def newsletter_signup_form(context):
"""
Renders a default nessletter signup form based on MailChimp.
"""
settings = value_or_none('settings', context)
if not settings:
raise ValueError("Expected 'settings' in template context.")
if not settings.mailchimp_api or not settings.mailchimp_list_id:
return ''
request = value_or_none('request', context)
if not request:
raise ValueError("Expected 'request' in template context.")
if request.method == 'POST':
form = MailChimpSubscriptionForm(request.POST)
else:
form = MailChimpSubscriptionForm()
msg = None
msg_type = None
if request.method == 'POST' and form.is_valid():
d = form.cleaned_data
merge_vars = {'FNAME': d.get('mailchimp_subscription__name', '')}
ms = MailSnake(settings.mailchimp_api)
try:
ms.listSubscribe(id=settings.mailchimp_list_id,
email_address=d['mailchimp_subscription__email'],
merge_vars=merge_vars)
msg = 'Almost finished...We need to confirm your email address. To complete the subscription process, please click the link in the email we just sent you.'
msg_type = 'success'
except:
msg = 'Unfortunately we were unable to process your request. Please try again later...'
msg_type = 'error'
# render form
t = get_template('cubane/cms/newsletter_form.html')
c = copy.copy(context)
c['form'] = form
c['msg'] = msg
c['msg_type'] = msg_type
return t.render(c)
class MailchimpRegistrar(object):
_mail_snake = None
def __init__(self):
if not hasattr(settings, 'MAILCHIMP_API_KEY'):
logger.error('MailChimp API key not present')
self._mail_snake = MailSnake(settings.MAILCHIMP_API_KEY)
def _register_email(self, email, list_id):
self._mail_snake.listSubscribe(id=list_id,
email_address=email,
merge_vars={'EMAIL': email},
double_optin=True,
update_existing=True)
def subscribe_to_events_notification(self, email):
list_id = settings.MAILCHIMP_EVENTS_NOTIFICATION_LIST_ID
self._register_email(email, list_id)
def pre_save_user(sender, instance, **kwargs):
try:
original = User.objects.get(pk=instance.pk)
except User.DoesNotExist:
pass
else:
# Sync with MailChimp whenever a user becomes active
if not original.is_active == instance.is_active and instance.is_active:
user = instance
profile = user.get_profile()
mailsnake = MailSnake(settings.MAILCHIMP_API_KEY)
if profile.newsletter:
email = user.email.encode('utf-8')
logger.debug('Subscribing ' + email + ' to MailChimp list...')
try:
mailsnake.listSubscribe(id=settings.MAILCHIMP_LIST_ID,
email_address=email,
double_optin=False,
update_existing=True,
send_welcome=True)
except:
logger.exception('Failed to subscribe ' + email +
' to MailChimp list')
else:
email = user.email.encode('utf-8')
# If the user is already subscribed on MailChimp, go ahead and update our local state to match
logger.debug('Retrieving subscription state for ' + email +
' on MailChimp list...')
try:
info = mailsnake.listMemberInfo(
id=settings.MAILCHIMP_LIST_ID, email_address=(email, ))
except:
logger.exception(
'Failed to retrieve subscription state for ' + email)
else:
if info['success'] == 1 and info['data'][0][
'status'] == 'subscribed':
profile.newsletter = True
profile.save(dispatch_signal=False)
def pre_save_user_profile(sender, instance, raw, **kwargs):
# Don't update MailChimp if this is a raw save (to prevent cycles when updating in response to the MailChimp webhook)
if not raw:
try:
original = UserProfile.objects.get(pk=instance.pk)
except UserProfile.DoesNotExist:
pass
else:
if not original.newsletter == instance.newsletter:
user = instance.user
# Update MailChimp whenever the newsletter preference changes for an active user
if user.is_active:
email = user.email.encode('utf-8')
profile = instance
mailsnake = MailSnake(settings.MAILCHIMP_API_KEY)
if profile.newsletter:
logger.debug('Subscribing ' + email +
' to MailChimp list...')
try:
mailsnake.listSubscribe(
id=settings.MAILCHIMP_LIST_ID,
email_address=email,
double_optin=False,
update_existing=True,
send_welcome=True)
except:
logger.exception('Failed to subscribe ' + email +
' to MailChimp list')
else:
logger.debug('Unsubscribing ' + email +
' from MailChimp list...')
try:
mailsnake.listUnsubscribe(
id=settings.MAILCHIMP_LIST_ID,
email_address=email)
except:
logger.exception('Failed to unsubscribe ' + email +
' from MailChimp list')
def form_valid(self, form):
ms = MailSnake(settings.MAILCHIMP_API_KEY)
ms.listSubscribe(
id = settings.MAILCHIMP_LIST_ID,
email_address = form.cleaned_data['email'],
merge_vars = {
'FNAME': form.cleaned_data['first_name'],
'GROUPINGS': [{'name':'reading','groups':'bcseoguide'}],
},
update_existing = True,
double_optin = True,
)
if self.request.is_ajax():
return self.response_class(
request=self.request,
template='sm/subscribe/ajax/success.html',
context={})
return HttpResponseRedirect(reverse('subscribe_success'))
def newsletter_signup(request):
email = request.POST['email']
if re.match('^[a-zA-Z0-9._%-]+@[a-zA-Z0-9._%-]+.[a-zA-Z]{2,6}$', email):
ms = MailSnake(settings.MAILCHIMP_KEY)
r = ms.listSubscribe(id='df179acee6', email_address=email)
print(r)
if r:
return HttpResponse()
else:
return HttpResponseServerError()
else:
#Invalid email address. Return 400
return HttpResponseBadRequest(content='Invalid email address')
def new_member(request):
#auth.logout(request)
if request.method == 'POST':
uform = MyUserCreationForm(request.POST)
pform = MemberForm(request.POST)
if uform.is_valid() and pform.is_valid():
user = uform.save()
member = pform.save(commit=False)
member.user = user
member.save()
user = authenticate(username=uform.data['username'], password=uform.data['password1'])
auth.login(request, user)
if settings.USE_MAILCHIMP:
ms = MailSnake(settings.MAILCHIMP_API_KEY)
lists = ms.lists()
ms.listSubscribe(
id = lists['data'][0]['id'], #TODO: assumes use of first list,
email_address = user.email,
merge_vars = {
'FNAME' : user.first_name,
'LNAME' : user.last_name,
},
update_existing = True,
double_optin = False, #no confirm message
send_welcome = True, #note: won't send if merely updates existing
)
return redirect('membership.views.enrollment')
else:
uform = MyUserCreationForm()
pform = MemberForm()
d = {
'uform':uform,
'pform':pform,
}
return render(request, 'membership/new_member.html', d)
def ajax_signup(request):
if request.POST:
new_signup = MyUserCreationForm(request.POST)
if new_signup.is_valid():
new_signup.save()
uname = new_signup.cleaned_data["username"]
"""set up so username and email are the same"""
user = User.objects.get(username=uname)
user.email = uname
user.save()
"""create user profile"""
store_id = request.POST.get("default_store")
store = Store.objects.get(id=store_id)
up = UserProfile(user=user, default_store=store)
up.save()
"""create default subscription"""
sub = Subscription(userprofile=up, subscription=False, subscription_type="un-subscribed")
sub.save()
"""email admin of new signup"""
sendSignupAdminEmail(user, store)
"""email user with signup information"""
sendSignupEmail(user, store)
"""subscrbe user to daily email"""
LIST_IDS = {"sflaunch_group": "eaa0a378ba"}
l_id = LIST_IDS["sflaunch_group"]
ms = MailSnake(settings.MAILCHIMP_API_KEY)
success = ms.listSubscribe(id=l_id, email_address=user.email, double_optin=False)
username = user.username
password = user.password
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
return HttpResponse("success", status=200)
return HttpResponse("Username is already taken", status=403)
def CreateNewUserHelper(request, c_email, c_city):
email = c_email.lower()
token = get_rand_token()
ck_u = User.objects.filter(email=email)
if len(ck_u) > 0:
existing_user = True
else:
existing_user = False
u = User(username=email, password=token, email=email)
u.save()
"""create invitation"""
store = Store.objects.filter(active=True, city="San Francisco")[0]
inv = Invitation(user=u, default_store=store, email=u.username, token=token, used=False)
inv.save()
# save in session
request.session["user"] = base64.b16encode(str(u.id))
CITY_LIST = {"san-francisco": "San Francisco"}
cl_city = CITY_LIST[c_city]
up = UserProfile(user=u, default_store=store)
up.save()
"""create default subscription"""
sub = Subscription(userprofile=up, subscription=False, subscription_type="un-subscribed")
sub.save()
"""Send admin email"""
sendSignupAdminEmail(u, cl_city)
"""Send welcome email to new user"""
c = cl_city.lower()
city = c.replace(" ", "")
sendWelcomeEmail(email, token, city, cl_city)
"""subscribe user to daily email"""
LIST_IDS = {"san-francisco": "eaa0a378ba"}
l_id = LIST_IDS[c_city]
ms = MailSnake(settings.MAILCHIMP_API_KEY)
success = ms.listSubscribe(id=l_id, email_address=u.email, double_optin=False)
def admin_invite(request):
if request.POST:
form = InvitationForm(request.POST)
if form.is_valid():
c_email = form.cleaned_data["email"]
email = c_email.lower()
token = get_rand_token()
u = User(username=email, password=token, email=email)
u.save()
store = form.cleaned_data["store"]
up = UserProfile(user=u, default_store=store)
up.save()
"""create default subscription"""
sub = Subscription(userprofile=up, subscription=False, subscription_type="un-subscribed")
sub.save()
c = store.city.lower()
city = c.replace(" ", "")
send_invite_email(email, token, city, store)
inv = Invitation(user=u, default_store=store, email=u.username, token=token, used=False)
inv.save()
"""subscrbe user to daily email"""
LIST_IDS = {"sflaunch_group": "eaa0a378ba"}
l_id = LIST_IDS["sflaunch_group"]
ms = MailSnake(settings.MAILCHIMP_API_KEY)
success = ms.listSubscribe(id=l_id, email_address=u.email, double_optin=False)
else:
form = InvitationForm()
invites = Invitation.objects.all()
template = "profile/admin/admin_invite.html"
data = {"form": form, "invites": invites}
return render_to_response(template, data, context_instance=RequestContext(request))
def subscribe(request):
ms = MailSnake(settings.MAILCHIMP_KEY)
form = SubscriptionForm(request.POST)
result = {}
if form.is_valid():
try:
subscribed = ms.listSubscribe(id=settings.MAILCHIMP_NEWSLETTER_LIST_ID,
email_address=form.cleaned_data['email'],
double_optin=False)
if subscribed:
result = {'status': 'success', 'message': 'E-mail cadastrado com sucesso! :)'}
else:
result = {'status': 'error', 'message': 'Algo de errado aconteceu e seu e-mail não foi cadastrado. :('}
except ListAlreadySubscribedException:
result = {'status': 'success', 'message': 'O e-mail informado já estava cadastrado em nossa newsletter. ;)'}
else:
result = {'status': 'error', 'message': get_last_error_message(form)}
return HttpResponse(simplejson.dumps(result), mimetype='application/json')
def redeem_now(request):
user = None
token = request.POST.get('token')
if not token:
token = request.GET.get('token')
city = 'sanfrancisco'
#if 'city' in request.GET:
# city = request.GET.get('city')
try:
gift = GiftSubscription.objects.get(gifttoken=token)
user = gift.giftuser
request.session['user'] = base64.b16encode(str(user.id))
except GiftSubscription.DoesNotExist:
raise Http404
except:
raise Http404
if user:
if request.POST:
form = SetPasswordForm(user, request.POST)
if form.is_valid():
form.save()
"""Get users default city"""
up = UserProfile.objects.filter(user=user)
if up:
store = up[0].default_store
c = store.city
city = c.lower().replace(' ','')
"""update to gift subscription"""
gift.giftused = True
gift.save()
"""update to gift subscription"""
s_type = "4 month unlimited (gift subscription)"
sub = Subscription.objects.filter(userprofile=up[0])
if len(sub) > 0:
s = sub[0]
s.subscription_type = s_type
s.subscription = True
s.save()
else:
s = Subscription(userprofile=up, subscription=True, subscription_type=s_type)
s.save()
"""subscribe user to daily email"""
LIST_IDS = {'sflaunch_group':'eaa0a378ba'}
l_id = LIST_IDS['sflaunch_group']
ms = MailSnake(settings.MAILCHIMP_API_KEY)
success = ms.listSubscribe(id=l_id, email_address=user.email, double_optin=False)
data = {'user':user, 'city':city}
template = "gifts/thanks_gift_redeemed.html"
return render_to_response(template, data,context_instance=RequestContext(request))
else:
form = SetPasswordForm(user)
data = {'form':form, 'user':user, 'token':token, 'city':city}
template = 'gifts/gift_redeem.html'
return render_to_response(template, data, context_instance=RequestContext(request))
def account_signup(self, request):
email = request.session.get(settings.SIGNUP_EMAIL_SESSION_VAR, None)
if email == '':
raise Http404('Missing email address.')
checkout = request.GET.get('checkout', False) == '1'
form_class = self.get_account_signup_form()
if request.method == 'POST':
form = form_class(request.POST, initial={'checkout': checkout})
else:
form = form_class(initial={
'email': email,
'checkout': checkout
})
form.configure(request)
if request.method == 'POST':
captcha = validate_captcha(request)
if not captcha:
messages.add_message(request, messages.ERROR,
'Please tick the checkbox at the bottom of the form to prevent SPAM.'
)
if form.is_valid() and captcha:
d = form.cleaned_data
# create user account
md5 = hashlib.md5()
md5.update(d['email'])
user = User.objects.create(
username = md5.hexdigest()[:30],
first_name = d['first_name'],
last_name = d['last_name'],
email = d['email']
)
# replace username with user id, set password and add user to list of customers
user.username = unicode(user.id)
user.set_password(d['password'])
user.save()
# create customer
newsletter = 0
if request.settings.mailchimp_enabled:
if d['newsletter']:
person_name = (d['first_name'],d['last_name'])
merge_vars = {'FNAME': " ".join(person_name)}
ms = MailSnake(request.settings.mailchimp_api)
try:
ms.listSubscribe(id=request.settings.mailchimp_list_id, email_address=d['email'], merge_vars=merge_vars)
except:
pass
newsletter = d['newsletter']
customer = get_customer_model().objects.create(
user=user,
first_name = d['first_name'],
last_name = d['last_name'],
email=d['email'],
title=d['title'],
address1='',
city='',
county='',
postcode='',
country=d['country'],
telephone='',
newsletter=newsletter
)
# log customer in
login_user_without_password(request, user)
# go to dashboard or deliver page
messages.success(request, 'Thank you for signing up with us.')
if d['checkout']:
response = HttpResponseRedirect(reverse('shop.order.delivery'))
else:
response = HttpResponseRedirect(reverse('shop.account.index'))
response.set_cookie('cubaneShopLogin', '1')
return response
return {
'account_section': True,
'is_signup_page': True,
'form': form
}
def complete(request):
"""
(3) Final checkout step, where the order is actually created from the basket.
"""
basket = Basket(request)
# redirect back to a previous step if we missed anything...
next = get_next_checkout_step(request, basket, CurrentPage.COMPLETE())
if next:
return HttpResponseRedirect(next)
# state or county
if 'state' in basket.billing_address:
county = basket.billing_address.get('state')
else:
county = basket.billing_address.get('county')
# create account if requested
if basket.signup:
# create user account
md5 = hashlib.md5()
md5.update(basket.signup.get('email'))
email = basket.signup.get('email')
if User.objects.filter(email=email).count() > 0:
messages.warning(
request,
'There is already an account with this email: %s.' % email)
return HttpResponseRedirect(reverse('shop.account.login'))
user = User.objects.create(username=md5.hexdigest()[:30],
first_name=basket.signup.get('first_name'),
last_name=basket.signup.get('last_name'),
email=email)
# replace username with user id and set password
user.username = unicode(user.id)
user.set_password(basket.signup.get('password'))
user.save()
# create profile
get_customer_model().objects.create(
user=user,
first_name=user.first_name,
last_name=user.last_name,
email=user.email,
title=basket.billing_address.get('title'),
address1=basket.billing_address.get('address1'),
address2=basket.billing_address.get('address2'),
address3=basket.billing_address.get('address3'),
city=basket.billing_address.get('city'),
county=county,
postcode=basket.billing_address.get('postcode'),
country=basket.billing_address.get('country'),
telephone=basket.billing_address.get('telephone'),
newsletter=basket.newsletter)
# log user in
login_user_without_password(request, user)
basket.signup = None
else:
if request.user.is_anonymous():
user = None
else:
user = request.user
# if specified, copy relevant information to customer's profile
if user != None and basket.update_profile:
user.first_name = basket.billing_address.get('first_name')
user.last_name = basket.billing_address.get('last_name')
user.save()
customer = get_customer_model().objects.get(user=user)
customer.address1 = basket.billing_address.get('address1')
customer.address2 = basket.billing_address.get('address2')
customer.address3 = basket.billing_address.get('address3')
customer.city = basket.billing_address.get('city')
customer.county = county
customer.postcode = basket.billing_address.get('postcode')
customer.country = basket.billing_address.get('country')
customer.telephone = basket.billing_address.get('telephone')
customer.save()
# create single order
order = get_order_model().create_from_basket(request, basket, user)
# mailchimp
if request.settings.mailchimp_enabled and basket.newsletter:
email = basket.billing_address.get('email')
first_name = basket.billing_address.get('first_name')
last_name = basket.billing_address.get('last_name')
person_name = (first_name, last_name)
merge_vars = {'FNAME': " ".join(person_name)}
ms = MailSnake(request.settings.mailchimp_api)
try:
ms.listSubscribe(id=request.settings.mailchimp_list_id,
email_address=email,
merge_vars=merge_vars)
except:
pass
# redirect to order status page (payment from there...)
basket.save()
return HttpResponseRedirect(
reverse('shop.order.status', args=[order.secret_id]))
def signup(request, city):
LOCATIONS = {'sanfrancisco':'San Francisco'}
STATE = {'sanfrancisco':'CA'}
store_city = LOCATIONS[city]
store_state = STATE[city]
store_all = Store.objects.filter(city=store_city, active=True)
if request.POST:
new_signup = MyUserCreationForm(request.POST)
if new_signup.is_valid():
new_signup.save()
uname = new_signup.cleaned_data['username']
"""set up so username and email are the same"""
user = User.objects.get(username=uname)
user.email = uname
user.save()
"""create user profile"""
store_id = request.POST.get('default_store')
store = Store.objects.get(id=store_id)
up = UserProfile(user=user, default_store=store)
up.save()
"""create default subscription"""
sub = Subscription(userprofile=up, subscription=False, subscription_type='un-subscribed')
sub.save()
"""email admin of new signup"""
sendSignupAdminEmail(user, store)
"""email user with signup information"""
sendSignupEmail(user, store)
"""subscrbe user to daily email"""
LIST_IDS = {'sflaunch_group':'eaa0a378ba'}
l_id = LIST_IDS['sflaunch_group']
ms = MailSnake(settings.MAILCHIMP_API_KEY)
success = ms.listSubscribe(id=l_id, email_address=user.email, double_optin=False)
username = user.username
password = user.password
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
request.session['user'] = base64.b16encode(str(up.user.id))
return HttpResponseRedirect('/profile/subscribe/sanfrancisco')
new_signup = MyUserCreationForm()
location_form = UserProfileForm()
mapForm = createMapMulti(store_all, store_city, store_state, largeMap=True, zoomControl=True, panControl=True)
template = 'profile/signup.html'
data = {'new_signup':new_signup, 'store_all':store_all, 'city':city,
'store_city':store_city, 'location_form':location_form, 'map':mapForm}
return render_to_response(template, data,context_instance=RequestContext(request))
def submit_orders(request):
# gets logged in user profile, or anonymous profile
profile = current_profile(request)
current_cart = Cart(request)
# the cart has its own discount logic
# plus we need to account for any user submitted coupons
total_amount = current_cart.discount_applied() * 100
discount_amount = current_cart.discount() * 100.0
coupon_amount = float(request.POST.get('coupon_amount', 0.0))
shipping_amount = float(request.POST.get('shipping_amount', 0.0))
# actual amount to charge with stripe
final_amount = total_amount - coupon_amount + shipping_amount
print(str(current_cart.count()) + ' items')
print('total ' + str(total_amount))
print('coupon amount ' + str(coupon_amount))
print('shipping amount ' + str(shipping_amount))
print('final amount ' + str(final_amount))
# grab email for reference in stripe
if profile.user.username == 'guest':
email = request.POST.get('email_address', '')
else:
email = profile.user.email
# subscribing people to mailchimp
if request.POST.get('email_checkbox','') and email != '':
ms = MailSnake(settings.MAILCHIMP_KEY)
lists = ms.lists()
ms.listSubscribe(
id = lists['data'][0]['id'],
email_address = email,
update_existing = True,
double_optin = False,
)
# see your keys here https://manage.stripe.com/account
stripe.api_key = settings.STRIPE_SECRET_KEY # key the binx gave
stripe_desc = str(email) + ", " + str(current_cart.count()) + " meshus"
print(stripe_desc)
# get the credit card details submitted by the form
token = request.POST['stripe_token']
# create the charge on Stripe's servers - this will charge the user's card
charge = stripe.Charge.create(
amount = int(final_amount), # amount in cents, again
currency = "usd",
card = token,
description = stripe_desc
)
# store the shipping address information
shipping = ShippingInfo()
shipping.contact = email
shipping.shipping_name = request.POST['shipping_name']
shipping.shipping_address = request.POST['shipping_address']
shipping.shipping_address_2 = request.POST['shipping_address_2']
shipping.shipping_city = request.POST['shipping_city']
shipping.shipping_zip = request.POST['shipping_zip']
shipping.shipping_region = request.POST['shipping_region']
shipping.shipping_state = request.POST['shipping_state']
shipping.shipping_country = request.POST['shipping_country']
# save shipping separately now, not in Order
shipping.amount = shipping_amount
shipping.save()
items = current_cart.cart.item_set.all()
if current_cart.count() > 1:
return submit_multiple(request, shipping, items, final_amount, discount_amount, coupon_amount)
elif current_cart.count() == 1:
return submit_single(request, shipping, items, final_amount, coupon_amount)
