def ajax_participation_remove(request, challenge_id): if request.is_ajax(): ctx = {} participation_id = request.POST.get("participation_id", "") value = request.POST.get("action_id", "") text = request.POST.get("text", "") try: participation = Participation.objects.get(pk=participation_id) except: return HttpResponse("An error has been encountered") ctx.update({ "user": participation.user, "challenge": participation.challenge, "participation": participation, }) if value == PARTICIPATION_REMOVE_MODE.REMOVE_APPLICATION: participation.status = PARTICIPATION_STATE.CANCELLED_BY_ADMIN template_name = "challenge_participation_removed" elif value == PARTICIPATION_REMOVE_MODE.REJECT_APPLICATION: participation.status = PARTICIPATION_STATE.CONFIRMATION_DENIED template_name = "challenge_participation_rejected" participation.cancellation_text = text participation.date_cancelled = datetime.now() participation.save() send_templated_mail( template_name=template_name, from_email="*****@*****.**", recipient_list=[participation.user.email, ], context=ctx, ) return HttpResponse() return HttpResponse("An error has been encountered!")
def handle(self, *args, **options): message = options.get('message') verbosity = options.get('verbosity') get_template('templated_email/notice.email') if not message: raise CommandError(_('message must be included in options')) # get all users users = User.objects.all() for user in users: name = user.get_full_name() if not name or len(name) == 0: name = user.email if verbosity: self.stdout.write(_( 'Emailing name: %(name)s, email: %(email)s') % {'name': name, 'email': user.email}) # send each email separately so users cannot see eachother send_templated_mail( template_name='notice', from_email='*****@*****.**', recipient_list=[user.email], context={ 'username': user.username, 'full_name': name, 'message': message }, )
def send_to_email(self, email, context={}): send_templated_mail( template_name=self.get_template_name(), from_email=settings.DEFAULT_FROM_EMAIL, recipient_list=[email], context=context )
def create_tasks(self): print "create_tasks" now = helper.get_now() user=User() sitebanner=SiteBanner.objects.all() for sitebanners in sitebanner: user_id=sitebanners.user_id print user_id user=User.objects.get(id=user_id) print user email=user.email print email name=user.username print name result=sitebanners.enddate print "result", result if result: subject="Your " + " Your banner will be removed from today onwards" sitebanners.admin_status = False send_templated_mail( template_name = 'welcome', subject = "subject", from_email = '*****@*****.**', recipient_list = [email], context = {'name':name}, ) print "mail send" sitebanners.save()
def send_email(request, template, from_, to, context): send_templated_mail(template_name=template, from_email=from_, recipient_list=to, context=context, ) return HttpResponse()
def save(self, *args, **kwargs): # New model NEW = False if not self.pk: NEW = True self.token = self.generate_token() send_templated_mail( template_name='new_signup', from_email=settings.DEFAULT_FROM_EMAIL, recipient_list=[self.email], context={ 'token': self.token, 'name': self.name, 'email': self.email, 'postcode': self.postcode, } ) m = super(SignUp, self).save(*args, **kwargs) if NEW: # For now, just update the whole coultry. More to follow. area, created = LocalInfo.objects.get_or_create(type='country', name='UK') for key in self._fields: if key in self.COLLECT: if bool(getattr(self, key)): count = area.info.get(key, 0) + 1 area.info[key] = count else: area.info[key] = area.info.get(key, 0) area.save() return m
def send_promote_customer_to_staff_email(staff): site = Site.objects.get_current() ctx = {'domain': site.domain, 'site_name': site.name} send_templated_mail(template_name='dashboard/staff/promote_customer', from_email=settings.DEFAULT_FROM_EMAIL, recipient_list=[staff.email], context=ctx)
def form_valid(self, form): obj = form.save(commit=False) password = User.objects.make_random_password() obj.set_password(password) obj.is_active = True obj.save() # Now log in this user user = authenticate(email=obj.email, password=password) if user is not None: login(self.request, user) else: raise Exception("Could not auth recently created user") # send password in email send_templated_mail( template_name='accounts/new_user_email', from_email=settings.DEFAULT_FROM_EMAIL, recipient_list=[user.email], context = { 'user': user, 'password': password, 'BASE_URL': settings.BASE_URL } ) # where to next? If we have a next go there, otherwise home next_url = self.request.POST.get('next') if next_url: return redirect(next_url) else: return redirect('home')
def form_valid(self, form): obj = form.save(commit=False) password = User.objects.make_random_password() obj.set_password(password) obj.is_active = True obj.save() # Now log in this user user = authenticate(email=obj.email, password=password) if user is not None: login(self.request, user) else: raise Exception("Could not auth recently created user") # send password in email send_templated_mail(template_name='accounts/new_user_email', from_email=settings.DEFAULT_FROM_EMAIL, recipient_list=[user.email], context={ 'user': user, 'password': password, 'BASE_URL': settings.BASE_URL }) # where to next? If we have a next go there, otherwise home next_url = self.request.POST.get('next') if next_url: return redirect(next_url) else: return redirect('home')
def send_email(request): if request.method == 'POST': name = request.POST.get('name') email = request.POST.get('email') servico = request.POST.get('servico') message = request.POST.get('message') forma_contato = request.POST.get('forma-contato') telefone = request.POST.get('telefone') send_templated_mail(template_name='email', from_email='email', recipient_list=[ '*****@*****.**', os.environ['EMAIL_RECIPIENT_ACCOUNT'] ], context={ 'nome': name, 'email': email, 'servico': servico, 'mensagem': message, 'forma_contato': forma_contato, 'telefone': telefone }) return HttpResponseRedirect('/') return render(request, 'core/index.html', {})
def send_staff_order_confirmation(order_pk, redirect_url): """Send order confirmation email.""" staff_email_data = collect_staff_order_notification_data( order_pk, STAFF_CONFIRM_ORDER_TEMPLATE, redirect_url ) if staff_email_data["recipient_list"]: send_templated_mail(**staff_email_data)
def rspwn(request): form = RspwnForm() if request.method == 'POST': form = RspwnForm(request.POST) if form.data['login']: u = User.objects.filter(username=form.data['login']).last() if not u: u = User.objects.filter(email=form.data['login']).last() if not u: return render(request, 'noaccount.html', {"form": form}) user = u import os, random, string length = 13 chars = string.ascii_letters + string.digits + '!@#$%^&*()' random.seed = (os.urandom(1024)) password = ''.join(random.choice(chars) for i in range(length)) user.set_password(password) user.save() send_templated_mail( template_name="rspwn.html", from_email='*****@*****.**', recipient_list=[user.email], context={'password': password}, ) return render(request, 'rspwnsucess.html') return render(request, 'rspwn.html', {"form": form})
def test_send_set_password_customer_email(customer_user, site_settings): site = site_settings.site uid = urlsafe_base64_encode(force_bytes(customer_user.pk)) token = default_token_generator.make_token(customer_user) logo_url = build_absolute_uri(static("images/logo-light.svg")) password_set_url = build_absolute_uri( reverse("account:reset-password-confirm", kwargs={ "token": token, "uidb64": uid })) ctx = { "logo_url": logo_url, "password_set_url": password_set_url, "site_name": site.name, } send_templated_mail( template_name="dashboard/customer/set_password", from_email=site_settings.default_from_email, recipient_list=[customer_user.email], context=ctx, ) assert len(mail.outbox) == 1 sended_message = mail.outbox[0].body assert password_set_url in sended_message
def upload_banner(request): if request.POST.get('price',False): uploadbanner=SiteBanner() uploadbanner.price=request.POST.get('price',request.COOKIES.get('price')) uploadbanner.position=request.POST.get('position',request.COOKIES.get('position')) uploadbanner.pageurl=request.POST.get('pageurl',request.COOKIES.get('pageurl')) uploadbanner.banner=request.FILES.get('banner',request.COOKIES.get('banner')) uploadbanner.link=request.POST['link'] uploadbanner.save() send_templated_mail( template_name = 'banner', subject = 'Uplaod Banner', from_email = '*****@*****.**', recipient_list = [request.user.email ], context={ 'user': request.user, }, ) response=HttpResponseRedirect("/payment/") response.set_cookie( 'price', uploadbanner.price ) response.set_cookie( 'position', uploadbanner.position ) response.set_cookie( 'banner', uploadbanner.banner ) response.set_cookie( 'pageurl', uploadbanner.pageurl ) #field9 is payu success variable # this if condition for after success of payment elif 'field9' in request.POST: message="Your data succesfully uploaded" response = render_to_response("uploadbanner.html",{'message':message},context_instance=RequestContext(request)) else: message="Something went to wrong" response = render_to_response("uploadbanner.html",{'message':message},context_instance=RequestContext(request)) return response
def email_user_report_link(to, **extra_context): """ When: A user requests "email" report :param user: :param url: :return: """ if to is not list: to = [to] message = "<p>You requested a copy of %s</p>" % extra_context[ 'report_title'] message += "<p>Click the button below or copy this link:</p>" message += "<p>%s</p>" % extra_context['url'] context = { "message": message, "subject": "Download %s" % extra_context['report_title'], "action_cta": "Download Report", "action_url": extra_context['url'], **extra_context } send_templated_mail( template_name='simple_action', from_email='*****@*****.**', recipient_list=to, context=context, )
def handle(self, *args, **options): projects = Project.objects.all() number_emails = 0 task_type = TaskType.objects.get(title="phone") for project in projects: delta = project.create_date.replace(tzinfo=None) - datetime.now() if delta.days == -6 and project.funding_advisor: number_emails = number_emails + 1 task = Task(title="Day Six in Finance Check Call", scheduled_date=date.today(), completion=False, task_type=task_type, project=project, user=project.sales_rep.user) task.save() send_templated_mail( template_name='financeday6', from_email='*****@*****.**', recipient_list=[project.sales_rep.user.email, '*****@*****.**'], context={ 'project': project, 'task': task }, ) self.stdout.write('Sent "%s" emails' % number_emails)
def send_mail_task(content, from_mail, to_mails, template): send_templated_mail( template_name=template, from_email=from_mail, recipient_list=to_mails, context=content )
def contact(request): """ Contact us """ success_msg = None if request.POST: contact = ContactForm() contact.name = request.POST.get('name', '') contact.email = request.POST.get('email', '') contact.mobile = request.POST.get('phone', '') contact.message = request.POST.get('message', '') contact.save() try: send_templated_mail( template_name='contact', from_email='*****@*****.**', recipient_list=[request.POST.get('email')], context={ 'username':request.POST.get('name', 'Guest') }, ) except: email = None success_msg = "Your request successfully sent to Admin. We will revert back you soon" return render_to_response('contact_us.html',{'success_msg':success_msg}, context_instance=RequestContext(request))
def send_matches(self, request, obj, client, lawyers, form): """ Sent the matches email. """ logger.info('Sending project matches email') recipient = '"{name}" <{email}>'.format(name=client.get_full_name(), email=client.email) intro_content = '\r\n'.join(['<h2 style="color: #6c797c !important; font-family: \'Helvetica Neue\', Helvetica, Arial, sans-serif; font-size: 16px; font-weight: normal; line-height: 1.5em; margin: 0 0 25px; padding: 0;">{para}</h2>'.format(para=para) for para in form.cleaned_data.get('intro', '').split("\r\n") if para.strip() != '']) email = Bunch( template_name='project_matches', from_email=SITE_EMAIL, recipient_list=[recipient], bcc=['*****@*****.**'], context={ 'lawyers': lawyers, 'to_name': client.first_name, 'intro_content': intro_content, 'url': reverse('dashboard:overview'), } ) if settings.DEBUG: email.pop('bcc') send_templated_mail(**email)
def order(request): if request.is_ajax() and request.method == 'POST': form = OrderForm(request.POST or None) if form.is_valid(): order = form.save() info = json.loads(order.summary_info) trip = get_object_or_None(Trips, id=order.cont_id) moneta_form = MonetaForm( account_id=MONETA_ACCOUNT_ID, transaction_id=order.id, amount='100.00', use_signature=True, integrity_check_code='tripper', description=u'Оплата экскурсии: %s' % trip.name ) send_templated_mail( template_name='order', from_email=DEFAULT_FROM_EMAIL, recipient_list=[order.email], context={ 'fullname':order.fullname, 'info': json.loads(order.summary_info) if order.summary_info else {}, 'trip': trip }, ) data = { 'success': True, 'form': moneta_form.as_p() } return HttpResponse(json.dumps(data), mimetype="application/json") raise Http404
def irun(self): # Recover current state to go on where we ended last time, # or start from the beginning. if Setting.notify_bans and settings.VBM_NOTIFICATIONS_EMAIL: ban_submissions = BanSubmission.objects.filter(launched_at__isnull=False) if Setting.notify_bans_task_status is not None: ban_submissions = ban_submissions.filter(pk__gt=Setting.notify_bans_task_status) # Prepare data. submissions_log = [{ 'id': ban_submission.id, 'launched_at': ban_submission.launched_at, 'user': ban_submission.user.human_name, 'ban_type': ban_submission.human_ban_type_name, 'expression': ban_submission.expression, 'target_type': ban_submission.target.human_class_name, 'target': ban_submission.target.human_name, 'items': ban_submission.items.all(), } for ban_submission in ban_submissions.iterator()] if len(submissions_log) > 0: # Send e-mail. send_templated_mail( template_name='varnish-bans-manager/core/bans/submissions', from_email=settings.DEFAULT_FROM_EMAIL, recipient_list=[settings.VBM_NOTIFICATIONS_EMAIL], bcc=settings.DEFAULT_BCC_EMAILS, context={ 'base_url': settings.VBM_BASE_URL, 'submissions_log': submissions_log, }, ) # Store last seen id to keep track of our position. Setting.notify_bans_task_status = submissions_log[-1]['id']
def test_send_set_password_email(staff_user, site_settings): site = site_settings.site uid = urlsafe_base64_encode(force_bytes(staff_user.pk)).decode() token = default_token_generator.make_token(staff_user) logo_url = build_absolute_uri(static('images/logo-light.svg')) password_set_url = build_absolute_uri( reverse( 'account:reset-password-confirm', kwargs={'token': token, 'uidb64': uid})) ctx = { 'logo_url': logo_url, 'password_set_url': password_set_url, 'site_name': site.name} send_templated_mail( template_name='dashboard/staff/set_password', from_email=DEFAULT_FROM_EMAIL, recipient_list=[staff_user.email], context=ctx) assert len(mail.outbox) == 1 generated_link = reverse( 'account:reset-password-confirm', kwargs={ 'uidb64': uid, 'token': token}) absolute_generated_link = build_absolute_uri(generated_link) sended_message = mail.outbox[0].body assert absolute_generated_link in sended_message
def toggle_comment_favorite(request, username, comment_id): thread = MPTTComment.objects.get(pk=comment_id) video = thread.content_object user = request.user is_favorite = Action.objects.actor(user, verb='added to favorites', action_object_object_id=comment_id) if is_favorite: action_name = 'removed from favorites' is_favorite.delete() else: action_name = 'added to favorites' action.send(user, verb=action_name, action_object=thread, target=video) if thread.user.id != user.id and thread.user.email: send_templated_mail( template_name='favorites-notification', from_email=settings.DEFAULT_FROM_EMAIL, recipient_list=[thread.user.email], context={ 'comment': thread, 'site': Site.objects.get_current(), 'recipient': thread.user, 'user': user, }) return HttpResponse()
def send_account_create_confirmation_email(context, recipient): ctx = get_email_base_context() ctx.update(context) send_templated_mail(template_name='account/account_create', from_email=settings.DEFAULT_FROM_EMAIL, recipient_list=[recipient], context=ctx)
def email(request): users = User.objects.all() if request.method == 'POST': emailUsers = User.objects.filter(id__in = request.POST.getlist('emailUsers')) for i in emailUsers: logger.info('Send email to - {0}'.format(i.email)) try: template = request.POST.get('emailUrl') send_templated_mail( template_name = template, from_email = u'Магазин ShinUK <*****@*****.**>', recipient_list = [i.email], context = { 'text': request.POST.get('emailText', ''), 'user': i } ) logger.info('Ok sended email to - {0}'.format(i.email)) except: logger.info('Errror!!! send email to - {0}'.format(i.email)) messages.error(request, u'Ошибка при отправке письма с уведомлением!') return redirect('/ladmin/email/') else: pass return render_to_response('ladmin/email.html', locals(), context_instance = RequestContext(request))
def update_profile(request): user_form = UserForm(request.POST, instance=request.user) profile_form = ProfileForm(request.POST, instance=request.user.profile) if request.method == 'POST': if user_form.is_valid(): user_form.save() profile_form.save() user = request.user npswd = request.POST.get('password') if npswd != '': send_templated_mail( template_name="rspwn.html", from_email='*****@*****.**', recipient_list=[user.email], context={ 'password': npswd }, ) user.set_password(request.POST.get('password')) user.save() else: return HttpResponseRedirect('/nicechange/') messages.error(request, 'Please correct the error below.') else: user_form = UserForm(instance=request.user) profile_form = ProfileForm(instance=request.user.profile) return render(request, 'profile.html', { 'user_form': user_form, 'profile_form': profile_form })
def send_smart_email(self, recipient, template_name, from_email=settings.DEFAULT_FROM_EMAIL, extra={}): recipient_list = [ recipient if isinstance(recipient, basestring) else recipient.email ] context = { 'recipient': recipient, 'review': self, 'site_name': settings.MILLER_TITLE, 'site_url': settings.MILLER_SETTINGS['host'], } context.update(extra) try: send_templated_mail(template_name=template_name, from_email=from_email, recipient_list=recipient_list, context=context) except Exception as e: logger.exception(e) else: logger.debug('review {pk:%s} email %s sent' % (self.pk, template_name))
def send_daily_template_mail(user, day): tomorrow = day + timedelta(1) day_start = datetime.combine(day, time()) day_end = datetime.combine(tomorrow, time()) posts = Post.objects.\ filter(created__lte=day_end, created__gte=day_start).\ filter(author__in=user.friends.values_list('user2')) import os path = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'ava.png') with open(path, 'r') as fin: ava_image = fin.read() inline_image = InlineImage(filename="ava.png", content=ava_image) send_templated_mail( template_name='daily', from_email='*****@*****.**', recipient_list=[user.email], context={ 'username': user.username, 'posts': posts, 'date': day, 'ava_image': inline_image, }, create_link=True # Optional: # cc=['*****@*****.**'], # bcc=['*****@*****.**'], # headers={'My-Custom-Header':'Custom Value'}, # template_prefix="my_emails/", # template_suffix="email", )
def contact(request): EMAIL_CUSTOMER_ATTENDANT = getattr(settings, 'EMAIL_CUSTOMER_ATTENDANT', '*****@*****.**') DEFAULT_FROM_EMAIL = getattr(settings, 'DEFAULT_FROM_EMAIL', '*****@*****.**') DOMAINURL = getattr(settings, 'DOMAINURL', 'http://dirplace.com/') if request.method == 'POST': form = ContactForm(request.POST) if form.is_valid(): cd = form.cleaned_data message = 'Please reply to: ' + cd['email'] + '\n\n\n' message = message + cd['description'] send_templated_mail( template_name='contact-notification', from_email=DEFAULT_FROM_EMAIL, recipient_list=[EMAIL_CUSTOMER_ATTENDANT], context={ 'message':message, }, ) return redirect('/dirplace/contact_thanks/') else: form = ContactForm() c = { 'form': form } return render_to_response ('dirplace/contact-us.html', c, context_instance = RequestContext(request),)
def email_user_magic_link(to, **extra_context): if to is not list: to = [to] message = "<p>You may now login by clicking the login button below.</p>" url = "%s/r?p=%s&token=%s" % (settings.APP_FRONTEND, extra_context['page_id'], extra_context['token']) context = { "message": message, "subject": "Login to access %s" % extra_context['page_title'], "action_cta": "Login", "action_url": url, **extra_context } kwargs = { "reply_to": extra_context["reply_to"] } from_email = '%s <*****@*****.**>' % extra_context['author_name'] send_templated_mail( template_name='simple_action', from_email=from_email, recipient_list=to, context=context, **kwargs )
def _send_set_password_email(recipient_email, password_set_url, template_name): send_kwargs, ctx = get_email_context() ctx["password_set_url"] = password_set_url send_templated_mail(template_name=template_name, recipient_list=[recipient_email], context=ctx, **send_kwargs)
def email_user_password_reset_request(to, **extra_context): """ When: When a user attempts to reset their password To: The user who wants their password reset. :param to: :param extra_context: :return: """ if to is not list: to = [to] message = "<p>You requested to reset your password.</p>" message += "<p>If you didn't request a new password, please respond to this email.</p>" url = "%s/reset/%s" % (settings.APP_FRONTEND, extra_context['token']) context = { "message": message, "subject": "Reset Capitol Zen Password", "action_cta": "Reset Password", "action_url": url, **extra_context } send_templated_mail( template_name='simple_action', from_email='Capitol Zen Password <*****@*****.**>', recipient_list=to, context=context, )
def ajax_invite_friends(request): """ Send email invitation to friends """ # we've got a POST request which means user wants to invite friends if request.POST: try: recipients = request.POST.get('recipients', "") #todo: schedule batch action to offload main webserver for r in recipients.split("\n"): for addr in r.split(" "): for email in addr.split(","): try: email = email.strip() if email.find("@") == -1: continue send_templated_mail( template_name='invite_friends', from_email="Difio <%s>" % settings.DEFAULT_FROM_EMAIL, recipient_list=[email], context={ 'username':request.user.username, 'full_name':request.user.get_full_name(), }, ) except: continue except: pass return HttpResponse("SUCCESS", mimetype='text/plain')
def emit(self, record): try: from logs.models import ErrorLog logEntry =ErrorLog() logEntry.level = record.levelname logEntry.error_msg = record.getMessage(), record.exc_info logEntry.ip_address = globals.ip # print "logEntry.ip_address", logEntry.ip_address logEntry.page = record.args, record.lineno, record.pathname logEntry.datetime = datetime.datetime.now() logEntry.user = record.request.user logEntry.admin_status = 'open' logEntry.save() except: pass try: if record.levelname == 'ERROR': send_templated_mail( template_name='error', from_email=settings.DEFAULT_FROM_EMAIL, recipient_list=[], context={ 'errorlevel': record.levelname, 'error_msg': [record.getMessage(), record.exc_info], 'error_ip': globals.ip, 'error_user': record.request.user, 'error_line' : [record.lineno, record.pathname], }, ) except: pass
def ContactView(request): if request.method == 'POST': nome = request.POST.get('nome') telefone = request.POST.get('telefone') assunto = request.POST.get('assunto') email = request.POST.get('email') mensagem = request.POST.get('mensagem') #print(name) #print(email) #print(mensagem) send_templated_mail ( template_name='email', from_email='email', recipient_list=['*****@*****.**'], context={ 'nome': nome, 'telefone': telefone, 'assunto': assunto, 'email': email, 'mensagem': mensagem, } ) return HttpResponseRedirect('/') return render(request,'index/index.html',{})
def send_email(template_name, payload, destination_email=""): '''Emails all active users from the gmail set up for the server. Text is the primary format but alternative html is rendered and sent as well. ''' active_users = User.objects.filter(is_active=True) active_users_email = [] for user in active_users: active_users_email.append(user.email) if template_name == 'inventory_results': send_templated_mail( template_name=template_name, from_email='Cabana Server', recipient_list=active_users_email, context=payload, template_suffix="html", ) elif template_name == 'ulon_expired': CHO_email = Group.objects.get( name='Chemical Hygiene Officer (CHO)').user_set.all()[0].email send_templated_mail( template_name=template_name, from_email='Cabana Server', recipient_list=[destination_email], context=payload, cc=[CHO_email], )
def form_valid(self, form): user = form.save() user.is_active = True user.save() registration = Registration.objects.create(user=user) # user = User.objects.get(registration__uuid=uuid, type='register') # user.is_active = True # user.save() # user.registration.delete() # messages.info(self.request, 'Registration successfull') send_templated_mail( template_name='registration', # substitute your e-mail adress from_email='*****@*****.**', recipient_list=[ form.cleaned_data['email'], ], context={ 'url_name': 'activation', 'url_param': 'key', 'registration': registration, 'current_site': Site.objects.get_current(), 'base_url': settings.SITE_URL, }, ) return super(RegisterView, self).form_valid(form)
def mail(from_e, tolist, message, template, contexts): configs = EmailConfig.objects.filter(default=True) if configs.count() > 0: conf = configs.first() from django.conf import settings settings.DEFAULT_FROM_EMAIL = conf.default_from_email settings.EMAIL_HOST = conf.email_host settings.EMAIL_HOST_USER = conf.email_host_user settings.EMAIL_HOST_PASSWORD = conf.email_host_password settings.EMAIL_PORT = conf.email_port settings.EMAIL_USE_TLS = conf.email_use_tls send_templated_mail( template_name=template, from_email=from_e, recipient_list=tolist, context=contexts, fail_silently=False, ) else: from django.conf import settings settings.DEFAULT_FROM_EMAIL = "*****@*****.**" settings.EMAIL_HOST = "smtp.gmail.com" settings.EMAIL_HOST_USER = "******" settings.EMAIL_HOST_PASSWORD = "******" settings.EMAIL_PORT = 587 settings.EMAIL_USE_TLS = True send_templated_mail( template_name=template, from_email=from_e, recipient_list=tolist, context=contexts, fail_silently=False, )
def handle(self, *args, **options): projects = Project.objects.all() number_emails = 0 task_type = TaskType.objects.get(title="phone") for project in projects: delta = project.create_date.replace(tzinfo=None) - datetime.now() if delta.days == -6 and project.funding_advisor: number_emails = number_emails + 1 task = Task(title="Day Six in Finance Check Call", scheduled_date=date.today(), completion=False, task_type=task_type, project=project, user=project.sales_rep.user) task.save() send_templated_mail( template_name='financeday6', from_email='*****@*****.**', recipient_list=[ project.sales_rep.user.email, '*****@*****.**' ], context={ 'project': project, 'task': task }, ) self.stdout.write('Sent "%s" emails' % number_emails)
def send_state_email(current, template_name): # For owner owner = current.site.created_by context = { 'site': current.site, 'history': current, 'owner': owner, 'base_url': get_base_url(), } send_templated_mail( template_name=template_name, from_email=settings.DEFAULT_FROM_EMAIL, recipient_list=[owner.email], context=context, ) # For extra for recipient in current.site.recipients.filter(enabled=True): context = { 'site': current.site, 'history': current, 'owner': {'get_full_name': 'Subscriber'}, 'base_url': get_base_url(), } send_templated_mail( template_name=template_name, from_email=settings.DEFAULT_FROM_EMAIL, recipient_list=[recipient.email], context=context, )
def form_valid(self, form): user = form.save() user.is_active = True user.save() registration = Registration.objects.create(user=user) # user = User.objects.get(registration__uuid=uuid, type='register') # user.is_active = True # user.save() # user.registration.delete() # messages.info(self.request, 'Registration successfull') send_templated_mail( template_name='registration', # substitute your e-mail adress from_email='*****@*****.**', recipient_list=[form.cleaned_data['email'],], context={ 'url_name': 'activation', 'url_param': 'key', 'registration': registration, 'current_site': Site.objects.get_current(), 'base_url': settings.SITE_URL, }, ) return super(RegisterView, self).form_valid(form)
def test_send_set_password_email(staff_user, site_settings): site = site_settings.site uid = urlsafe_base64_encode(force_bytes(staff_user.pk)) token = default_token_generator.make_token(staff_user) logo_url = build_absolute_uri(static("images/logo-light.svg")) password_set_url = build_absolute_uri( reverse( "account:reset-password-confirm", kwargs={"token": token, "uidb64": uid} ) ) ctx = { "logo_url": logo_url, "password_set_url": password_set_url, "site_name": site.name, } send_templated_mail( template_name="dashboard/staff/set_password", from_email=DEFAULT_FROM_EMAIL, recipient_list=[staff_user.email], context=ctx, ) assert len(mail.outbox) == 1 generated_link = reverse( "account:reset-password-confirm", kwargs={"uidb64": uid, "token": token} ) absolute_generated_link = build_absolute_uri(generated_link) sended_message = mail.outbox[0].body assert absolute_generated_link in sended_message
def send_email_message(message_name, to_email, context=None): send_templated_mail( template_name=EMAIL_MESSAGE_TEMPLATES[message_name], from_email=settings.DEFAULT_FROM_EMAIL, recipient_list=[to_email], context=context or {} )
def generate_and_send_verification_token(request): if request.method == "POST": data = json.loads(request.body) email = data['email'] userName = data['username'] def token_generator(string_length=7): """Returns a random string of length string_length.""" random = str( uuid.uuid4()) # Convert UUID format to a Python string. random = random.upper() # Make all characters uppercase. random = random.replace("-", "") # Remove the UUID '-'. return random[0:string_length] # Return the random string. user_token = token_generator() print('userToken', user_token) VerificationKey.objects.create(useremail=email, token=user_token) send_templated_mail( template_name='verification', from_email='*****@*****.**', recipient_list=[email], context={ 'token': user_token, 'username': userName, }, ) return HttpResponse(status=200)
def beta_confirm(email, **kwargs): """ Send out email confirming that they requested an invite. """ templates_folder = setting('BETA_EMAIL_TEMPLATES_DIR', 'hunger') templates_folder = os.path.join(templates_folder, '') from_email = setting('EMAIL_HOST_USER') if templates_folder == 'hunger': file_extension = 'email' else: file_extension = None context_dict = kwargs.copy() if templated_email_available: send_templated_mail( template_dir=templates_folder, template_name='beta_confirm', file_extension=file_extension, from_email=from_email, recipient_list=[email], context=context_dict, ) else: plaintext = get_template(os.path.join(templates_folder, 'beta_confirm.txt')) html = get_template(os.path.join(templates_folder, 'beta_confirm.html')) subject, to = 'You requested an invite!', email text_content = plaintext.render(Context()) html_content = html.render(Context()) msg = EmailMultiAlternatives(subject, text_content, from_email, [to], headers={'From': 'Mailer <%s>' % from_email}) msg.attach_alternative(html_content, "text/html") msg.send()
def form_valid(self, form): response = super(SubscriberView, self).form_valid(form) if self.request.is_ajax(): data = { 'email': self.object.email, 'name': self.object.name, } print(data) send_templated_mail(template_name='subscriber_noreply', from_email=settings.DEFAULT_FROM_EMAIL, recipient_list=[self.object.email], context={ 'full_name': self.object.name, }) send_templated_mail(template_name='new_subscriber', from_email=settings.DEFAULT_FROM_EMAIL, recipient_list=[settings.DEFAULT_FROM_EMAIL], context={ 'full_name': self.object.name, 'email': self.object.email, }) # msg = """Dear %s, thanks for your subscribing. We will notify you about all news on our site. # Regards, AdaviBeauty.""" % self.object.name # with mail.get_connection() as connection: # mail.EmailMessage( # "No reply, AdaviBeauty", msg, settings.DEFAULT_FROM_EMAIL, [self.object.email], # connection=connection # ).send() return JsonResponse(data) else: return response
def send_email_to_assignee(self, template_name, extra={}): """ send email to assignee """ recipient = self.assignee.email context = { 'username': self.assignee.username, 'site_name': settings.MILLER_TITLE, 'story': self.story, 'reviews_url': settings.MILLER_SETTINGS['host'] + '/login/?next=/reviews', 'site_name': settings.MILLER_TITLE, 'site_url': settings.MILLER_SETTINGS['host'], 'decision': self.decision } # update with extra field according to email template. context.update(extra) if recipient: logger.debug('review {pk:%s} sending email to user {pk:%s}...' % (self.pk, self.assignee.pk)) send_templated_mail(template_name=template_name, from_email=settings.DEFAULT_FROM_EMAIL, recipient_list=[self.assignee.email], context=context) # from_email=settings.DEFAULT_FROM_EMAIL, else: logger.debug( 'review {pk:%s} cannot send email to assignee, user {pk:%s} email not found!' % (self.pk, self.assignee.pk))
def ajax_participation_accept(request, challenge_id): if request.is_ajax(): participation_id = request.POST.get("participation_id", "") try: participation = Participation.objects.get(pk=participation_id) except: return HttpResponse("An error has been encountered") participation.status = PARTICIPATION_STATE.CONFIRMED participation.date_accepted = datetime.now() participation.save() send_templated_mail( template_name="challenge_participation_accepted", from_email="*****@*****.**", recipient_list=[participation.user.email, ], context={ "user": participation.user, "challenge": participation.challenge, "subject": _("You were accepted for %(challenge_name)s") % {"challenge_name": participation.challenge.name}, "challenge_url": participation.challenge.get_full_url(request), }, ) return HttpResponse() return HttpResponse("An error has been encountered!")
def test_send_set_password_email(staff_user, site_settings): site = site_settings.site uid = urlsafe_base64_encode(force_bytes(staff_user.pk)) token = default_token_generator.make_token(staff_user) logo_url = build_absolute_uri(static('images/bringall-logo.png')) password_set_url = build_absolute_uri( reverse("account:reset-password-confirm", kwargs={ "token": token, "uidb64": uid })) ctx = { "logo_url": logo_url, "password_set_url": password_set_url, "site_name": site.name, } send_templated_mail( template_name="dashboard/staff/set_password", from_email=DEFAULT_FROM_EMAIL, recipient_list=[staff_user.email], context=ctx, ) assert len(mail.outbox) == 1 generated_link = reverse("account:reset-password-confirm", kwargs={ "uidb64": uid, "token": token }) absolute_generated_link = build_absolute_uri(generated_link) sended_message = mail.outbox[0].body assert absolute_generated_link in sended_message
def save(self, force_insert=False, force_update=False, *args, **kwargs): is_new = self.id is None super(Project, self).save(*args, **kwargs) if is_new: Document.objects.create(project=self, title='Act Notes', internal=True) Document.objects.create(project=self, title='SRTO', internal=True) if self. financing_cash > 0: Document.objects.create(project=self, title='Cash') if self.financing_hloc > 0: Document.objects.create(project=self, title='HELOC') if self.financing_401k > 0: Document.objects.create(project=self, title='401K') if self.financing_pension > 0: Document.objects.create(project=self, title='Pension') if self.financing_ira > 0: Document.objects.create(project=self, title='IRA') if self.financing_stocksbonds > 0: Document.objects.create(project=self, title='Stocks and Bonds') if not User.objects.filter(username=self.email).count(): user = User.objects.create_user(self.email, self.email, 'erF213') user.last_name = self.last_name user.first_name = self.first_name user.save() self.customers_user = user self.save() send_templated_mail( template_name='new_app', from_email='*****@*****.**', recipient_list=[self.email], context={ 'project': self, }, )
def test_send_set_password_email(staff_user, site_settings): site = site_settings.site uid = urlsafe_base64_encode(force_bytes(staff_user.pk)).decode() token = default_token_generator.make_token(staff_user) logo_url = build_absolute_uri(static('images/logo-document.svg')) password_set_url = build_absolute_uri( reverse('account:reset-password-confirm', kwargs={ 'token': token, 'uidb64': uid })) ctx = { 'logo_url': logo_url, 'password_set_url': password_set_url, 'site_name': site.name } send_templated_mail(template_name='dashboard/staff/set_password', from_email=DEFAULT_FROM_EMAIL, recipient_list=[staff_user.email], context=ctx) assert len(mail.outbox) == 1 generated_link = reverse('account:reset-password-confirm', kwargs={ 'uidb64': uid, 'token': token }) absolute_generated_link = build_absolute_uri(generated_link) sended_message = mail.outbox[0].body assert absolute_generated_link in sended_message
def email_share(context): context_data = context.get(DATA_KEY, None) video_id = context.get('video_id', None) video = Video.objects.get(slug=video_id) share_with_email = context_data.get('shareWithEmail', None) shared_by = None if context_data.get('username', None): user = auth.models.User.objects.get(username=context_data['username']) else: user = context.get('user', None) if user and not isinstance(user, auth.models.AnonymousUser): action.send(user, verb='shared', action_object=video) shared_by = user if share_with_email: send_templated_mail( template_name='share-email', from_email=settings.DEFAULT_FROM_EMAIL, recipient_list=[share_with_email], context={ 'shared_by': user, 'video': video, 'site': Site.objects.get_current(), 'shared_by': shared_by, })
def formset_valid(self, formset): """ This function is called when the formset is deemed valid. An email is sent to all email fields which are filled in. If the request is done via ajax give json back with a success message, otherwise redirect to the success url. """ protocol = self.request.is_secure() and 'https' or 'http' date_string = date.today().strftime('%d%m%Y') # Get the current site or empty string try: current_site = Site.objects.get_current() except Site.DoesNotExist: current_site = '' for form in formset: if form in formset.deleted_forms: continue first_name = form.cleaned_data.get('first_name') email = form.cleaned_data.get('email') tenant_id = self.request.user.tenant_id hash = sha256('%s-%s-%s-%s' % ( tenant_id, email, date_string, settings.SECRET_KEY )).hexdigest() invite_link = '%s://%s%s' % (protocol, current_site, reverse_lazy('invitation_accept', kwargs={ 'tenant_id': tenant_id, 'first_name': first_name, 'email': email, 'date': date_string, 'hash': hash, })) # Email to the user send_templated_mail( template_name='invitation', from_email=settings.DEFAULT_FROM_EMAIL, recipient_list=[form.cleaned_data['email']], context={ 'current_site': current_site, 'full_name': self.request.user.full_name, 'name': first_name, 'invite_link': invite_link, } ) post_intercom_event(event_name='invite-sent', user_id=self.request.user.id) if is_ajax(self.request): return HttpResponse(anyjson.serialize({ 'error': False, 'html': _('The invitations were sent successfully'), }), content_type='application/json') return HttpResponseRedirect(self.get_success_url())
def post_save_transaction(signal, instance, **kwargs): send_templated_mail( template_name='send_heart', from_email=settings.FROM_EMAIL, recipient_list=[instance.receiver.user.email], context={ 'transaction': instance })
def borrow(request, book_id): book = get_object_or_404(Book, pk=book_id) today = datetime.date.today() context = {'book': book} if request.method == 'POST': book_request = BookRequest(book=book, requester=request.user) form = BookRequestForm(request.POST, instance=book_request) if form.is_valid(): request_object = form.save() review_url = request.build_absolute_uri(reverse('books:review_requests')) send_templated_mail( template_name='book_requested', from_email=settings.DEFAULT_FROM_EMAIL, recipient_list=[book.submitter.email], context={ 'book': book, 'book_request': book_request, 'review_url': review_url, }) return HttpResponseRedirect(reverse('books:my_requests')) else: context['form'] = form return render(request, 'books/borrow.html', context) else: # Since available_until can be None: if not book.available_until: is_still_available = True else: is_still_available = today <= book.available_until # Check if there are pending requests if not book.status == 'A': # Check if the book is actually available (not held, # borrowed or expired). # TODO: Make it possible to borrow a book in the future, # after the book is returned. context['error'] = 'not_available' #elif request.user == book.submitter: # context['error'] = 'is_submitter' elif request.user == book.holder: context['error'] = 'is_holder' elif not is_still_available: context['error'] = 'expired' elif today < book.available_from: context['error'] = 'not_yet' elif book.available_to != get_gender(request.user): context['error'] = 'gender' # If the more serious errors arenot present, we can check for # warnings and prepare the form: if not 'error' in context: previous_requests = BookRequest.objects.filter(status='P') if previous_requests: context['warning'] = 'pending_requests' form = BookRequestForm() context['form'] = form return render(request, 'books/borrow.html', context)
def form_valid(self, form): """ Register a new user. """ # Do not accept any valid form when registration is closed. if not settings.REGISTRATION_POSSIBLE: messages.error(self.request, _('I\'m sorry, but I can\'t let anyone register at the moment.')) return redirect(reverse_lazy('login')) # Create and save user user = LilyUser.objects.create_user( email=form.cleaned_data['email'], password=form.cleaned_data['password'], first_name=form.cleaned_data['first_name'], preposition=form.cleaned_data['preposition'], last_name=form.cleaned_data['last_name'], ) user.is_active = False user.save() # Add to admin group account_admin = Group.objects.get_or_create(name='account_admin')[0] user.groups.add(account_admin) # Get the current site try: current_site = Site.objects.get_current() except Site.DoesNotExist: current_site = '' # Generate uidb36 and token for the activation link uidb36 = int_to_base36(user.pk) token_generator = PasswordResetTokenGenerator() token = token_generator.make_token(user) # Send an activation mail # TODO: only create/save contact when e-mail sent successfully send_templated_mail( template_name='activation', from_email=settings.DEFAULT_FROM_EMAIL, recipient_list=[form.cleaned_data['email']], context={ 'current_site': current_site, 'protocol': self.request.is_secure() and 'https' or 'http', 'user': user, 'uidb36': uidb36, 'token': token, } ) # Show registration message messages.success( self.request, _('Registration completed. I\'ve sent you an email, please check it to activate your account.') ) return self.get_success_url()
def test_with_connection_in_args(self): mocked_connection = Mock() send_templated_mail(*self.TEST_ARGS, connection=mocked_connection, **self.TEST_KWARGS) kwargs = dict(self.TEST_KWARGS) del kwargs['template_prefix'] del kwargs['template_suffix'] mocked_connection.send.assert_called_with(*self.TEST_ARGS, **kwargs)
def sendmail(self, title, email,ctx): current_site = Site.objects.get(id=1), send_templated_mail( template_name = 'product_alert', from_email = '*****@*****.**', recipient_list = [email], context = ctx, ) print "mail successfully"
def send_promote_customer_to_staff_email(staff_pk): staff = User.objects.get(pk=staff_pk) ctx = get_email_base_context() ctx['dashboard_url'] = build_absolute_uri(reverse('dashboard:index')) send_templated_mail( template_name='dashboard/staff/promote_customer', from_email=settings.DEFAULT_FROM_EMAIL, recipient_list=[staff.email], context=ctx)