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 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 __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
def connect(self):
if self.mailchimp is not None:
return
self.initialize()
self.mailchimp = PostMonkey(self.settings.api_key)
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
