def handleApply(self, action): data, errors = self.extractData() if 'email' in data: # Fetch MailChimp settings registry = getUtility(IRegistry) mailchimp_settings = registry.forInterface(IMailchimpSettings) if len(mailchimp_settings.api_key) == 0: return mailchimp = PostMonkey(mailchimp_settings.api_key) # Fetch MailChimp lists # XXX, Todo: For now we just fetch the first list. try: lists = mailchimp.lists()['data'] list_id = lists[0]['id'] except MailChimpException, error: raise WidgetActionExecutionError( Invalid( _(u"Could not fetch list from mailchimp.com: %s" % error))) # Subscribe to MailChimp list try: mailchimp.listSubscribe(id=list_id, email_address=data['email']) except MailChimpException, error: raise WidgetActionExecutionError( 'email', Invalid(_(u"Could not subscribe to newsletter: %s" % error)))
class MailchimpLocator(object): """Utility for MailChimp API calls. """ implements(IMailchimpLocator) def connect(self): registry = getUtility(IRegistry) self.settings = registry.forInterface(IMailchimpSettings) self.mailchimp = PostMonkey(self.settings.api_key) def lists(self): """Return all available MailChimp lists. http://apidocs.mailchimp.com/api/rtfm/lists.func.php """ #print("MAILCHIMP LOCATOR: lists") self.connect() try: # lists returns a dict with 'total' and 'data'. we just need data return self.mailchimp.lists()['data'] except MailChimpException: return [] except PostRequestError: return [] except: raise def default_list_id(self): self.connect() if self.settings.default_list: return self.settings.default_list lists = self.lists() if len(lists) > 0: return lists[0]['id'] def groups(self, list_id=None): """Return all available MailChimp interest groups. @id: the list id to connect to. e.g. u'a1346945ab'. Not the web_id! http://apidocs.mailchimp.com/api/rtfm/listinterestgroupings.func.php """ if not list_id: return #print("MAILCHIMP LOCATOR: groups") self.connect() try: # mailchimp returns a list of groups for a single mailinglist. # We always choose the first and return just the groups part. return self.mailchimp.listInterestGroupings(id=list_id)[0] except MailChimpException, error: if error.code == 211: # "This list does not have interest groups enabled" # http://apidocs.mailchimp.com/api/1.3/exceptions.field.php#210-list-_-basic-actions return elif error.code == 200: # "Invalid MailChimp List ID" # http://apidocs.mailchimp.com/api/1.3/exceptions.field.php#200-list-related-errors return raise
def lists(): pm = PostMonkey(os.environ.get('MAILCHIMP_API_KEY','')) lists = pm.lists() for list in lists['data']: print list['id'], list['name'] return file('templates/200.json').read(), 200
def register(): statsd.increment('api_calls.register') form = SignupForm(request.form) logger.info(request.form) if not form.validate(): msg = { 'success': False, 'msg': form.errors} return jsonify(msg) user = session.query(Person).\ filter(Person.email == form.email.data ).first() if user: msg = { 'success': False, 'msg': user.email + ' is already registered!', 'parameter': 'email', } return jsonify(msg) u = Person(form) session.add(u) session.commit() try: pm = PostMonkey(apikey=MC_APIKEY, timeout=10) pm.listSubscribe( id=MC_LISTID, email_address=form.email.data) except MailChimpException, e: app.logger.error(str(e))
def snapshot_mailchimp(verbose=False): api_key = os.environ.get('MAILCHIMP_API_KEY') assert api_key, 'No MAILCHIMP_API_KEY defined in environment.' pm = PostMonkey(api_key, timeout=10) ping_string = pm.ping() expected = u'Everything\'s Chimpy!' assert ping_string==expected, 'Bad handshake, got "%s", expected "%s"' % (ping_string,expected) if verbose: print 'handshake ok' lists = pm.lists() if not 'data' in lists: print 'Got bad lists object from server.' pprint(lists) raise ValueError('Bad lists object from server') # Snapshot creation code... today = datetime.now().date() for l in lists['data']: try: if verbose: print 'Scraping %s...' % l['name'] latest = Session.query(model.SnapshotOfMailchimp)\ .filter(model.SnapshotOfMailchimp.name==l['name'])\ .order_by(model.SnapshotOfMailchimp.timestamp.desc())\ .first() if latest and latest.timestamp>=today: if verbose: print ' -> most recent snapshots have already been processed.' continue snapshot = model.SnapshotOfMailchimp(\ name = l['name'],\ members = l['stats']['member_count'], timestamp = today) if verbose: print ' -> ',snapshot.toJson() Session.add(snapshot) Session.commit() except Exception, e: pprint({'list':l,'exception':str(e)})
class SignupWorker(QueueProcessingWorker): def __init__(self): super(SignupWorker, self).__init__() if settings.MAILCHIMP_API_KEY: self.pm = PostMonkey(settings.MAILCHIMP_API_KEY, timeout=10) def consume(self, data): merge_vars=data['merge_vars'] # This should clear out any invitation reminder emails clear_followup_emails_queue(data["EMAIL"]) if settings.MAILCHIMP_API_KEY and settings.PRODUCTION: try: self.pm.listSubscribe( id=settings.ZULIP_FRIENDS_LIST_ID, email_address=data['EMAIL'], merge_vars=merge_vars, double_optin=False, send_welcome=False) except MailChimpException as e: if e.code == 214: logging.warning("Attempted to sign up already existing email to list: %s" % (data['EMAIL'],)) else: raise e email = data.get("EMAIL") name = merge_vars.get("NAME") enqueue_welcome_emails(email, name)
class SignupWorker(QueueProcessingWorker): def __init__(self): # type: () -> None super(SignupWorker, self).__init__() if settings.MAILCHIMP_API_KEY: self.pm = PostMonkey(settings.MAILCHIMP_API_KEY, timeout=10) def consume(self, data): # type: (Mapping[str, Any]) -> None merge_vars = data['merge_vars'] # This should clear out any invitation reminder emails clear_followup_emails_queue(data["EMAIL"]) if settings.MAILCHIMP_API_KEY and settings.PRODUCTION: try: self.pm.listSubscribe(id=settings.ZULIP_FRIENDS_LIST_ID, email_address=data['EMAIL'], merge_vars=merge_vars, double_optin=False, send_welcome=False) except MailChimpException as e: if e.code == 214: logging.warning( "Attempted to sign up already existing email to list: %s" % (data['EMAIL'], )) else: raise e email = data.get("EMAIL") name = merge_vars.get("NAME") enqueue_welcome_emails(email, name)
def review(): app.logger.debug(request.form) # get form data (WE SHOULD VALIDATE) message = request.form.get('message') subject = request.form.get('subject') from_email = request.form.get('from_email') from_name = request.form.get('from_name') app.logger.debug(from_email) app.logger.debug(from_name) pm = PostMonkey(app.config['PM_API_KEY']) list_info = pm.lists(filters={'list_id':app.config['PM_LIST_ID']}) list_name = list_info['data'][0]['name'] list_count = list_info['data'][0]['stats']['member_count'] return render_template('review_form.html', page_title="Review E-mail", from_name=from_name, from_email=from_email, list_name=list_name, list_count=list_count, message=message, subject=subject)
def handleApply(self, action): data, errors = self.extractData() if 'email' in data: # Fetch MailChimp settings registry = getUtility(IRegistry) mailchimp_settings = registry.forInterface(IMailchimpSettings) if len(mailchimp_settings.api_key) == 0: return mailchimp = PostMonkey(mailchimp_settings.api_key) # Fetch MailChimp lists # XXX, Todo: For now we just fetch the first list. try: lists = mailchimp.lists()['data'] list_id = lists[0]['id'] except MailChimpException, error: raise WidgetActionExecutionError( Invalid(_(u"Could not fetch list from mailchimp.com: %s" % error))) # Subscribe to MailChimp list try: mailchimp.listSubscribe( id=list_id, email_address=data['email']) except MailChimpException, error: raise WidgetActionExecutionError( 'email', Invalid(_( u"Could not subscribe to newsletter: %s" % error)))
def test_mailchimp_ping_method(mock_class): mock_class().ping = MagicMock( return_value=u"Everything's Chimpy!" ) from postmonkey import PostMonkey pm = PostMonkey('123') assert pm.ping() == u"Everything's Chimpy!"
def email_chimp(request): email = request.POST['email'] apikey = 'a36024c7bb5504d63b61963dd9741fa2-us8' mailid = 'c4ed436de6' pm = PostMonkey(apikey) pm.listSubscribe(id = mailid, email_address = email, double_optin = False) return HttpResponse()
def valid_api_key(data): if len(data.api_key) == 0: return mailchimp = PostMonkey(data.api_key) try: return mailchimp.ping() except: raise Invalid(u"Your MailChimp API key is not valid. Please go " + u"to mailchimp.com and check your API key.")
def valid_api_key(data): if len(data.api_key) == 0: return mailchimp = PostMonkey(data.api_key) try: return mailchimp.ping() except: raise Invalid( u"Your MailChimp API key is not valid. Please go " + u"to mailchimp.com and check your API key.")
def available_lists(self): registry = getUtility(IRegistry) mailchimp_settings = registry.forInterface(IMailchimpSettings) mailchimp = PostMonkey(mailchimp_settings.api_key) try: return mailchimp.lists() except MailChimpException, error: raise WidgetActionExecutionError( Invalid(u"Could not fetch available lists from MailChimp. " + "Please check your MailChimp API key: %s" % error))
def valid_api_key(obj): registry = getUtility(IRegistry) mailchimp_settings = registry.forInterface(IMailchimpSettings) if len(mailchimp_settings.api_key) == 0: return mailchimp = PostMonkey(mailchimp_settings.api_key) try: return mailchimp.ping() except: raise Invalid(u"Your MailChimp API key is not valid. Please go " + "to mailchimp.com and check your API key.")
def mailchimp_account(self): registry = getUtility(IRegistry) mailchimp_settings = registry.forInterface(IMailchimpSettings) if len(mailchimp_settings.api_key) == 0: return [] mailchimp = PostMonkey(mailchimp_settings.api_key) try: return mailchimp.getAccountDetails() except MailChimpException, error: raise WidgetActionExecutionError( Invalid(u"Could not fetch account details from MailChimp. " + "Please check your MailChimp API key: %s" % error))
def send(): """ sends emails to a configured MailChimp list """ # get form data (WE SHOULD VALIDATE) msg_text = request.form.get('message') subject = request.form.get('subject') from_email = request.form.get('from_email') from_name = request.form.get('from_name') test_list = request.form.get('test_list', None) if (test_list): list_id = app.config['PM_TEST_LIST_ID'] app.logger.debug("sending to test list %s" % (list_id)) else: list_id = app.config['PM_LIST_ID'] app.logger.debug("sending to LIVE list %s" % (list_id)) pm = PostMonkey(app.config['PM_API_KEY']) md = Mandrill(app.config['MD_API_KEY']) members = pm.listMembers(id=list_id, limit=1000) emails = [] for mem in members['data']: emails.append(mem['email']) eastern = pytz.timezone('US/Eastern') now = eastern.localize(datetime.datetime.now()) msg_text = "%s\n\n--------\n\nE-mail generated at %s" % (msg_text, now) for email in emails: message = { "text": msg_text, "subject": subject, "from_email": from_email, "from_name": from_name, "to": [{ "email": email }] } app.logger.debug("sending to %s at %s" % (email, now)) resp = md.messages.send(message, async=True) app.logger.debug(pformat(resp)) flash("%s e-mails sent!" % len(emails)) return redirect(url_for('home'))
def available_lists(context): registry = getUtility(IRegistry) mailchimp_settings = registry.forInterface(IMailchimpSettings) if len(mailchimp_settings.api_key) == 0: return SimpleVocabulary([]) mailchimp = PostMonkey(mailchimp_settings.api_key) try: lists = mailchimp.lists()["data"] except MailChimpException: pass except: return SimpleVocabulary([]) return SimpleVocabulary([SimpleTerm(value=li["id"], title=li["name"]) for li in lists])
def available_lists(context): registry = getUtility(IRegistry) mailchimp_settings = registry.forInterface(IMailchimpSettings) if len(mailchimp_settings.api_key) == 0: return SimpleVocabulary([]) mailchimp = PostMonkey(mailchimp_settings.api_key) try: lists = mailchimp.lists()['data'] except MailChimpException: pass except: return SimpleVocabulary([]) return SimpleVocabulary( [SimpleTerm(value=li['id'], title=li['name']) for li in lists])
def gumroad(): # We have passed the shared secret or we didn't care about it pm = PostMonkey(os.environ.get('MAILCHIMP_API_KEY','')) # Get a posted email address email = request.form.get('email',None) if not email == None: # Send that off to Mailchimp pm = PostMonkey(os.environ.get('MAILCHIMP_API_KEY','')) try: pm.listSubscribe(id=os.environ.get('MAILCHIMP_LIST_ID',''),email_address=email,double_optin=False) except MailChimpException, e: print e.code # 200 print e.error # u'Invalid MailChimp List ID: 42' return file('templates/401.json').read(), 401
def salva_email(request): instance = UserSocialAuth.objects.get(user=request.user, provider='instagram') email = request.POST['email'] try: apikey = 'a36024c7bb5504d63b61963dd9741fa2-us8' mailid = 'c4ed436de6' pm = PostMonkey(apikey) pm.listSubscribe(id = mailid, email_address = email, double_optin = False) except: pass Utente.objects.filter(utente = instance).update(email = email) return HttpResponse()
def subscribe(): # We have passed the shared secret or we didn't care about it pm = PostMonkey(MAILCHIMP_API_KEY) # Get a posted email address email = request.form.get('email',None) if not email == None: # Send that off to Mailchimp pm = PostMonkey(MAILCHIMP_API_KEY) try: pm.listSubscribe(id=MAILCHIMP_LIST_ID, email_address=email,double_optin=False) except MailChimpException, e: print e.code # 200 print e.error # u'Invalid MailChimp List ID: 42' flash('Error: ' + str(e.error)) return redirect(url_for('homepage'))
def send(): """ sends emails to a configured MailChimp list """ # get form data (WE SHOULD VALIDATE) msg_text = request.form.get('message') subject = request.form.get('subject') from_email = request.form.get('from_email') from_name = request.form.get('from_name') pm = PostMonkey(app.config['PM_API_KEY']) md = Mandrill(app.config['MD_API_KEY']) members = pm.listMembers(id=app.config['PM_LIST_ID'], limit=1000) emails = [] for mem in members['data']: emails.append(mem['email']) now_utc = datetime.datetime.now() # get naive utc time local_tz = pytz.timezone('US/Eastern') # set local timezone now_utc = pytz.utc.localize(now_utc) # add timezone data to utc time local_time = now_utc.astimezone(local_tz) # convert to local time msg_text = "%s\n\n--------\n\nE-mail generated at %s" % (msg_text, local_time) for email in emails: message = { "text": msg_text, "subject": subject, "from_email": from_email, "from_name": from_name, "to": [{ "email": email }] } app.logger.debug("sending to %s" % (email)) resp = md.messages.send(message, async=True) app.logger.debug(pformat(resp)) flash("%s e-mails sent!" % len(emails)) return redirect(url_for('home'))
def subscribe(): if os.environ.get('SECRET_KEY',None) != None or request.form.get('sk',None) != None: secret_key = os.environ.get('SECRET_KEY',None) if secret_key != request.form.get('sk',None): # We were expecting a secret key because one is set, but we didn't or it didn't match return file('templates/401.json').read(), 401 # We have passed the shared secret or we didn't care about it pm = PostMonkey(os.environ.get('MAILCHIMP_API_KEY','')) # Get a posted email address email = request.form.get('email',None) if not email == None: # Send that off to Mailchimp pm = PostMonkey(os.environ.get('MAILCHIMP_API_KEY','')) try: pm.listSubscribe(id=os.environ.get('MAILCHIMP_LIST_ID',''),email_address=email,double_optin=False) except MailChimpException, e: print e.code # 200 print e.error # u'Invalid MailChimp List ID: 42' return file('templates/401.json').read(), 401
def test_postmonkey_mocker(self): from postmonkey import PostMonkey mailchimp = PostMonkey(u"abc") self.assertEqual( mailchimp.lists(), { u'total': 2, u'data': [{ u'id': u'f6257645gs', u'web_id': 625, u'name': u'ACME Newsletter', u'default_from_name': u'*****@*****.**', }, { u'id': u'f6267645gs', u'web_id': 626, u'name': u'ACME Newsletter 2', u'default_from_name': u'*****@*****.**', }] })
def __init__(self): # type: () -> None super(SignupWorker, self).__init__() if settings.MAILCHIMP_API_KEY: self.pm = PostMonkey(settings.MAILCHIMP_API_KEY, timeout=10)
from mocker import Mocker from mocker import ANY mocker = Mocker() postmonkey = mocker.replace("postmonkey") pm = postmonkey.PostMonkey(ANY) pm.ping() mocker.result(u"Everything's Chimpy!") mocker.replay() from postmonkey import PostMonkey mailchimp = PostMonkey('123') print(mailchimp.ping())
from flask import Flask, render_template, request, redirect from postmonkey import PostMonkey from postmonkey import MailChimpException # from flask.ext.sqlalchemy import SQLAlchemy import requests import logging from logging import Formatter, FileHandler import os #----------------------------------------------------------------------------# # App Config. #----------------------------------------------------------------------------# app = Flask(__name__) app.config.from_object('config') pm = PostMonkey('5eb1d21efa1f1f5f6e11f1c9c8213e51-us14') #db = SQLAlchemy(app) # Automatically tear down SQLAlchemy. ''' @app.teardown_request def shutdown_session(exception=None): db_session.remove() ''' # Login required decorator. ''' def login_required(test): @wraps(test) def wrap(*args, **kwargs): if 'logged_in' in session:
def __init__(self): super(SignupWorker, self).__init__() if settings.MAILCHIMP_API_KEY: self.pm = PostMonkey(settings.MAILCHIMP_API_KEY, timeout=10)
class MailchimpLocator(object): """Utility for MailChimp API calls. """ implements(IMailchimpLocator) key_account = "collective.mailchimp.cache.account" key_groups = "collective.mailchimp.cache.groups" key_lists = "collective.mailchimp.cache.lists" def __init__(self): self.mailchimp = None self.registry = None self.settings = None def initialize(self): if self.registry is None: self.registry = getUtility(IRegistry) if self.settings is None: self.settings = self.registry.forInterface(IMailchimpSettings) def connect(self): if self.mailchimp is not None: return self.initialize() self.mailchimp = PostMonkey(self.settings.api_key) def lists(self): self.initialize() cache = self.registry.get(self.key_lists, _marker) if cache is not _marker: return cache return self._lists() def _lists(self): #print("MAILCHIMP LOCATOR: lists") self.connect() try: # lists returns a dict with 'total' and 'data'. we just need data return self.mailchimp.lists()['data'] except MailChimpException: return [] except PostRequestError: return [] except: raise def default_list_id(self): self.connect() if self.settings.default_list: return self.settings.default_list lists = self.lists() if len(lists) > 0: return lists[0]['id'] def groups(self, list_id=None): if not list_id: return self.initialize() cache = self.registry.get(self.key_groups, _marker) if cache is not _marker: groups = cache.get(list_id, _marker) if groups is not _marker: return groups return self._groups(list_id) def _groups(self, list_id=None): if not list_id: return #print("MAILCHIMP LOCATOR: groups") self.connect() try: # mailchimp returns a list of groups for a single mailinglist. # We always choose the first and return just the groups part. return self.mailchimp.listInterestGroupings(id=list_id)[0] except MailChimpException, error: if error.code == 211: # "This list does not have interest groups enabled" # http://apidocs.mailchimp.com/api/1.3/exceptions.field.php#210-list-_-basic-actions return elif error.code == 200: # "Invalid MailChimp List ID" # http://apidocs.mailchimp.com/api/1.3/exceptions.field.php#200-list-related-errors return raise
def connect(self): if self.mailchimp is not None: return self.initialize() self.mailchimp = PostMonkey(self.settings.api_key)
class MailchimpLocator(object): """Utility for MailChimp API calls. """ implements(IMailchimpLocator) key_account = "collective.mailchimp.cache.account" key_groups = "collective.mailchimp.cache.groups" key_lists = "collective.mailchimp.cache.lists" def __init__(self): self.mailchimp = None self.registry = None self.settings = None def initialize(self): if self.registry is None: self.registry = getUtility(IRegistry) if self.settings is None: self.settings = self.registry.forInterface(IMailchimpSettings) def connect(self): if self.mailchimp is not None: return self.initialize() self.mailchimp = PostMonkey(self.settings.api_key) def lists(self): self.initialize() cache = self.registry.get(self.key_lists, _marker) if cache and cache is not _marker: return cache return self._lists() def _lists(self): self.connect() try: # lists returns a dict with 'total' and 'data'. we just need data return self.mailchimp.lists()['data'] except MailChimpException: return [] except PostRequestError: return [] except: raise def default_list_id(self): self.connect() if self.settings.default_list: return self.settings.default_list lists = self.lists() if len(lists) > 0: return lists[0]['id'] def groups(self, list_id=None): if not list_id: return self.initialize() cache = self.registry.get(self.key_groups, _marker) if cache and cache is not _marker: groups = cache.get(list_id, _marker) if groups and groups is not _marker: return groups return self._groups(list_id) def _groups(self, list_id=None): if not list_id: return self.connect() try: # mailchimp returns a list of groups for a single mailinglist. # We always choose the first and return just the groups part. return self.mailchimp.listInterestGroupings(id=list_id)[0] except MailChimpException, error: if error.code == 211: # "This list does not have interest groups enabled" # http://apidocs.mailchimp.com/api/1.3/exceptions.field.php#210-list-_-basic-actions return elif error.code == 200: # "Invalid MailChimp List ID" # http://apidocs.mailchimp.com/api/1.3/exceptions.field.php#200-list-related-errors return raise
else: acq.refreshed = True @task def convert_to_mobi(input_url, input_format="application/epub+zip"): return mobigen.convert_to_mobi(input_url, input_format) @task def generate_mobi_ebook_for_edition(edition): return mobigen.generate_mobi_ebook_for_edition(edition) from postmonkey import PostMonkey, MailChimpException pm = PostMonkey(settings.MAILCHIMP_API_KEY) @task def ml_subscribe_task(profile, **kwargs): try: if not profile.on_ml: return pm.listSubscribe(id=settings.MAILCHIMP_NEWS_ID, email_address=profile.user.email, **kwargs) except Exception, e: logger.error("error subscribing to mailchimp list %s" % (e)) return False @task
#!/usr/bin/python import eventbrite from postmonkey import PostMonkey print "Authorizing..." # authorization eb_auth_tokens = {'app_key': 'YOUR_APP_KEY', 'user_key': 'YOUR_USER_KEY'} eb_client = eventbrite.EventbriteClient(eb_auth_tokens) pm = PostMonkey('YOUR_MAILCHIMP_API_KEY') userEvents = eb_client.user_list_events() #print pm.ping() # returns u"Everything's Chimpy!" idlist = [evnt['event']['id'] for evnt in userEvents['events']] print "Found %s event(s)" % len(idlist) print idlist all_emails = [] print "Getting attendee emails..." for thisid in idlist: try: peeps = eb_client.event_list_attendees({'id':thisid}) except EnvironmentError as e: print e these_emails = [peep['attendee']['email'] for peep in peeps['attendees']] print "%s: [%s]" % (thisid, these_emails)
def connect(self): registry = getUtility(IRegistry) self.settings = registry.forInterface(IMailchimpSettings) self.mailchimp = PostMonkey(self.settings.api_key)
def strip2mailchimp(): """ { "created": 1326853478, "livemode": false, "id": "evt_00000000000000", "type": "charge.succeeded", "object": "event", "request": null, "data": { "object": { "id": "ch_00000000000000", "object": "charge", "created": 1412117456, "livemode": false, "paid": true, "amount": 100, "currency": "eur", "refunded": false, "card": { "id": "card_00000000000000", "object": "card", "last4": "4242", "brand": "Visa", "funding": "credit", "exp_month": 8, "exp_year": 2015, "fingerprint": "3WqOgApKDjCTvHEG", "country": "US", "name": null, "address_line1": null, "address_line2": null, "address_city": null, "address_state": null, "address_zip": null, "address_country": null, "cvc_check": "pass", "address_line1_check": null, "address_zip_check": null, "customer": null }, "captured": true, "refunds": { "object": "list", "total_count": 0, "has_more": false, "url": "/v1/charges/ch_14iZSOLQaIfBBJAWXuK7DE0I/refunds", "data": [] }, "balance_transaction": "txn_00000000000000", "failure_message": null, "failure_code": null, "amount_refunded": 0, "customer": null, "invoice": null, "description": "My First Test Charge (created for API docs)", "dispute": null, "metadata": {}, "statement_description": null, "receipt_email": null, "receipt_number": null } } } """ # locally use .form #i = request.form #for k in i: # event_json = json.loads(k) event_json = json.loads(request.data) # we have the data we are looking for if 'type' in event_json and event_json['type'] == 'charge.succeeded': # Get the email address email = event_json['data']['object']['receipt_email'] if not email == None: # Send that off to Mailchimp pm = PostMonkey(os.environ.get('MAILCHIMP_API_KEY','')) try: pm.listSubscribe(id=os.environ.get('MAILCHIMP_LIST_ID',''),email_address=email,double_optin=False) except MailChimpException, e: print e.code # 200 print e.error # u'Invalid MailChimp List ID: 42' return file('templates/500.json').read(), 500