def get_context_data(self, **kwargs): # check outdated bomb alarms alert_list = BombAlarm.objects.filter(time__lt=datetime.now()) for alert in alert_list: due = humanizeTimeDiff(alert.bomb.getDueDate()) subject = u'[컴바라기] 폭탄이 터지기 까지 %s 남았습니다.' % due content = u'폭탄(%s)이 터지기까지 %s 남았습니다. 해당 폭탄이 필요하다면 빠르게 회수하세요!' % (alert.bomb.title, due) try: email = EmailMessage(subject, content, from_email='*****@*****.**', to=alert.bomb.user.email) email.content_subtype = "html" email.send() except: pass alert.delete() # check outdated bombs deleted_list = Bomb.objects.filter(uploaded__lt=datetime.now() - timedelta(days=settings.BOMB_TIME_DAYS)) for deleted in deleted_list: # mail to the user of bomb user. subject = u'[컴바라기] 당신의 폭탄이 터졌습니다.' content = u'폭탄(%s)이 터졌습니다.' % deleted.title try: email = EmailMessage(subject, content, from_email='*****@*****.**', to=deleted.user.email) email.content_subtype = "html" email.send() except: pass deleted_list.delete() context = super(BombListView, self).get_context_data(**kwargs) context['bomb_time'] = settings.BOMB_TIME_DAYS context['total'] = Bomb.objects.count() context['used'] = Bomb.getMyUsed(self.request.user) context['given'] = settings.BOMB_SPACE_PERSONAL return context
def enviarEmailSemTempalte(self, vTitulo, vTexto, vEmailDestino, vEmailRemetente, vEhText=False): try: if settings.EMAIL: iEmail = EmailMessage(vTitulo, vTexto, vEmailRemetente, [vEmailDestino]) if vEhText: iEmail.content_subtype = "text" else: iEmail.content_subtype = "html" iEmail.send() return True except Exception, e: Erro().registraLog('enviarEmailSemTempalte', 'models.py', 'comunicacao', str(e), constantes.cntTipoLogErro) return False
def send_email(subject, message, receivers, **kwargs): receivers = get_receivers(receivers) sender = kwargs.get('sender', settings.EMAIL_HOST_USER) category = kwargs.get('category') attachments = kwargs.get('attachments', []) email_kwargs = {} for arg in ['bcc', 'cc', 'reply_to', 'headers']: email_kwargs[arg] = kwargs.get(arg) email = EmailMessage(subject=subject, body=message, from_email=sender, to=receivers, **email_kwargs) email.content_subtype = FORMAT_HTML # As 'NoneType' object is not iterable. if attachments: for file_path in attachments: email.attach_file(file_path) email_result = email.send() email_kwargs.update({ 'category': category, 'result': email_result, 'receivers': receivers, 'attachments': attachments, 'sender': sender, 'subject': subject, 'message': message }) return email_kwargs
def send_html_email( subject: str, to: List[str], template_name: str, context: Dict[str, Any], ) -> int: """ Sends an HTML and plain text email from a Django template. Args: subject: The subject of the email. to: The list of recipients. template_name: The name of the template to render, assumes the plain text version is a template with the same name with `.txt` extension. context: The context to render the template with. """ site = Site.objects.get_current() context = { "site_name": site.name, "site_domain": site.domain, } html_content = render_to_string(template_name, context) msg = EmailMessage(subject, html_content, [to]) msg.content_subtype = "html" return msg.send()
def forgotpassword(request): logger.info("User is on forgot password page") reset = False if request.method == 'POST': form = ForgotPasswordForm(request.POST, rp={}) if form.is_valid(): cleaned_data = form.cleaned_data users = User.objects.filter(email=cleaned_data['email']) if len(users) > 0: user = users[0] user.player.reset_code = id_generator(size=32) user.player.save() template = loader.get_template("mail/resetpassword.html") message_text = template.render(Context({ "link": "http://nmk.kokanovic.org/profile/reset?id=%s" % user.player.reset_code, "username": user.username})) logger.info("Sending mail to reset user's password to %s", user.email) msg = EmailMessage(u"[nmk] Zahtev za resetovanjem lozinke", message_text, "*****@*****.**", to=[user.email,]) msg.content_subtype = "html" msg.send(fail_silently = False) reset = True else: form = ForgotPasswordForm(rp={}) return render(request, "forgotpassword.html", {"form": form, 'reset': reset})
def send(self, fail_silently=False): recipient_list = [] recipient_bcc_list = [] headers = {} if self.recipient: recipient_list = self.recipient.split(',') recipient_list = [recipient.strip() for recipient in recipient_list \ if recipient.strip() <> ''] if self.recipient_cc: recipient_cc_list = self.recipient_cc.split(',') recipient_cc_list = [recipient_cc.strip() for recipient_cc in recipient_cc_list if \ recipient_cc.strip() <> ''] recipient_list += recipient_cc_list if self.recipient_bcc: recipient_bcc_list = self.recipient_bcc.split(',') recipient_bcc_list = [recipient_bcc.strip() for recipient_bcc in recipient_bcc_list if \ recipient_bcc.strip() <> ''] if self.reply_to: headers['Reply-To'] = self.reply_to if self.sender_display: headers['From'] = '%s<%s>' % (self.sender_display, self.sender) if recipient_list or recipient_bcc_list: msg = EmailMessage(self.subject, self.body, self.sender, recipient_list, recipient_bcc_list, headers=headers ) if self.content_type == 'html' or self.content_type == 'text/html': msg.content_subtype = 'html' msg.send(fail_silently=fail_silently)
def post(self, request, *args, **kwargs): form = self.form_class(request.POST) if form.is_valid(): data = form.cleaned_data["email"] else: data = False if self.check_user_input(data) is True: associated_users = get_user_model()._default_manager.filter(email=data) if associated_users.exists(): for user in associated_users: c = self.get_email_context(user=user, request=request) subject = self.subject email = loader.render_to_string(self.email_template, c) mail = EmailMessage(subject, email, self.from_email, [user.email]) mail.content_subtype = "html" try: mail.send() result = self.form_valid(form) messages.success(request, strings.RESET_PASSWORD_CONFIRM) except Exception as e: print(e) messages.success(request, strings.RESET_PASSWORD_ERR_SEND_EMAIL) result = self.form_invalid(form) result = self.form_valid(form) messages.success(request, strings.RESET_PASSWORD_CONFIRM.format(data)) result = self.form_invalid(form) messages.error(request, strings.RESET_PASSWORD_ERR_NO_EMAIL) else: messages.error(request, strings.RESET_PASSWORD_ERR_FORMAT_EMAIL) result = self.form_invalid(form) return result
def register(request): registration_type = request.GET.get('type', '') logger.info('User is on register page, going with %s type', registration_type) last_registration_time = datetime(2018, 6, 14, 14, 0, tzinfo=timezone.utc) if timezone.now() >= last_registration_time: raise Http404() if request.method == 'POST': form = RegisterForm(request.POST) if form.is_valid(): cleaned_data = form.cleaned_data user = User.objects.create_user(username=cleaned_data['email'], email=cleaned_data['email'], password=cleaned_data['password'], first_name=cleaned_data['display_name'], last_name='', is_active=False, last_login=timezone.now()) user.player.activation_code = id_generator() user.player.save() player = update_player_upon_registration(user) with translation.override(player.language): subject = _('[sharkz.bet] Registration successful') template = loader.get_template('mail/registered.html') message_text = template.render( {'link': 'https://sharkz.bet/activate?id=%s' % user.player.activation_code}) logger.info('Sending mail that user is registered to %s', user.email) msg = EmailMessage(subject, message_text, '*****@*****.**', to=[user.email, ]) msg.content_subtype = 'html' msg.send(fail_silently=False) return HttpResponseRedirect(reverse(register_success)) else: form = RegisterForm() return render(request, 'register.html', {'form': form, 'no_menu': True})
def create_notice(notice_type, user, mail_data={}, notice_data={}, mail_template=None): """ Create a new notice. @type notice_type: unicode @type user: django.contrib.auth.models.User @type mail_data: dict @type notice_data: dict """ log = json.dumps(notice_data) Notice.objects.create(type=notice_type, user=user, log=log) email = user.get_profile().reminder_email if email and mail_data: current_site = Site.objects.get_current().domain mail_data['site'] = current_site template = mail_template if mail_template else 'mail/%s.txt' % notice_type message = render_to_string(template, mail_data) msg = EmailMessage(mail_data['subject'], message, DEFAULT_FROM_EMAIL, [user.get_profile().reminder_email]) msg.content_subtype = 'html' msg.send()
def forgotpassword(request): logger.info('User is on forgot password page') reset = False if request.method == 'POST': form = ForgotPasswordForm(request.POST, rp={}) if form.is_valid(): cleaned_data = form.cleaned_data users = User.objects.filter(email=cleaned_data['email']) if len(users) > 0: user = users[0] user.player.reset_code = id_generator(size=32) user.player.save() with translation.override(user.player.language): subject = _('[sharkz.bet] Reset password request') template = loader.get_template('mail/resetpassword.html') message_text = template.render( {'link': 'https://sharkz.bet/profile/reset?id=%s' % user.player.reset_code, 'email': user.email}) logger.info('Sending mail to reset user\'s password to %s', user.email) msg = EmailMessage(subject, message_text, '*****@*****.**', to=[user.email, ]) msg.content_subtype = 'html' msg.send(fail_silently=False) reset = True else: form = ForgotPasswordForm(rp={}) return render(request, 'forgotpassword.html', {'form': form, 'reset': reset})
def send_voting_email(request, voting, exclude_memberships=None): ctx_dict = { 'voting': voting, 'site': get_current_site(request), 'protocol': settings.SSL_ON and 'https' or 'http', } for voter in voting.voters.all(): member = voter.membership if exclude_memberships and member in exclude_memberships: continue ctx_dict['recipient'] = member ctx_dict['link'] = '{procotol}://{site}{url}'.format( procotol=ctx_dict['protocol'], site=ctx_dict['site'], url=voter.get_voting_url()) tmpl = TemplateModel.objects.get(name=TemplateModel.VOTING_INVITATION) subject = tmpl.generate_title(ctx_dict) or voting.account.name message = tmpl.generate(ctx_dict) mail = EmailMessage(subject, message, settings.DEFAULT_FROM_EMAIL, [member.user.email]) admin_emails = [ m.user.email for m in voting.account.get_admin_memberships() if m.id != member.id ] if admin_emails: mail.extra_headers['Reply-To'] = ', '.join(admin_emails) mail.content_subtype = "html" mail.send()
def test_location_determining(request): by_IP = location_service.LocationByIP(request) lat_lng = by_IP.lat_lon location_data = { 'region': by_IP.canadian_region.name if by_IP.canadian_region is not None else '', 'city': by_IP.city.name if by_IP.city is not None else '', 'location_lat': lat_lng[1], 'location_lng': lat_lng[0], 'ip': by_IP.ip } meta = request.META message = json.dumps({ 'location_data': location_data, 'meta_data': { x: meta[x] for x in meta if type(meta[x]) in [int, str, bool, unicode] } }) subject = "Bad ip on Cityfusion." msg = EmailMessage(subject, message, '*****@*****.**', ['*****@*****.**']) msg.content_subtype = 'html' msg.send() return HttpResponse(json.dumps(location_data), mimetype='application/json')
def save(self, *args, **kwargs): is_new = self.pk is None if self.send_answer: subject = u'Ответ на ваш вопрос - %s' % settings.SITE_NAME subject = u''.join(subject.splitlines()) message = render_to_string( 'faq/user_message_template.html', { 'saved_object': self, 'site_name': settings.SITE_NAME, } ) emailto = self.email msg = EmailMessage(subject, message, settings.DEFAULT_FROM_EMAIL, [emailto]) msg.content_subtype = "html" msg.send() self.send_answer = False self.state = 'sent' else: if not is_new: self.state = 'saved' super(Question, self).save() if is_new: if self.allow_mailings: self.create_mailing_address(is_active=True) else: self.create_mailing_address(is_active=False)
def custom_email(label, to, cc=None, attachments=None, context=None): if not isinstance(to, (list, tuple)): to = [to] if not isinstance(cc, (list, tuple)): cc = [cc] full_context = dict() full_context.update({} or context) mail_obj = EmailMessage() mail_obj.to = to mail_obj.cc = cc mail_obj.subject = render_to_string('email/{}/subject.txt'.format(label), context=full_context) mail_obj.from_email = settings.EMAIL_HOST_USER mail_obj.body = render_to_string('email/{}/message.html'.format(label), context=full_context) if attachments: for file_name in attachments: if os.path.exists(file_name): mail_obj.attach_file(file_name) else: logging.debug( "file is not available in specified location: {}".format( file_name)) mail_obj.content_subtype = "html" try: return mail_obj.send() except Exception as e: msg = u"sending email failed\n" msg += unicode(e) print >> sys.stderr, e
def SaveQuestionForm(request): if request.is_ajax(): data = request.POST.copy() faq_form = QuestionForm(data) if faq_form.is_valid(): saved_object = faq_form.save() subject = u'%s - Новый вопрос' % settings.SITE_NAME subject = u''.join(subject.splitlines()) message = render_to_string( 'faq/admin_message_template.html', { 'saved_object': saved_object, 'site_name': settings.SITE_NAME, } ) try: emailto = Settings.objects.get(name='workemail').value except Settings.DoesNotExist: emailto = False if emailto: msg = EmailMessage(subject, message, settings.DEFAULT_FROM_EMAIL, [emailto]) msg.content_subtype = "html" msg.send() return HttpResponse('success') else: faq_form_html = render_to_string( 'faq/faq_form.html', {'form': faq_form} ) return HttpResponse(faq_form_html) else: return HttpResponseBadRequest()
def post(self, request, *args, **kwargs): """ Sends the feedback email to admin. """ obj = self.get_object() form = FeedbackForm(request.POST) if not form.is_valid(): return render(request, 'app/article_detail.html', { 'feedback_form': form, 'object': obj, 'already_voted': False, 'display_form': True, }) email = form.cleaned_data['email'] email_message = EmailMessage( subject=_('New feedback from article {0}'.format(obj.name)), body=render_to_string('feedback_email.html', { 'feedback_message': form.cleaned_data['description'], 'feedback_email': email, 'article': obj, 'base_url': settings.SITE_URL, }), to=[settings.SUPPORT_EMAIL], reply_to=[email], ) email_message.content_subtype = 'html' email_message.send() messages.success( request, _('Thank you for sending your feedback!') ) return redirect(obj)
def send_message(to_email, body_template, subject_template, from_email=settings.DEFAULT_FROM_EMAIL, reply_to=None, sender=None, content_type="html", extra_context=None): """ Send a message using a given body and subject templates for email. """ if type(from_email) in (tuple, list): # Use the first email if list or tuple provided from_email = from_email[0].encode('utf-8') context = { 'sender': sender, } headers = {'Reply-To': reply_to} context.update(extra_context or {}) msg = EmailMessage(render_to_string(subject_template, context), render_to_string(body_template, context), from_email, # from (to_email,), # to headers=headers) msg.content_subtype = content_type # Main content is now text/html msg.send()
def format_and_send_html_email(experiment, file_string, template_vars, subject, email_type, cc_recipients=None): content = render_to_string(file_string, template_vars) version = experiment.format_firefox_versions channel = experiment.firefox_channel recipients = [experiment.owner.email] + list( experiment.subscribers.values_list("email", flat=True)) if experiment.analysis_owner: recipients.append(experiment.analysis_owner) email = EmailMessage( subject.format(name=experiment.name, version=version, channel=channel), content, settings.EMAIL_SENDER, recipients, cc=cc_recipients, ) email.content_subtype = "html" email.send(fail_silently=False) ExperimentEmail.objects.create(experiment=experiment, type=email_type)
def register(request): logger.info("User is on register page") last_registration_time = datetime(2016, 6, 10, 20, 0) if datetime.now() >= last_registration_time: raise Http404() registered = False if request.method == 'POST': form = RegisterForm(request.POST, user={}) if form.is_valid(): cleaned_data = form.cleaned_data user = User.objects.create_user(username = cleaned_data['username'], email = cleaned_data['email'], password = cleaned_data['password'], first_name = cleaned_data['first_name'], last_name = cleaned_data['last_name'], is_active = False, last_login = datetime.now()) user.player.activation_code = id_generator() user.player.save() template = loader.get_template("mail/registered.html") message_text = template.render(Context({"link": "http://nmk.kokanovic.org/activate?id=%s" % user.player.activation_code})) logger.info("Sending mail that user is registered to %s", user.email) msg = EmailMessage(u"[nmk] Registracija na NMK uspešna", message_text, "*****@*****.**", to=[user.email,]) msg.content_subtype = "html" msg.send(fail_silently = False) registered = True else: form = RegisterForm(user={}) return render(request, "register.html", {"form": form, 'registered': registered})
def post(self, request, *args, **kwargs): """ Sends the feedback email to admin. """ obj = self.get_object() form = FeedbackForm(request.POST) if not form.is_valid(): return render( request, 'app/article_detail.html', { 'feedback_form': form, 'object': obj, 'already_voted': False, 'display_form': True, }) email = form.cleaned_data['email'] email_message = EmailMessage( subject=_('New feedback from article {0}'.format(obj.name)), body=render_to_string( 'feedback_email.html', { 'feedback_message': form.cleaned_data['description'], 'feedback_email': email, 'article': obj, 'base_url': settings.SITE_URL, }), to=[settings.SUPPORT_EMAIL], reply_to=[email], ) email_message.content_subtype = 'html' email_message.send() messages.success(request, _('Thank you for sending your feedback!')) return redirect(obj)
def save_user(form, client): list_mail = dict() name = form.cleaned_data['name'] email = form.cleaned_data['email'] user = form.cleaned_data['user'].upper() groups = form.cleaned_data['groups'] user_ldap = form.cleaned_data[ 'ldap_user'] if form.cleaned_data['is_ldap'] else None list_mail['nome'] = name list_mail['user'] = user password = make_random_password() list_mail['pass'] = password new_user = client.create_usuario().inserir( user, password, name, email, user_ldap) for group in groups: client.create_usuario_grupo().inserir( new_user.get('usuario')['id'], group) if user_ldap is None: connection = EmailBackend( username=EMAIL_HOST_USER, password=EMAIL_HOST_PASSWORD) send_email = EmailMessage('Novo Usuário CadVlan-Globo.com', loader.render_to_string( MAIL_NEW_USER, list_mail), EMAIL_FROM, [email], connection=connection) send_email.content_subtype = "html" send_email.send()
def home(request): if request.method == 'POST': form = ContactForm(request.POST, request.FILES) if form.is_valid(): contact = form.save() message = render_to_string("email.html", {'contact': contact}) msg = EmailMessage('Info verzoek van anverhuizen.be', message, contact.email, ['*****@*****.**']) msg.content_subtype = "html" if 'attachment' in request.FILES: request.FILES['attachment'].seek(0) msg.attach(request.FILES['attachment'].name, request.FILES['attachment'].read(), request.FILES['attachment'].content_type) msg.send(fail_silently=False) messages.success(request, _("Ik heb jouw bericht ontvangen en zal zo snel mogelijk contact opnemen.")) return HttpResponseRedirect(reverse('home')) else: form = ContactForm() return render_to_response('home.html', {'form': form}, RequestContext(request))
def send_email_to_data_sender(user, language_code, request=None, type="activation"): site = get_current_site(request) ctx_dict = { 'domain': site.domain, 'uid': int_to_base36(user.id), 'user': user, 'token': default_token_generator.make_token(user), 'protocol': 'http', 'site': site, } types = dict({"activation": dict({"subject":'activatedatasenderemail/activation_email_subject_for_data_sender_account_', "subject_param":False, "template": 'activatedatasenderemail/activation_email_for_data_sender_account_'}), "created_user": dict({"subject": 'registration/created_user_email_subject_', "subject_param":site.domain, "template": 'registration/created_user_email_'})}) if type not in types: return action = types.get(type) subject = render_to_string(action.get("subject") + language_code + '.txt') subject = ''.join(subject.splitlines()) if action.get("subject_param"): subject = subject % action.get("subject_param") if request is not None: ctx_dict.update({"creator_user": request.user.first_name}) message = render_to_string(action.get("template") + language_code + '.html', ctx_dict) email = EmailMessage(subject, message, EMAIL_HOST_USER, [user.email], [HNI_SUPPORT_EMAIL_ID]) email.content_subtype = "html" email.send()
def email_admin(log): subject = 'Retrive Latest Currency' content = 'Exception occurred: %s' % log sender = settings.ADMINS[0][1] mail = EmailMessage(subject, content, sender, ['*****@*****.**', '*****@*****.**']) mail.content_subtype = 'html' mail.send()
def process_location_reassignment(domain, transitions, uploaded_filename, user_email): try: Processor(domain, transitions).process() except Exception as e: email = EmailMessage( subject= f"[{settings.SERVER_ENVIRONMENT}] - Location Reassignment Failed", body=linebreaksbr( f"The request could not be completed for file {uploaded_filename}. Something went wrong.\n" f"Error raised : {e}.\n" "Please report an issue if needed."), to=[user_email], from_email=settings.DEFAULT_FROM_EMAIL) email.content_subtype = "html" email.send() raise e else: email = EmailMessage( subject= f"[{settings.SERVER_ENVIRONMENT}] - Location Reassignment Completed", body= f"The request has been successfully completed for file {uploaded_filename}.", to=[user_email], from_email=settings.DEFAULT_FROM_EMAIL) email.send()
def email_other_cases_details(domain, transitions, uploaded_filename, user_email): try: transition_objs = [ Transition(**transition) for transition in transitions ] filestream = OtherCases(domain).dump(transition_objs) except Exception as e: email = EmailMessage( subject= f"[{settings.SERVER_ENVIRONMENT}] - Location Reassignment Other Cases Dump Failed", body=linebreaksbr( f"The request could not be completed for file {uploaded_filename}. Something went wrong.\n" f"Error raised : {e}.\n" "Please report an issue if needed."), to=[user_email], from_email=settings.DEFAULT_FROM_EMAIL) email.content_subtype = "html" email.send() raise e else: email = EmailMessage( subject= f"[{settings.SERVER_ENVIRONMENT}] - Location Reassignment Other Cases Dump Completed", body= f"The request has been successfully completed for file {uploaded_filename}. ", to=[user_email], from_email=settings.DEFAULT_FROM_EMAIL) if filestream: email.attach(filename="Other Cases.zip", content=filestream.read()) else: email.body += "There were no cases found. " email.body += f"Please note that the cases are fetched only for " \ f"{', '.join(OtherCases.valid_operations)}." email.send()
def remind_account_about_events_with_email(account, single_events): if account.reminder_email: featured_events = Event.featured_events_for_region(account.native_region)[0:4] similar_events = find_similar_events( Event.future_events.filter(id__in=single_events.values_list("event_id", flat=True)) ) subject = "Upcoming events from cityfusion" message = render_to_string('accounts/emails/reminder_email.html', { "featured_events": featured_events, "events": single_events, "similar_events": similar_events, "STATIC_URL": "/static/", "advertising_region": account.advertising_region, "site": "http://%s" % Site.objects.get_current().domain }) try: msg = EmailMessage(subject, message, "*****@*****.**", [account.reminder_email]) msg.content_subtype = 'html' msg.send() except: logger.error("Invalid email %s" % account.reminder_email) return message else: return ""
def contacto(request): form = ContactoForm(request.POST or None) if form.is_valid(): nombre = form.cleaned_data.get("nombre_completo") correo = form.cleaned_data.get("email") mensaje = form.cleaned_data.get("mensaje") fecha = datetime.datetime.now() titulo = "Contacto Qpet" contenido = render_to_string('mails/contacto-mail.html', {'nombre':nombre, 'correo':correo, 'mensaje': mensaje, 'fecha':fecha}) # ... email = EmailMessage(titulo, contenido, settings.EMAIL_HOST_USER, ['*****@*****.**'], ['*****@*****.**']) email.content_subtype = "html" email.send() form = ContactoForm() context = { "form": form, } return render(request,"sitio/contacto.html",context)
def remind_account_about_events_with_email(account, single_events): featured_events = Event.featured_events_for_region(account.native_region) similar_events = find_similar_events( Event.future_events.filter(id__in=single_events.values_list("event_id", flat=True)) ) subject = "Upcoming events from cityfusion" message = render_to_string( "accounts/emails/reminder_email.html", { "featured_events": featured_events, "events": single_events, "similar_events": similar_events, "STATIC_URL": "/static/", "advertising_region": account.advertising_region, "site": "http://%s" % Site.objects.get_current().domain, }, ) msg = EmailMessage(subject, message, "*****@*****.**", [account.reminder_email]) msg.content_subtype = "html" msg.send() return message
def create_notice(notice_type, user, mail_data={}, notice_data={}, mail_template=None): """ Create a new notice. @type notice_type: unicode @type user: django.contrib.auth.models.User @type mail_data: dict @type notice_data: dict """ log = json.dumps(notice_data) Notice.objects.create(type=notice_type, user=user, log=log) email = user.get_profile().reminder_email if email and mail_data: current_site = Site.objects.get_current().domain mail_data['site'] = current_site template = mail_template if mail_template else 'mail/%s.txt' % notice_type message = render_to_string(template, mail_data) msg = EmailMessage(mail_data['subject'], message, DEFAULT_FROM_EMAIL, [user.get_profile().reminder_email]) msg.content_subtype = 'html' msg.send()
def inform_account_about_events_with_tag_with_email(account, events, tags_in_venues): if account.in_the_loop_email: featured_events = Event.featured_events_for_region( account.native_region)[:4] similar_events = find_similar_events(events) subject = "New Events in cityfusion" message = render_to_string( 'accounts/emails/in_the_loop_email.html', { "featured_events": featured_events, "events": events, "similar_events": similar_events, "STATIC_URL": "/static/", "site": "http://%s" % Site.objects.get_current().domain, "tags_in_venues": tags_in_venues, "advertising_region": account.advertising_region, }) try: msg = EmailMessage(subject, message, "*****@*****.**", [account.in_the_loop_email]) msg.content_subtype = 'html' msg.send() except: logger.error("Invalid email %s" % account.in_the_loop_email) return message else: return ""
def emailsending(key,template,email,msg): print('ok') message = get_template(template).render(key) email = EmailMessage(msg, message, to=[email]) email.content_subtype = 'html' email.send() print('Email Snd Successfully')
def send_html_message(subject, html_content, from_email, to_list): # with open( "output.html" , "w") as debug_file: # debug_file.write(html_content) msg = EmailMessage(string_to_email_subject(subject), html_content, from_email, to_list) msg.content_subtype = "html" # Main content is now text/html msg.send()
def save_user(form, client): list_mail = dict() name = form.cleaned_data['name'] email = form.cleaned_data['email'] user = form.cleaned_data['user'].upper() groups = form.cleaned_data['groups'] user_ldap = form.cleaned_data['ldap_user'] if form.cleaned_data[ 'is_ldap'] else None list_mail['nome'] = name list_mail['user'] = user password = make_random_password() list_mail['pass'] = password new_user = client.create_usuario().inserir(user, password, name, email, user_ldap) for group in groups: client.create_usuario_grupo().inserir( new_user.get('usuario')['id'], group) if user_ldap is None: connection = EmailBackend(username=EMAIL_HOST_USER, password=EMAIL_HOST_PASSWORD) send_email = EmailMessage('Novo Usuário CadVlan-Globo.com', loader.render_to_string( MAIL_NEW_USER, list_mail), EMAIL_FROM, [email], connection=connection) send_email.content_subtype = "html" send_email.send()
def send_confirmation(self): url = reverse("users:reset_password", kwargs=dict(key=self.key)) url = "http://%s%s" % (Site.objects.get_current().domain, url) body = render_to_string("users/emails/reset-password-confirmation.html", dict(url=url, user=self.user)) message = EmailMessage(u"Reset your OER Commons password", body, to=[self.user.email]) message.content_subtype = "html" message.send()
def process_user(self, user_to_recover): if (not user_to_recover.has_usable_password() or not hasattr(user_to_recover, 'email') or not user_to_recover.email): return False context = { 'site_name': getattr(self.request, "shop", _("shop")), 'uid': urlsafe_base64_encode(force_bytes(user_to_recover.pk)), 'user_to_recover': user_to_recover, 'token': self.token_generator.make_token(user_to_recover), 'request': self.request, } subject = loader.render_to_string(self.subject_template_name, context) subject = ''.join( subject.splitlines()) # Email subject *must not* contain newlines body = loader.render_to_string(self.email_template_name, context, request=self.request) email = EmailMessage(from_email=self.from_email, subject=subject, body=body, to=[user_to_recover.email]) email.content_subtype = settings.SHUUP_AUTH_EMAIL_CONTENT_SUBTYPE email.send() return True
def send_mail(subject, template_name, to, **kwargs): kwargs['settings'] = settings body = render_to_string(template_name, kwargs) if to: msg = EmailMessage(subject, body, None, to=to) msg.content_subtype = "html" msg.send()
def send_mail(self, request, newsletter_id): object = Newsletter.objects.get(id=newsletter_id) subscribers = Subscription.objects.filter(subscribed=True) site = Site.objects.get_current() template = render_to_string(object.template, locals(), RequestContext(request)) if request.method == 'POST': object.sent_date = datetime.now() object.save() email = EmailMessage(subject = '%s - %s' % (object.title, site), body = template, from_email = settings.NEWSLETTER_FROM_EMAIL, bcc = [e.email for e in subscribers], headers = {'Reply-To': settings.NEWSLETTER_REPLYTO_EMAIL} ) email.content_subtype = "html" # Main content is now text/html email.send() self.message_user(request, _(u"Newsletter sent successfully")) return HttpResponseRedirect(reverse('admin:newsletters_newsletter_changelist')) opts = Newsletter._meta app_label = opts.app_label return render_to_response('admin/newsletters/send_mail.html', locals(), RequestContext(request))
def email_file(self, f: File, size: int, url: str): template_name = 'aristotle_mdr/email/download.html' context: Dict[str, Union[str, bool]] = { 'item_names': ', '.join([i.name for i in self.items]), 'download_url': url } # Send email with a link to the file and link to regenerate storage = self.get_storage() if hasattr(storage, 'querystring_expire'): expire_seconds = storage.querystring_expire context['expire_time'] = format_seconds(expire_seconds) # Build url to regenerate download query = QueryDict(mutable=True) query.setlist('items', self.item_ids) regenerate_url = '{host}{url}?{qstring}'.format( host=self.options['CURRENT_HOST'], url=reverse('aristotle:download_options', args=[self.download_type]), qstring=query.urlencode()) # Update context context.update({'attached': False, 'regenerate_url': regenerate_url}) email = EmailMessage( 'Aristotle Download', render_to_string(template_name, context), to=[self.user.email], ) email.content_subtype = 'html' # Sets the mime type of the body to text/html email.send(fail_silently=True)
def wyslij_email(request, pk): if request.is_ajax(): response_message = "success" wiadomosc = Wiadomosc.objects.get(id=pk) subject = 'Hotel Messiah' try: message = request.GET['message'] message_html = '<h3>' + _('Twoje pytanie') + ': </h3><p>' + wiadomosc.tresc + \ '</p><h3>' + _('Nasza odpowiedz') + ': </h3><p>' + request.GET['message'] + "</p>" from_email = '*****@*****.**' to_email = request.GET['email_address'] if subject and message and from_email: try: # send_mail(subject, message, from_email, [to_email]) msg = EmailMessage(subject, message_html, from_email, [to_email]) msg.content_subtype = "html" msg.send() except KeyError: response_message = "site_error" else: response_message = "empty_field" if response_message == "success": wiadomosc.wyslano_odpowiedz = True wiadomosc.odpowiedz = message wiadomosc.save() except KeyError: raise Http404 return HttpResponse(response_message) else: raise Http404
def send_mail_to_organization_creator(self, email_type): users = self.get_related_users().filter( groups__name__in=["NGO Admins", "Project Managers"]) from django.contrib.sites.models import Site current_site = Site.objects.get_current() current_language = get_language() activate(self.language) email_subject, email_template, sender = get_email_detail_by_type( email_type) email_content = loader.get_template('email/%s_%s.html' % ( email_template, ugettext("en"), )) for user in users: token = Token.objects.get_or_create(user=user)[0] c = Context({ 'username': user.first_name + ' ' + user.last_name, 'organization': self, 'site': current_site, 'token': token.key }) msg = EmailMessage(ugettext(email_subject), email_content.render(c), sender or settings.EMAIL_HOST_USER, [user.email]) msg.content_subtype = "html" msg.send() activate(current_language)
def wyslij_biuletyn(request): if request.is_ajax(): subscribers = Newsletter.objects.all() response_message = "success" from_email = '*****@*****.**' connection = mail.get_connection() connection.open() subject = 'Hotel Messiah Newsletter!' for subscriber in subscribers: try: message_html = request.GET['message']+"<a href='"+request.build_absolute_uri(reverse('hotel:newsletter_anuluj', args=[subscriber.news_kod]))+"'>"+"Anuluj newsletter"+"</a>" to_email = subscriber.news_email #to_email_bcc = Newsletter.objects.values_list('news_email', flat=True) if subject and message_html and from_email: try: msg = EmailMessage(subject, message_html, from_email, [to_email]) msg.content_subtype = "html" msg.send() except KeyError: response_message = "site_error" else: response_message = "empty_field" except KeyError: raise Http404 connection.close() return HttpResponse(response_message) else: raise Http404
def send_single_email(subject, message,to_email, from_email=DEFAULT_FROM_EMAIL,info_dict={},token=None, job=None, resume_id=None): to=list() to.append(to_email) details = MarketEmailSendDetail() details.send_time = datetime.now() details.from_email = from_email details.subject = subject details.to_email = to_email details.status = True details.info_dict = info_dict details.save() token = str(details.id) try: if token: message = message.replace("pinbot_token",token) msg = EmailMessage(subject=subject, body=message, from_email=from_email, to=to) msg.content_subtype = "html" # Main content is now text/html ret = msg.send() # 添加C端企业感兴趣 brick_company_card = JobUtils.send_company_card(job.user, job, resume_id, token) if brick_company_card: details.info_dict['card_job_id'] = brick_company_card.id details.save() return True,str(details.id) except Exception , IntegrityError: details.status = False details.error_info = str(IntegrityError) details.save() return False, str(IntegrityError)
def send_activation_mail(user): key = SecretKey.objects.get_or_create(user=user).secretkey context = {'username': user.username, 'security_key': key} html_content = render_to_string('massage.html', context) msg = EmailMessage('submit registration', html_content, '*****@*****.**', [user.email]) msg.content_subtype = "html" msg.send()
def remind_account_about_events_with_email(account, single_events): if account.reminder_email: featured_events = Event.featured_events_for_region( account.native_region)[0:4] similar_events = find_similar_events( Event.future_events.filter( id__in=single_events.values_list("event_id", flat=True))) subject = "Upcoming events from cityfusion" message = render_to_string( 'accounts/emails/reminder_email.html', { "featured_events": featured_events, "events": single_events, "similar_events": similar_events, "STATIC_URL": "/static/", "advertising_region": account.advertising_region, "site": "http://%s" % Site.objects.get_current().domain }) try: msg = EmailMessage(subject, message, "*****@*****.**", [account.reminder_email]) msg.content_subtype = 'html' msg.send() except: logger.error("Invalid email %s" % account.reminder_email) return message else: return ""
def inform_account_about_events_with_tag_with_email(account, events, tags_in_venues): featured_events = Event.featured_events_for_region(account.native_region)[:4] similar_events = find_similar_events(events) subject = "New Events in cityfusion" message = render_to_string( "accounts/emails/in_the_loop_email.html", { "featured_events": featured_events, "events": events, "similar_events": similar_events, "STATIC_URL": "/static/", "site": "http://%s" % Site.objects.get_current().domain, "tags_in_venues": tags_in_venues, "advertising_region": account.advertising_region, }, ) msg = EmailMessage(subject, message, "*****@*****.**", [account.in_the_loop_email]) msg.content_subtype = "html" msg.send() return message
def notify(self): base_url = "http://%s" % Site.objects.get_current().domain text = render_to_string("harvester/notification.html", dict(base_url=base_url, job=self)) message = EmailMessage(u"Harvesting job is complete", text, settings.DEFAULT_FROM_EMAIL, [self.email]) message.content_subtype = "html" message.send()
def remind_account_about_deleted_events_with_email(account, single_events): if account.reminder_email: featured_events = Event.featured_events_for_region(account.native_region)[:4] subject = 'Deleted events from cityfusion' message = render_to_string('accounts/emails/reminder_deleted_event_email.html', { "featured_events": featured_events, "events": single_events, "STATIC_URL": "/static/", "advertising_region": account.advertising_region, "site": "http://%s" % Site.objects.get_current().domain }) try: msg = EmailMessage(subject, message, "*****@*****.**", [account.reminder_email]) msg.content_subtype = 'html' msg.send() except: logger.error("Invalid email %s" % account.reminder_email) return message else: return ""
def contact_email_producto(request, form, herramienta, id_producto): emailF = form emails = [] #Informacion del usuario name = emailF.cleaned_data['nombre'] telephone = emailF.cleaned_data['telefono'] email = emailF.cleaned_data['correo'] emails.append('*****@*****.**') #Mensaje a enviar message = 'Correo de contacto del usuario: '+ str(name.encode("utf8")) + '.<br/> Enviado mientras veia la herramienta: <a href="www.alquiherramientas.com/productos/'+str(id_producto)+' target="new">'+str(herramienta)+'"</a>' message += '.<br> Con correo: ' + str(emailF.cleaned_data['correo'].encode("utf8")) +'<br>' message += 'Mensaje: '+ str(emailF.cleaned_data['mensaje'].encode("utf8")) + '<br>' message += 'Telefono de contacto: '+ str(telephone.encode("utf8")) email = EmailMessage() email.subject = '[Alquiherramientas] Contacto de producto' email.body = message email.from_email = '*****@*****.**' email.to = emails email.content_subtype = "html" enviado=email.send() return True
def send_template_mail(template_name, to, from_email=None, extra_context=None, request=None, subject_template=None, html=False, **kwargs): default_context = { 'site': Site.objects.get_current(), } if request: context = RequestContext(request, default_context) else: context = Context(default_context) if extra_context: context.update(extra_context) if not subject_template: subject_template = '%s_subject%s' % os.path.splitext(template_name) subject = get_template(subject_template) body = get_template(template_name) subject = (''.join(subject.render(context).splitlines())).strip() body = body.render(context) from_email = from_email or settings.DEFAULT_FROM_EMAIL connection = get_connection() message = EmailMessage(subject, body, from_email, to, connection=connection) if html: message.content_subtype = 'html' return message.send()
def audit_event_catch(instance=None, created=False, **kwargs): if instance.audited: return bad_phrases = phrases_query() name_search_result = re.findall(bad_phrases, instance.name, re.I) description_search_result = re.findall(bad_phrases, instance.description, re.I) if name_search_result or description_search_result: audit_event = AuditEvent( event_ptr_id=instance.pk ) audit_event.__dict__.update(instance.__dict__) audit_event.save() phrases = AuditPhrase.objects.filter( phrase__in=(name_search_result + description_search_result) ) for phrase in phrases: audit_event.phrases.add(phrase) current_site = Site.objects.get_current().domain subject = 'Bad phrases have been caught!' message = render_to_string('audit/bad_phrases_email.txt', { 'site': current_site, 'event': audit_event, 'phrases': phrases }) msg = EmailMessage(subject, message, DEFAULT_FROM_EMAIL, map(lambda x: x[1], settings.ADMINS)) msg.content_subtype = 'html'
def remind_account_about_deleted_events_with_email(account, single_events): if account.reminder_email: featured_events = Event.featured_events_for_region( account.native_region)[:4] subject = 'Deleted events from cityfusion' message = render_to_string( 'accounts/emails/reminder_deleted_event_email.html', { "featured_events": featured_events, "events": single_events, "STATIC_URL": "/static/", "advertising_region": account.advertising_region, "site": "http://%s" % Site.objects.get_current().domain }) try: msg = EmailMessage(subject, message, "*****@*****.**", [account.reminder_email]) msg.content_subtype = 'html' msg.send() except: logger.error("Invalid email %s" % account.reminder_email) return message else: return ""
def execute(self, context): """ :param context: Script Context :type context: E-Commerce.notify.script.Context """ recipient = self.get_value(context, "recipient") if not recipient: context.log(logging.INFO, "%s: Not sending mail, no recipient", self.identifier) return send_identifier = self.get_value(context, "send_identifier") if send_identifier and context.log_entry_queryset.filter(identifier=send_identifier).exists(): context.log( logging.INFO, "%s: Not sending mail, have sent it already (%r)", self.identifier, send_identifier ) return languages = [language for language in [ self.get_value(context, "language"), self.get_value(context, "fallback_language"), ] if language and language in dict(settings.LANGUAGES).keys()] if not languages: languages = [settings.PARLER_DEFAULT_LANGUAGE_CODE] strings = self.get_template_values(context, languages) subject = strings.get("subject") body = strings.get("body") body_template = strings.get("body_template") if body_template and "%html_body%" in body_template: body = body_template.replace("%html_body%", body) content_type = strings.get("content_type") if not (subject and body): context.log( logging.INFO, "%s: Not sending mail to %s, either subject or body empty", self.identifier, recipient ) return reply_to = self.get_value(context, "reply_to_address") reply_to = [reply_to] if reply_to else None # Push email to a list, unless it is None from_email = self.get_value(context, "from_email") or None subject = " ".join(subject.splitlines()) # Email headers may not contain newlines message = EmailMessage(subject=subject, body=body, to=[recipient], reply_to=reply_to, from_email=from_email) message.content_subtype = content_type message.send() context.log(logging.INFO, "%s: Mail sent to %s :)", self.identifier, recipient) if send_identifier: context.add_log_entry_on_log_target("Email sent to %s: %s" % (recipient, subject), send_identifier)
def send_activation_mail(user): key = SecretKey.objects.get_or_create(user=user).secretkey context = {'username': user.username, 'security_key': key} html_content = render_to_string('massage.html', context) msg = EmailMessage('submit registration', html_content, '*****@*****.**', [user.email]) msg.content_subtype = "html" msg.send()
def personal_plan(email, first_name, last_name): data = {'first_name': first_name, 'last_name': last_name} template = loader.get_template('planpersonal.html') html = template.render(data) subject_user, from_email = 'Midoc Virtual - Pago Realizado', '*****@*****.**' message_user = EmailMessage(subject_user, html, from_email, [email]) message_user.content_subtype = "html" message_user.send(fail_silently=True)
def recovery(email, code): data = {"email": email, "code": code} template = loader.get_template('recuperar.html') html = template.render(data) subject_user, from_email = 'Recuperacion de Acceso', '*****@*****.**' message_user = EmailMessage(subject_user, html, from_email, [email]) message_user.content_subtype = "html" message_user.send(fail_silently=True)
def send_note_to_release_device(to_email, cc_mail, context): # print(to_email) subject = 'Request For Releasing A Device' sender_note_html = render_to_string('send_note_mail.html', context) msg = EmailMessage(subject=subject, body=sender_note_html, from_email=EMAIL_HOST_USER, to=[to_email],cc=[cc_mail]) # msg = EmailMessage(subject=subject, body=sender_note_html, from_email=EMAIL_HOST_USER, to=[to_email]) msg.content_subtype = "html" # Main content is now text/html return msg.send()
def welcome(email, name): data = {"name": name} template = loader.get_template('bienvenido.html') html = template.render(data) subject_user, from_email = 'Midoc Virtual - Bienvenido', '*****@*****.**' message_user = EmailMessage(subject_user, html, from_email, [email]) message_user.content_subtype = "html" message_user.send(fail_silently=True)
def admin_rounds(request): rounds = Round.objects.order_by('id') message = '' set_active = request.GET.get('set_active', '0') try: set_active_id = int(set_active) except ValueError: # Try float. set_active_id = 0 set_inactive = request.GET.get('set_inactive', '0') try: set_inactive_id = int(set_inactive) except ValueError: # Try float. set_inactive_id = 0 if set_active_id != 0: should_be_active_round = get_object_or_404(Round, pk=int(set_active_id)) should_be_active_round.active = True should_be_active_round.save() message = _('Round "%s" set as active') % should_be_active_round.name messages.add_message(request, messages.INFO, message) if settings.SEND_MAIL: all_players = Player.objects.\ exclude(user__email='').filter(user__is_active=True).filter(send_mail_new_round=True) start_time = Match.objects.\ filter(round=should_be_active_round).aggregate(Min('start_time'))['start_time__min'] logger.info('Sending mail that round %s is active to %d players', should_be_active_round.name, len(all_players)) for player in all_players: with translation.override(player.language): subject = _('[sharkz.bet] New round "%s" available' ) % should_be_active_round.name template = loader.get_template('mail/round_active.html') message_text = template.render({ 'round': should_be_active_round, 'start_time': start_time }) msg = EmailMessage(subject, message_text, '*****@*****.**', to=[ player.user.email, ]) msg.content_subtype = 'html' msg.send(fail_silently=False) elif set_inactive_id != 0: should_be_inactive_round = get_object_or_404(Round, pk=int(set_inactive_id)) should_be_inactive_round.active = False should_be_inactive_round.save() message = _( 'Round "%s" set as inactive') % should_be_inactive_round.name messages.add_message(request, messages.INFO, message) return render(request, 'admin_rounds.html', {'rounds': rounds})