def post(self, request, *args, **kwargs): if not settings.USE_MAILCHIMP: return Response({ "status": "error", "error": "Mailchimp is currently disabled." }) new_user_data = { 'email_address': request.data['email'], 'status': 'subscribed', 'tags': ['newsletter'] } mailchimp_client = MailChimp(settings.MAILCHIMP_API_KEY, settings.MAILCHIMP_USERNAME) # add the new user to the mailchimp list try: mailchimp_client.lists.members.create(settings.MAILCHIMP_LIST_ID, new_user_data) return Response({ "status": "success", "request": str(new_user_data) }) # TODO: Look into best practices for returning errors. except ValueError as value_error: return Response({"status": "error", "error": str(value_error)}) except Exception as e: if e.args[0].get('title') == "Member Exists": error_msg = "Email is already subscribed to newsletter." else: error_msg = "Unknown error. Please try again later." return Response({"status": "error", "error": error_msg})
def list_campaigns(filter=None): """This function creates a campaign in MailChimp through their API. :param attribute filter: an issuer internal indentifier. :returns: Campaign object or list of campaigns.""" client = MailChimp( mc_user=djangoSettings.MC_USER, mc_api=djangoSettings.MC_API_KEY, ) data = client.campaigns.all(get_all=True)['campaigns'] # A filter value has been sent, only return relevant rows if filter: output = [] for r in data: row = {} if str(filter) in r['settings']['title']: row['settings'] = r['settings'] row['report_summary'] = r['report_summary'] row['report_summary']['emails_sent'] = r['emails_sent'] row['report_summary']['send_time'] = parser.parse( r['send_time']) output.append(row) return output else: return data
def add_to_common_list_view(request): """Веб-сервис, добавляющий email в общий лист рассылки""" email = request.GET.get('email') if not email: return JsonResponse({'success': False, 'message': 'Передайте email'}) mailchimp_client = MailChimp( mc_api=settings.MAILCHIMP_API_KEY, mc_user=settings.MAILCHIMP_USERNAME) mailchimp_client.lists.members.create(settings.MAILCHIMP_COMMON_LIST_ID, { 'email_address': email, 'status': 'subscribed', }) subscriber_hash = mailchimp_client \ .search_members \ .get(query=email fields='exact_matches.members.id') \ .get('exact_matches').get('members')[0].get('id') mailchimp_client.lists.members.tags.update( list_id=settings.MAILCHIMP_COMMON_LIST_ID, subscriber_hash=subscriber_hash, data={'tags': [{'name': 'COMMON TAG', 'status': 'activate'}]}) CommonMailingList.objects.get_or_create(email=email) return JsonResponse({'success': True})
def update_mailchimp(modeladmin, request, queryset): valid_contacts = queryset.filter(email__isnull=False) client = MailChimp(mc_api=settings.MAILCHIMP_API, mc_user=settings.MAILCHIMP_USER) listas = client.lists.all(get_all=True, fields="lists.name,lists.id") lista = listas['lists'][0]['id'] for p in valid_contacts: user_hash = get_subscriber_hash(p.email) contact = { 'email_address': p.email, 'status_if_new': 'subscribed', 'merge_fields': { 'FNAME': p.nome, 'LNAME': p.sobrenome, 'CITY' : p.cidade, 'STATE' : p.estado, 'ORG' : p.entidade.first().nome if p.entidade.first() else '', 'SENSIBLE' : '', 'EVENTS' : '', 'PHONE' : p.telefone, 'ADDRESS' : p.endereco, 'GENDER' : p.sexo.nome if p.sexo else '', 'AGE' : p.idade() }, 'tags' : [], } contact['merge_fields'] = return_empty(contact['merge_fields']) resultado = client.lists.members.create_or_update(lista, user_hash, return_empty(contact)) modeladmin.message_user(request, '{} contatos atualizados.'.format(valid_contacts.count()))
def delete_user_from_mailchimp(email_address): client = MailChimp(mc_user=settings.MAILCHIMP_USER, mc_api=settings.MAILCHIMP_API_KEY) result = None try: result = client.search_members.get(query=email_address) if result: subscriber_hash = result.get('exact_matches', {}).get('members', [{}])[0].get('id', None) except Exception as e: logger.debug(e) try: client.lists.members.delete( list_id=settings.MAILCHIMP_LIST_ID, subscriber_hash=subscriber_hash, ) except Exception as e: logger.debug(e) try: client.lists.members.delete( list_id=settings.MAILCHIMP_LIST_ID_HUNTERS, subscriber_hash=subscriber_hash, ) except Exception as e: logger.debug(e) try: client.lists.members.delete( list_id=settings.MAILCHIMP_LIST_ID_HUNTERS, subscriber_hash=subscriber_hash, ) except Exception as e: logger.debug(e)
def setup_mailchimp_client(): user_name = 'anystring' api_key = os.environ['MAILCHIMP_API_KEY'] headers = requests.utils.default_headers() client = MailChimp(user_name, api_key, request_headers=headers) print 'MailChimp client created' return client
def push_new_users_to_mailchimp(key, new_users, list_id): """Push new users to MailChimp new user list.""" logging.info('Making an API call to MailChimp') client = MailChimp('apikey', str(key).strip()) current_members = get_all_current_members_of_list(client, list_id) logging.info('Pushing New Users to list: {0}'.format(list_id)) for email, full_name in new_users.iteritems(): if email not in current_members: name_split = full_name.split() try: client.lists.members.create( list_id, { 'email_address': email, 'status': 'subscribed', 'merge_fields': { 'FNAME': name_split[0], 'LNAME': name_split[-1], }, }) except requests.exceptions.HTTPError as error: if DEBUG: logging.error('Error: {0}'.format(error)) pass return
def verify_user(request, user_id, activation_nonce): """ Verify email and assign api token """ user = get_object_or_404(CapUser, pk=user_id) # This leaks a little info -- we reveal whether a user ID exists or not and whether it is verified or deactivated. # This seems acceptable to provide better messages to legitimate users. if user.email_verified: return render(request, 'registration/verified.html') if not user.is_active: return render( request, 'registration/verified.html', {'error': 'This account is not active and cannot be verified.'}) error = None mailing_list_message = "We have not signed you up for our newsletter, Lawvocado. Sign up any time from our homepage." try: user.authenticate_user(activation_nonce=activation_nonce) except PermissionDenied: error = mark_safe( "This verification code is invalid or expired. <a href='%s'>Resend verification</a>?" % reverse('resend-verification')) else: # user authenticated successfully # update API limits for first X users per day # users after this limit will have approved accounts, but we will have to go back manually to increase limits site_limits = SiteLimits.add_values(daily_signups=1) if site_limits.daily_signups < site_limits.daily_signup_limit: user.total_case_allowance = user.case_allowance_remaining = settings.API_CASE_DAILY_ALLOWANCE user.save() # sign them up for the mailing list if they selected the mailing_list checkbox. if settings.MAILCHIMP['api_key'] and user.mailing_list: try: mc_client = MailChimp(mc_api=settings.MAILCHIMP['api_key'], mc_user=settings.MAILCHIMP['api_user']) mc_client.lists.members.create( settings.MAILCHIMP['id'], { 'email_address': user.email, 'merge_fields': { 'LNAME': user.first_name, 'FNAME': user.last_name }, 'status': 'subscribed' }) mailing_list_message = "Also, thanks for signing up for our newsletter, Lawvocado." except MailChimpError as e: if e.args[0]['status'] == 400 and e.args[0][ 'title'] == 'Member Exists': mailing_list_message = "Also, thanks for your continued interest in our newsletter, " \ "Lawvocado. We'll keep you on our list." else: logger.exception( "Error adding user email %s to mailing list" % user.email) return render(request, 'registration/verified.html', { 'error': error, 'mailing_list_message': mailing_list_message, })
def mailchimp_subscribe(request: AuthHttpRequest): user = request.user if settings.TESTING or settings.DEBUG: logger.warning(f"Not actually subscribing {user} since we're testing") return elif API_KEY is not None: try: client = MailChimp(mc_api=API_KEY, mc_user='******') client.lists.members.create( os.getenv('MAILCHIMP_LIST_ID'), { 'email_address': user.email, 'status': 'subscribed', 'merge_fields': { 'FNAME': user.first_name, 'LNAME': user.last_name, } }) messages.success( request, "The email {user.email} is now listed as the " + "contact point for OTIS announcements from Evan.") except MailChimpError as e: logger.error(f"Could not add {user.email} to MailChimp", exc_info=e) messages.warning( request, "The email {user.email} could not be added to MailChimp, maybe it's subscribed already?" ) else: raise Exception("No API KEY provided in production!")
def form_valid(self, form): mailchimp_enabled = settings.MAILCHIMP_API_KEY and settings.MAILCHIMP_LIST_ID dummy_key = 'a' * 32 client = MailChimp(mc_api=settings.MAILCHIMP_API_KEY or dummy_key, timeout=5.0, enabled=mailchimp_enabled) data = form.cleaned_data.copy() email = data.pop('email') data = {k.upper(): v for k, v in data.items()} try: client.lists.members.create( settings.MAILCHIMP_LIST_ID, { 'email_address': email, 'status': 'pending', 'merge_fields': data, }) except Exception as e: self.warning(e) else: if mailchimp_enabled: self.success() else: self.warning( Exception( 'Incorrect Mailchimp configuration: API_KEY: {}, LIST_ID: {}' .format( str(settings.MAILCHIMP_API_KEY), str(settings.MAILCHIMP_LIST_ID), ))) return super().form_valid(form)
def handle(self, *args, **options): print("- match") from marketing.models import Match for match in Match.objects.all(): process_email(match.email, 'match') get_size = 50 client = MailChimp(settings.MAILCHIMP_USER, settings.MAILCHIMP_API_KEY) print('mailchimp') for i in range(0, 90000): members = client.lists.members.all(settings.MAILCHIMP_LIST_ID, count=get_size, offset=(i * get_size), fields="members.email_address") members = members['members'] if not len(members): break print(i) for member in members: email = member['email_address'] process_email(email, 'mailchimp') #TODO: could sync back #with client.lists.members.create( print('/mailchimp') print('local') print("- dashboard_sub") from dashboard.models import Subscription for sub in Subscription.objects.all(): email = sub.email process_email(email, 'dashboard_subscription') print("- tip") from dashboard.models import Tip for tip in Tip.objects.all(): for email in tip.emails: process_email(email, 'tip_usage') print("- bounty") from dashboard.models import Bounty for b in Bounty.objects.all(): email_list = [] if b.bounty_owner_email: email_list.append(b.bounty_owner_email) if b.claimee_email: email_list.append(b.claimee_email) for email in email_list: process_email(email, 'bounty_usage') print("- tdi") from tdi.models import WhitepaperAccess, WhitepaperAccessRequest for wa in WhitepaperAccess.objects.all(): process_email(wa.email, 'whitepaperaccess') for wa in WhitepaperAccessRequest.objects.all(): process_email(wa.email, 'whitepaperaccessrequest') print('/local')
def get_client(subscription): client = MailChimp( mc_api=subscription.mc_api, mc_user=subscription.mc_user, timeout=30.0, ) return client
def get(self, service=""): # test MailChimp API if service == "mailchimp": try: MAILCHIMP_API = os.environ.get('MAILCHIMP_API') headers = requests.utils.default_headers() client = MailChimp(mc_api=MAILCHIMP_API, timeout=60.0, request_headers=headers) client.lists.all(get_all=True, fields="lists.id") return {'status': 'OK'}, 200 except Exception as e: log.error(str(e)) # test GA API if service == "ga": try: # Define the auth scopes to request. scope = 'https://www.googleapis.com/auth/analytics.readonly' key_file_location = 'client_secrets.json' # Authenticate and construct service. service = get_service(api_name='analytics', api_version='v3', scopes=[scope], key_file_location=key_file_location) service.management().accounts().list().execute() return {'status': 'OK'}, 200 except Exception as e: log.error(str(e)) return {'status': 'ERROR'}, 500
def main(): # set all paths path_to_apikey = '/home/ubuntu/.apikeys' apikey_file = 'mailchimp-list.api' mc_user_file = 'mailchimp-user' path_to_lists = '/home/ubuntu/path/to/mailing-lists/updates' path_to_id_dict = '/home/ubuntu/.apikeys/list_ids.pickle' path_to_tag_dict = '/home/ubuntu/.apikeys/tag_ids.pickle' # load keys and data apikey = load_key(path_to_apikey, apikey_file) mailchimp_user = load_key(path_to_apikey, mc_user_file) lists_to_update = os.listdir(path_to_lists) list_id_dict = load_pickle(path_to_id_dict) tag_id_dict = load_pickle(path_to_tag_dict) master_list_name = '<CLIENT> Master Contact List' file_list_id = list_id_dict[master_list_name] new_member_list = list_id_dict['<CLIENT> New Members'] # initialize mailchimp client client = MailChimp(mc_api=apikey, mc_user=mailchimp_user) # add all new members to mailchimp for listfile in lists_to_update: # get tag id instead of list id # use one master list segment_id = tag_id_dict[listfile] list_to_add = os.path.join(path_to_lists, listfile) print('---> Starting List:', listfile) print('List ID:', file_list_id) print('Tag ID:', segment_id) add_to_mailchimp(list_to_add, file_list_id, segment_id, listfile, new_member_list, client)
def post(self, request): serializer = WaitlistSerializer(data=request.data) serializer.is_valid(raise_exception=True) client = MailChimp(mc_api=MAILCHIMP_API_KEY, mc_user='******') try: client.lists.update_members( list_id=MAILCHIMP_WAITLIST_ID, data={ 'members': [{ 'email_address': serializer.validated_data['email'], 'status': 'pending' }] }) total = client.lists.members.all( MAILCHIMP_WAITLIST_ID, status='subscribed', get_all=True, fields="members.email_address,members.id") count = len(total['members']) except requests.exceptions.RequestException as e: raise APIException('Could not subscribe to waitlist') return Response({'count': count})
def check_connection(self, logger: AirbyteLogger, config: Mapping[str, Any]) -> Tuple[bool, Any]: try: client = MailChimp(mc_api=config["apikey"], mc_user=config["username"]) client.ping.get() return True, None except Exception as e: return False, repr(e)
class SubscribeView(FormView): template_name = 'tonight/subscribe.html' form_class = EmailForm success_url = '/thanks/' client = MailChimp(MAILCHIMP_USER, MAILCHIMP_API_KEY) def subscribe(self, list_id, email): self.client.lists.members.create(list_id, { 'email_address': email, 'status': 'subscribed', }) def form_valid(self, form): # https://github.com/charlesthk/python-mailchimp data = form.cleaned_data try: if data['city'] == 'ALL': self.subscribe('9219e7e784', data['email']) elif data['city'] == 'HN': self.subscribe('ebb54415a6', data['email']) elif data['city'] == 'SG': self.subscribe('ca0033027c', data['email']) except Exception: return HttpResponseRedirect('/subscribe/existed/') return super(SubscribeView, self).form_valid(form)
def post(self, request): serializer = WaitlistSerializer(data=request.data) serializer.is_valid(raise_exception=True) client = MailChimp(mc_api=MAILCHIMP_API_KEY, mc_user='******') try: client.lists.update_members( list_id=MAILCHIMP_WAITLIST_ID, data={ 'members': [{ 'email_address': serializer.validated_data['email'], 'status': 'pending' }] }) local_cache = cache count = local_cache.get('waitlist_count') if not count: response = client.lists.members.all(MAILCHIMP_WAITLIST_ID, status='subscribed', count=0) count = response['total_items'] local_cache.set('waitlist_count', count) local_cache.incr('waitlist_count') except requests.exceptions.RequestException as e: raise APIException('Could not subscribe to waitlist') return Response({'count': count})
def mailchimp_subscribe(request, email, first_name, last_name, organisation, job_title): """Subscribe `email` to newsletter. Returns boolean indicating success """ del request.session["newsletter_email"] email_hash = hashlib.md5(email.encode("utf8")).hexdigest() data = { "email_address": email, "status": "subscribed", "merge_fields": { "FNAME": first_name, "LNAME": last_name, "MMERGE3": organisation, "MMERGE4": job_title, }, } client = MailChimp( mc_user=get_env_setting("MAILCHIMP_USER"), mc_api=get_env_setting("MAILCHIMP_API_KEY"), ) try: client.lists.members.get( list_id=settings.MAILCHIMP_LIST_ID, subscriber_hash=email_hash ) return True except MailChimpError: try: client.lists.members.create(list_id=settings.MAILCHIMP_LIST_ID, data=data) return True except MailChimpError: # things like blacklisted emails, etc logger.warn("Unable to subscribe %s to newsletter", email) return False
def update_email_subscriptions(sender, instance, created, **kwargs): if settings.DEBUG==False and not created: client = MailChimp(mc_api=settings.MAILCHIMP_API_KEY, timeout=10.0) email_hash = hashlib.md5(instance.user.email.lower().encode('utf-8')).hexdigest() interests = {} subscription_groups = SubscriptionGroup.objects.all(); for group in subscription_groups: interests[group.group_id] = instance.subscription_groups.filter(group_id__iexact=group.group_id).exists() client.lists.members.create_or_update( list_id=settings.SPEAKER_LIST_ID, subscriber_hash=email_hash, data={ 'email_address': instance.user.email, 'status': 'subscribed', 'status_if_new': 'pending', 'merge_fields': { 'FNAME': instance.first_name, 'LNAME': instance.last_name, 'IWOMAN': "Yes" if instance.woman else "No", 'IPOC': "Yes" if instance.poc else "No", 'ILGBTQA': "Yes" if instance.lgbtqa else "No", 'ITITLE': instance.position if instance.position else "undisclosed position", 'ICOMPANY': instance.organization if instance.organization else "undisclosed company", 'ICITY': instance.location.city if instance.location else "undisclosed location", }, 'interests': interests } )
def add_user_to_mailing_list(email: str) -> None: """ Adds the new user's email to our mailchimp list (which should trigger a welcome email) """ try: user = AuthUser.objects.get(email=email) client = MailChimp(settings.MAILCHIMP_API_KEY, mc_user=settings.MAILCHIMP_USERNAME) res = client.lists.members.create( settings.MAILCHIMP_LIST_ID, { "email_address": email, "status": "subscribed", "merge_fields": { "FNAME": user.first_name, "LNAME": user.last_name }, }, ) logger.info("Added user to email list. Response: ", res) except Exception as e: logger.exception( f"Exception while adding email {email} to mailing list.", e)
def form_valid(self, form): # add to mailchimp email = form.cleaned_data.get('email') if settings.MAILCHIMP_ENABLE and email: email_hash = hashlib.md5(email.lower().encode('utf-8')).hexdigest() try: mailchimp_client = MailChimp( mc_api=settings.MAILCHIMP_API_KEY, mc_user=settings.MAILCHIMP_USERNAME) data = { 'email_address': email, 'status': 'subscribed', 'status_if_new': 'subscribed' } mailchimp_client.lists.members.create_or_update( list_id=settings.MAILCHIMP_LIST_ID, subscriber_hash=email_hash, data=data) except Exception as e: pass return super().form_valid(form)
def my_handler(event, context): api_key = os.environ['API_KEY'] username = os.environ['USERNAME'] list_id = os.environ['LIST_ID'] client = MailChimp(mc_api=api_key, mc_user=username) content_type = event['headers']['Content-Type'] email = parse_email(content_type, event['body']) try: lists = client.lists.all() logger.info(lists) members = client.lists.members.create(list_id, { 'email_address': email, 'status': 'subscribed' }) except MailChimpError as e: print(e) return { 'statusCode': 400, "header": { "Content-Type": "application/json" }, 'body': str(e) } return { 'statusCode': 200, "header": { "Content-Type": "application/json" } 'body': '' }
def add_to_case_list_view(request): """Веб-сервис, добавляющий email в лист рассылки по конкретному делу""" email = request.GET.get('email') if not email: return JsonResponse({'success': False, 'message': 'Передайте email'}) case_id = request.GET.get('case_id') if not case_id: return JsonResponse({'success': False, 'message': 'Передайте case_id'}) mailchimp_client = MailChimp( mc_api=settings.MAILCHIMP_API_KEY, mc_user=settings.MAILCHIMP_USERNAME) mailchimp_client.lists.members.create(settings.MAILCHIMP_CASE_LIST_ID, { 'email_address': email, 'status': 'subscribed', }) subscriber_hash = mailchimp_client \ .search_members \ .get(query=email fields='exact_matches.members.id') \ .get('exact_matches').get('members')[0].get('id') case = Case.objects.get(pk=case_id) case_tag = f'Case {case.name}' mailchimp_client.lists.members.tags.update( list_id=settings.MAILCHIMP_CASE_LIST_ID, subscriber_hash=subscriber_hash, data={'tags': [{'name': case_tag, 'status': 'activate'}]}) CaseMailingList.objects.get_or_create(email=email) return JsonResponse({'success': True})
def push_to_mailchimp(): print('- push_to_mailchimp') client = MailChimp(settings.MAILCHIMP_API_KEY, settings.MAILCHIMP_USER) created_after = timezone.now() - timezone.timedelta(hours=2) eses_funder = EmailSubscriber.objects.filter( active=True, created_on__gt=created_after, profile__persona_is_funder=True).order_by('-pk') print("funder emails") print("- {} emails".format(eses_funder.count())) sync_mailchimp_list(eses_funder, settings.MAILCHIMP_LIST_ID_FUNDERS) eses_hunter = EmailSubscriber.objects.filter( active=True, created_on__gt=created_after, profile__persona_is_hunter=True).order_by('-pk') print("hunter emails") print("- {} emails".format(eses_hunter.count())) sync_mailchimp_list(eses_hunter, settings.MAILCHIMP_LIST_ID_HUNTERS) eses = EmailSubscriber.objects.filter( active=True, created_on__gt=created_after).order_by('-pk') print("all emails") print("- {} emails".format(eses.count())) sync_mailchimp_list(eses, settings.MAILCHIMP_LIST_ID) print('/push_to_mailchimp')
def essense(request): if request.method == 'GET': cal = Calendar.objects.all()[:5] side = Post.objects.filter(page='SB') info = Post.objects.filter(page='CI') post = Post.objects.filter(page='ES') context = { 'post': post, 'title': '', 'side': side, 'info': info, 'cal': cal } #if get, show past newsletters return render(request, 'Stevie/letterIndex.html', context) elif request.method == 'POST': emailer = request.POST.get('name') email = request.POST.get('email') client = MailChimp(mc_api=API_KEY) client.lists.members.create( LIST_ID, { 'email_address': email, 'status': 'subscribed', 'merge_fields': { 'FNAME': emailer, }, }) return redirect('essense')
def reports_result(date_range, campaign_name_search): client = MailChimp(user_name, api_key) all_json_data = client.reports.all(get_all=True) all_reports = all_json_data['reports'] reports_in_daterange = all_reports#[0:50] # TODO: create new method find_index_for_date_range to handle a simple string date range input and provide the right index number for this filter matching_reports = [reports for reports in reports_in_daterange if campaign_name_search in reports["campaign_title"]] return matching_reports
def client(self) -> MailChimp: """ Get the MailChimp client """ return MailChimp(mc_user=settings.NEWSLETTER_USERNAME, mc_secret=settings.NEWSLETTER_API_KEY, request_headers=self.headers)
def get_client(): headers = default_headers() headers['User-Agent'] = 'Digital Marketplace (marketplace.service.gov.au)' client = MailChimp(getenv('MAILCHIMP_SECRET_API_KEY'), getenv('MAILCHIMP_USERNAME'), timeout=30.0, request_headers=headers) return client
def _get_mailchimp_client() -> MailChimp: """ Возвращает клиент API для работы с Mailchimp """ return MailChimp( mc_api=settings.MAILCHIMP_API_KEY, mc_user=settings.MAILCHIMP_USERNAME )