def handle(self, *args, **kwargs):
### Select
today = date.today()
messages = ()
for user in User.objects.all():
### Check batches ready to bottle
bottle_batch_list = Batch.objects.filter(predicted_ready__lte=today,user=user,notified_bottle_complete=False)
brewed_batch_list = Batch.objects.filter(predicted_brew_ready__lte=today,user=user,notified_brew_complete=False)
### Check batches ready to drink.
if len(brewed_batch_list) > 0 or len(bottle_batch_list) > 0:
message_body = 'Hi {user}, the following is ready:\n\n'.format(user=user)
for batch in brewed_batch_list:
message_body += '- Batch #{id}, {name}, is ready to bottle.\n'.format(id=batch.id, name=batch)
batch.notified_brew_complete = True
batch.save()
for batch in bottle_batch_list:
message_body += '- Batch #{id}, {name}, is ready to drink!\n'.format(id=batch.id, name=batch)
batch.notified_bottle_complete = True
batch.save()
message_body += '\nSincerely,\n\nThe homebrew fairy'
#Prepare the email.
message = ('Homebrew notification {date}'.format(date=today),
message_body,
'*****@*****.**',
[user.email])
messages += (message,)
if len(messages) > 0:
send_mass_mail(messages, fail_silently=False)
def cancel(self, user, *args, **kwargs):
extra_note = ''
part_of_your = 'Part of your'
if self.booking.booking_parts.exclude(state='cancelled').exclude(id=self.id).count() == 0 and self.booking.cancel.is_available() and kwargs.get('cancel_children', True):
self.booking.cancel(silent=True, user=user, cancel_children=False)
extra_note += "\nThis resulted in the cancellation of the booking, as there were no more active parts remaining."
part_of_your = 'Your'
if not kwargs.get('silent', False):
interested_parties = [('{} booking #{} has been cancelled'.format(part_of_your, self.booking.id), self.booking.user.email)]
from_email = '*****@*****.**'
message = """
Hello,
Part of your booking number #{} has been cancelled by {}.
Your booking of {}, which was booked from {} to {} was cancelled.{}
Regards,
The Media Booking System
""".format(self.booking.id, user, self.lendable.name, self.start_date, self.end_date, extra_note)
datatuple = [(subject, message, from_email, [recipient]) for (subject, recipient) in interested_parties]
mail.send_mass_mail(datatuple, fail_silently=True)
def send(cls, sender, event_type, request, **kwargs):
catalogue = sender
from_email = settings.FROM_EMAIL
if event_type == 'published':
action = 'added'
subject = 'A new {0} was {1}'.format(catalogue.kind, action)
if event_type == 'updated':
action = 'edited'
article = 'An' if catalogue.kind == 'offer' else 'A'
subject = '{0} {1} was {2}'.format(article, catalogue.kind, action)
catalogue_url = reverse('catalogue_view', kwargs={
'pk': catalogue.pk, 'kind': catalogue.kind
})
notifications_url = reverse('notifications:home')
body = render_to_string('notification_email.html', {
'catalogue': catalogue,
'action': action,
'notifications_url': request.build_absolute_uri(notifications_url),
'catalogue_url': request.build_absolute_uri(catalogue_url),
})
datatuple = []
for user in cls.objects.filter(subscribed=True):
email = [get_user_email(user.user_id)]
datatuple.append((subject, body, from_email, email))
send_mass_mail(datatuple)
def new_d_msg(t, d, name, hp, mail):
subject = u'【新释义】有人提交了新的释义!'
message = d_msg(t, d, name, hp, mail)
from_email = '*****@*****.**'
recipient_list = ['*****@*****.**']
message1 = (subject, message, from_email, recipient_list)
send_mass_mail((message1,), fail_silently=False)
def mass_mail_volunteer(self, request, queryset):
if not request.user.is_staff:
raise PermissionDenied
form = None
if 'send' in request.POST:
form = self.MassMailForm(request.POST)
if form.is_valid():
subject = form.cleaned_data['subject']
message = form.cleaned_data['message']
count = 0
plural = ''
for volunteer in queryset:
if volunteer.user.email:
# Would have preferred to collect the mails in volunteer_mails list,
# then send one mail outside this loop, but we don't want volunteers
# to see each other's email addresses for privacy reasons, which means
# BCC, which means it will get sent out as separate mails anyway.
send_mass_mail(((subject, message, settings.DEFAULT_FROM_EMAIL, [volunteer.user.email]),), fail_silently=False)
count += 1
if count > 1:
plural = 's'
self.message_user(request, 'Mail with subject "{}" sent to {} volunteer{}.'.format(subject, count, plural))
return HttpResponseRedirect(request.get_full_path())
if not form:
form = self.MassMailForm(initial={'_selected_action': request.POST.getlist(admin.ACTION_CHECKBOX_NAME)})
return render(request, 'admin/massmail.html', {'volunteers': queryset,
'massmail_form': form,
})
def send_mass_mail(self, request, queryset):
opts = self.model._meta
app_label = opts.app_label
form = MassMailForm()
if request.POST.get('post'):
form = MassMailForm(request.POST)
if form.is_valid():
data = []
recipients = [user.email for user in queryset if user.email]
for recipient in recipients:
data.append((form.cleaned_data['subject'], form.cleaned_data['text'],
None, (recipient,)))
mail.send_mass_mail(data)
messages.success(request, _('Mails sent successfully.'))
return # Let django handle redirections.
context = {
'title': _('Send mass mail'),
'queryset': queryset,
'opts': opts,
'app_label': app_label,
'action_checkbox_name': helpers.ACTION_CHECKBOX_NAME,
'form': form,
}
return TemplateResponse(request, 'rcal/send_mass_mail.html', context,
current_app=self.admin_site.name)
def test_connection_arg(self):
"""Test connection argument to send_mail(), et. al."""
mail.outbox = []
# Send using non-default connection
connection = mail.get_connection("regressiontests.mail.custombackend.EmailBackend")
send_mail("Subject", "Content", "*****@*****.**", ["*****@*****.**"], connection=connection)
self.assertEqual(mail.outbox, [])
self.assertEqual(len(connection.test_outbox), 1)
self.assertEqual(connection.test_outbox[0].subject, "Subject")
connection = mail.get_connection("regressiontests.mail.custombackend.EmailBackend")
send_mass_mail(
[
("Subject1", "Content1", "*****@*****.**", ["*****@*****.**"]),
("Subject2", "Content2", "*****@*****.**", ["*****@*****.**"]),
],
connection=connection,
)
self.assertEqual(mail.outbox, [])
self.assertEqual(len(connection.test_outbox), 2)
self.assertEqual(connection.test_outbox[0].subject, "Subject1")
self.assertEqual(connection.test_outbox[1].subject, "Subject2")
connection = mail.get_connection("regressiontests.mail.custombackend.EmailBackend")
mail_admins("Admin message", "Content", connection=connection)
self.assertEqual(mail.outbox, [])
self.assertEqual(len(connection.test_outbox), 1)
self.assertEqual(connection.test_outbox[0].subject, "[Django] Admin message")
connection = mail.get_connection("regressiontests.mail.custombackend.EmailBackend")
mail_managers("Manager message", "Content", connection=connection)
self.assertEqual(mail.outbox, [])
self.assertEqual(len(connection.test_outbox), 1)
self.assertEqual(connection.test_outbox[0].subject, "[Django] Manager message")
def test_chunking(self):
"""
Given 11 messages and a chunk size of 4, the backend should queue
11/4 = 3 jobs (2 jobs with 4 messages and 1 job with 3 messages).
"""
N = 11
chunksize = 4
with override_settings(CELERY_EMAIL_CHUNK_SIZE=4):
mail.send_mass_mail([
("subject", "body", "*****@*****.**", ["*****@*****.**"])
for _ in range(N)
])
num_chunks = 3 # floor(11.0 / 4.0)
self.assertEqual(len(self._delay_calls), num_chunks)
full_tasks = self._delay_calls[:-1]
last_task = self._delay_calls[-1]
for args, kwargs in full_tasks:
self.assertEqual(len(args[0]), chunksize)
args, kwargs = last_task
self.assertEqual(len(args[0]), N % chunksize)
def send_via_mail_to(request):
"""
send email to list of freinds
:param request:
in the square represented by :
west < longitude < east
north < latitude < south
"""
idAlert = int(request.POST['id'])
emails = request.POST['list']
text = request.POST['text']
listMails = emails.rstrip('#').split('#')
alert = Alert.objects.get(id=idAlert)
# email
path = reverse("public_show_alert", args=(idAlert,))
subject = "BloodOn team team,"
message = ''
if len(text):
message += '%s \n,' % text
message += 'This message has been sent from <href ="http://%s">BloodOn Inc</href>, ' \
'Because Some one need blood , the %s, ' \
'at %s \n ' % (settings.SITE_PATH, alert.date_for, alert.organization.name)
message += '\n for more detail please refer to : <href ="http://%s%s">BloodOn' \
'Inc</href> \n' % (settings.SITE_PATH, path)
messageMail = (subject, message, settings.DEFAULT_FROM_EMAIL, listMails)
send_mass_mail((messageMail,), fail_silently=False)
return bloodon_renderAsJson(request, {'success' : True})
def send_emails(self, recipients):
"""Send the emails using the templates and contexts requested."""
email_subject = self.options['subject']
email_sender = self.options['sender']
txt_template = loader.get_template(self.options['template'])
context = ast.literal_eval(self.options['context'])
email_txt = txt_template.render(context)
emails_sent_count = 0
messages = []
for recipient in recipients:
messages.append((
email_subject,
email_txt,
email_sender,
[recipient],
))
emails_sent_count += 1
if not self.options['simulate']:
send_mass_mail(messages, fail_silently=False)
tally_stat('pr.emails.sent', inc=emails_sent_count)
logger.info("Sent %s pr emails." % emails_sent_count)
else:
sys.stdout.write('Simulation mode. Imagine that we just sent %s '
'emails!\n' % emails_sent_count)
def send_emails(self, uids, feedback_address):
messages = []
addresses = []
data = self.cleaned_data
for sbj, body, user in self.preview(*uids):
messages.append((sbj, body, data['from_'], [user.email]))
addresses.append('"%s %s" - %s' % (user.first_name, user.last_name, user.email))
mail.send_mass_mail(messages)
# feedback mail
ctx = dict(data)
ctx['addresses'] = '\n'.join(addresses)
mail.send_mail(
'[%s] feedback mass mailing (admin stats)' % settings.CONFERENCE,
'''
message sent
-------------------------------
FROM: %(from_)s
SUBJECT: %(subject)s
BODY:
%(body)s
-------------------------------
sent to:
%(addresses)s
''' % ctx,
dsettings.DEFAULT_FROM_EMAIL,
recipient_list=[feedback_address],
)
return len(messages)
def index(request):
if request.method == "POST":
# Recupera os dados do POST e Cria um objeto de Formulário do tipo PessoaForm
form = PessoaForm(request.POST)
# Valida os dados do Formulario
if form.is_valid():
'''É melhor acessar form.cleaned_data. Estes dados não serão somente válidos,
mas estarão convertidos em tipos relevantes do Python'''
# Recupera cada valor do Dicionario
vnome = form.cleaned_data['nome']
vemail = form.cleaned_data['email']
vmensagem = form.cleaned_data['mensagem']
# Metodo para salvar no banco de dados
form.save()
# Cria a mensagem para o administrador(CEO)
msg_adm = ('Mensagem do Cliente', 'Nome: %s \nE-mail: %s \nMensagem: %s ' % (vnome, vemail, vmensagem), '*****@*****.**', ['*****@*****.**'])
# Cria a mensagem para o Cliente
msg_cliente = ('Code - WEB Solutions', 'Agradecemos seu Contato e interesse na Code, dentro de 24h entraremos em contato.', '*****@*****.**', ['%s' % (vemail)])
# Abre apenas uma conexão com o servidor de email e evia as duas mensagens
try:
send_mass_mail((msg_adm, msg_cliente), fail_silently=False)
except:
raise Http404
# Redireciona para a Index
messages.success(request, '%s, mensagem enviada com sucesso !' % vnome.title())
return render(request, 'index.html')
else:
messages.success(request, 'Ops! O formulário foi preenchido incorretamente')
return render(request, 'index.html')
else:
# Se for GET, istancia o Formulário
form = PessoaForm()
# Retorna o Formulario renderizado para o Template
return render_to_response('index.html', {'form': form})
def do_handle(self, *args, **options):
self.stdout.write('Started.\n')
logger.info("Start")
meta_diff = datetime.datetime.now() - datetime.timedelta(days=getattr(settings, 'MESSAGE_DAYS_AGE',1))
t_start = time.time()
mailing = []
for user in User.objects.filter(pm_inbox__unread=True, pm_inbox__notified__isnull=True, pm_inbox__message__created__lt=meta_diff).distinct():
messages = user.pm_inbox.filter(unread=True, notified__isnull=True, message__created__lt=meta_diff)
count = messages.count()
logger.debug("There are %s messages for %s" % (count, user))
set_user_language(user)
subject = ungettext('You have %(count)d unread message', 'You have %(count)d unread messages', count) % {
'count': count,
}
message = render_to_string('djangopm/mail/unread_messages.mail', {'message_count': count,
'user': user,
'messages': messages.all()})
mailing.append((subject, message, None, [ user.email ]))
messages.update(notified=datetime.datetime.now())
if len(mailing)>0:
logger.debug("Notify %d users" % len(mailing))
send_mass_mail(mailing, True)
logger.info("End")
self.stdout.write('Completed in %d seconds. Notified %s.\n' % (int(time.time() - t_start), len(mailing)))
return "Notify %d users" % len(mailing)
def send_email(self):
recipients = ContactRecipient.objects.filter(
active=True
).values_list('email', flat=True)
template = get_template('email/contact.html')
if len(recipients) == 0:
return
context = dict(
contact=self
)
message = template.render(context)
try:
send_mass_mail((
(
'A new contact request from %s' % self.name,
message,
'*****@*****.**',
list(recipients)
),
))
except:
print 'Error sending email'
else:
self.date_sent = datetime.datetime.now()
self.save()
def send_prediction_reminder_emails(predictions, users):
if not predictions:
return
mails = []
subject = u"[Big Brother] Today's Predictions"
sender = u'*****@*****.**'
for user in users:
if not user.email:
continue
message = [u'The following predictions are due today on '
'http://bigbrother.striemer.ca:', u'']
for prediction in predictions:
message.append(u'* {name}'.format(name=prediction))
choices = prediction.user_choices(user)
for i in xrange(prediction.number_of_choices):
if i < len(choices):
message.append(u' {i}. {choice}'.format(
choice=choices[i], i=i + 1))
else:
message.append(
u' {i}. You have not made a prediction'.format(
i=i + 1))
message.append(u'')
mails.append((subject, u'\n'.join(message), sender, [user.email]))
send_mass_mail(mails)
def handle(self, *args, **options):
global log_file
(user_file, message_base, logfilename, ratestr) = args
users = [u.strip() for u in open(user_file).readlines()]
message = middleware.lookup['main'].get_template('emails/' + message_base + "_body.txt").render()
subject = middleware.lookup['main'].get_template('emails/' + message_base + "_subject.txt").render().strip()
rate = int(ratestr)
self.log_file = open(logfilename, "a+", buffering=0)
i = 0
for users in chunks(users, rate):
emails = [(subject, message, settings.DEFAULT_FROM_EMAIL, [u]) for u in users]
self.hard_log(" ".join(users))
send_mass_mail(emails, fail_silently=False)
time.sleep(1)
print datetime.datetime.utcnow().isoformat(), i
i = i + len(users)
# Emergency interruptor
if os.path.exists("/tmp/stopemails.txt"):
self.log_file.close()
sys.exit(-1)
self.log_file.close()
def send_invitation(modeladmin, request, queryset):
messages_to_send = []
for invitation in queryset:
emails = []
guests = invitation.weddingguest_set.all()
# activating invitation language
activate(invitation.invitation_language)
# lazy translating
subject = _(u"Jūs pakviesti! Kur? Žiūrėkite į laiško vidų.")
body_message = _(u"Berniukas sutiko mergaitę. Tiesa, prieš 10 metų. Likusią istorijos\ndalį sužinosite prisijungę prie mūsų šventės.\n\nJūsų kodas: %(code)s\n\nApsilankykite svetainėje: http://rsvp.gang.lt sužinosite daugiau. Iki.")
for g in guests:
if g.email != None and g.email.strip() != '':
emails.append(str(g.email))
if len(emails) > 0:
messages.info(request, "Successfully sent emails to: %s" % ','.join(emails))
messages_to_send.append((subject, body_message % {'code': invitation.invite_code},
'*****@*****.**',
emails))
invitation.email_sent = True
invitation.email_sent_at = datetime.now()
invitation.save()
else:
messages.error(request, "Invitation %s has no emails assigned" % invitation)
if len(messages_to_send) > 0:
send_mass_mail(messages_to_send, fail_silently=False)
def send_booking_receipt(booking_id, language_code):
"""
Send mails on booking confirmed
"""
translation.activate(language_code)
booking = Booking.objects.get(pk=booking_id)
account = booking.event.account
sender = account.from_address or 'noreply@%s' % Site.objects.get_current().domain
try:
send_mass_mail(
((render_to_string(
'signupbox/mails/register_email_subject.txt' if index else 'signupbox/mails/register_email_subject_registrant.txt',
context_instance=Context({'event': booking.event, 'booking': booking, 'attendee': attendee}, autoescape=False)
), render_to_string(
'signupbox/mails/register_email.txt' if index else 'signupbox/mails/register_email_registrant.txt',
context_instance=Context({'event': booking.event, 'booking': booking, 'attendee': attendee}, autoescape=False)
), sender,
[attendee.email])
for index, attendee in enumerate(booking.attendees.order_by('id')) if attendee.email
)
)
except SMTPException, exc:
process_booking.retry(exc=exc)
def handle_noargs(self, **options):
time_interval = datetime.timedelta(minutes=1)
timestamp = timezone.now().replace(second=0, microsecond=0)
# get recently closed polls
recently_closed_poll_list = Poll.objects.filter(
closing_date__lt = timestamp
).filter(
closing_date__gte = timestamp - time_interval
)
for poll in recently_closed_poll_list:
#self.stdout.write('Poll: '+str(poll.pk), ending = '')
# TODO compute the winner
# if the poll contains user : send notify them
participant_list = list(poll.participant.all())
email_list = ()
for participant in participant_list:
message = ()
if participant.email != "*****@*****.**":
# email used for all public poll
self.stdout.write('Voter: ' +participant.email, ending = '')
message_data = {
'admin': poll.admin,
'voter_uuid': participant.uuid if poll.private else 'public',
'poll': poll,
'domain': 'pnyx.dss.in.tum.de',
'protocol': 'https',
}
logger.debug("Voter " + participant.email + " notified about the end of the poll " + str(poll.pk))
message += (('Your Pnyx poll has been closed, please check the final results',
render_to_string('polls/poll_closed_email.html', message_data),
'*****@*****.**',
[participant.email]),)
send_mass_mail(message, fail_silently = False)
def sendMail(self,request): # Inicializar variables de correo subject = 'Últimas noticias de esta semana' message = '' messageList = () # Obtener últimas noticias categories = Categories.objects.all() for category in categories: message = '\n'+category.name+': \n' for source in category.sources.all(): feed_items = feedparser.parse(source.rss_url) try: for i in range(0,3): message += feed_items['entries'][i].title + ' - ' + feed_items['entries'][i].link + '\n' except Exception as e: e category.message = message # Obtener usuarios suscritos y asignar las categorías correspondientes a su correo userProfiles = UserProfile.objects.all() for userProfile in userProfiles: if userProfile.mailFlag: message = '' user = User.objects.get(id = userProfile.user.id) for category in categories: if category.sources: message += category.message mail = (subject,message,'*****@*****.**',[user.email]) messageList += mail send_mass_mail((messageList,),fail_silently=False) return Response(status=201)
def send_fillform_mail(modeladmin, request, queryset):
"""Send fillform informations to the user"""
if request.POST.get('post'):
register_view_url = request.build_absolute_uri(reverse('staff:registration'))
mails = tuple(__get_fillform_email(register_view_url, p) for p in queryset)
send_mass_mail(mails)
count = len(mails)
data = {'count': count,
'person': str(queryset[0]),}
admin_msg = ungettext(
'Die Fillform E-Mail wurde an {person} verschickt.',
'Die Fillform E-Mails wurden an {count} Personen verschickt.',
count).format(**data)
modeladmin.message_user(request, admin_msg, messages.SUCCESS)
else:
context = {
'queryset': queryset,
'opts' : modeladmin.opts,
'title': _("Fillform E-Mail verschicken"),
'action_checkbox_name': helpers.ACTION_CHECKBOX_NAME,
}
template = loader.get_template("staff/admin/fillform_email_confirm.html")
return TemplateResponse(request, template, context)
def drop_ride(request, ride_id):
"""
This function drops a user from a ride if they are part of it. Otherwise, it
does nothing and reports an error.
"""
context_instance = RequestContext(request)
user = context_instance['user']
query = Q(ride__id=ride_id) &\
Q(user__id=user.id)
sr = SearchRequest.objects.filter(query)
if sr:
sr = sr[0]
ride = sr.ride
sr.delete()
messages.add_message(request, messages.SUCCESS,
"Success! You were removed from the ride.")
#Send e-mail notification to other riders
subject = '%s %s has left your ride' % (user.first_name, user.last_name)
body = 'Sorry, but %s has left a ride you are a part of at CabFriendly.com. Go to http://cabfriendly.com/rides/%d/ to view updated details and coordinate the ride.' % (user.first_name, ride.id)
emails = []
ride.filled_out()
for rider in ride.riders:
if rider.id != user.id:
emails.append((subject, body, OUR_EMAIL, [rider.email]))
send_mass_mail(emails, fail_silently=False)
else:
messages.add_message(request, messages.WARNING,
"You actually weren't part of ride %s to begin with :)"
% (ride_id))
return redirect('/')
def send_alert(request):
try:
contacts = Contact.objects.filter(user=request.user)
if not contacts:
return render_to_response('contacts/alert-status.html', {'status_msg': 'There are no emergency contacts available. Please add your emergency contacts.'}, RequestContext(request))
else:
try:
location = request.POST.get('location', '')
user = UserProfile.objects.get(user=request.user)
from_email = request.user.email
msg_list = _build_message_list(user, contacts, location, from_email)
if len(msg_list) > 0:
datatuple = tuple(msg_list)
# send alert messages
send_mass_mail(datatuple, fail_silently=True,
auth_user=os.environ.get('ERGO_ALERT_AUTH_USER', ERGO_ALERT_AUTH_USER),
auth_password=os.environ.get('ERGO_ALERT_AUTH_PASSWORD', ERGO_ALERT_AUTH_PASSWORD))
else:
return render_to_response('contacts/alert-status.html', {'status_msg': 'Emergency contact alert options have not been specified. Please edit your emergency contacts.'}, RequestContext(request))
# return success status
return render_to_response('contacts/alert-status.html', {'status_msg': 'Emergency contacts have been successfully notified.'}, RequestContext(request))
except UserProfile.DoesNotExist:
# return missing profile
return render_to_response('contacts/alert-status.html', {'status_msg': 'ERROR: Missing user profile.'}, RequestContext(request))
except:
return render_to_response('contacts/alert-status.html', {'status_msg': 'Error encountered while alerting emergency contacts. Please try again.'}, RequestContext(request))
def mass_mail_volunteer(self, request, queryset):
if not request.user.is_staff:
raise PermissionDenied
form = None
if 'send' in request.POST:
form = self.MassMailForm(request.POST)
if form.is_valid():
subject = form.cleaned_data['subject']
message = form.cleaned_data['message']
count = 0
plural = ''
volunteer_mails = []
for volunteer in queryset:
# TODO: actually send the mail
if volunteer.user.email:
volunteer_mails.append(volunteer.user.email)
count += 1
send_mass_mail(((subject, message, settings.DEFAULT_FROM_EMAIL, volunteer_mails),), fail_silently=False)
if count > 1:
plural = 's'
self.message_user(request, 'Mail with subject "%s" sent to %d volunteer%s.' % (subject, count, plural))
return HttpResponseRedirect(request.get_full_path())
if not form:
form = self.MassMailForm(initial={'_selected_action': request.POST.getlist(admin.ACTION_CHECKBOX_NAME)})
return render(request, 'admin/massmail.html', {'volunteers': queryset,
'massmail_form': form,
})
def save(self):
name = self.cleaned_data['name']
email = self.cleaned_data['email']
message = self.cleaned_data['message']
subject = 'IAS Individual Contact Form'
messages = []
messages.append((
subject,
render_to_string(
'crm/contact/contact_form.txt',
self.cleaned_data,
),
settings.DEFAULT_FROM_EMAIL,
self.recipients,
))
messages.append((
subject,
render_to_string(
'crm/contact/contact_form_confirmation.txt',
self.cleaned_data,
),
settings.DEFAULT_FROM_EMAIL,
[email],
))
send_mass_mail(messages, fail_silently=True)
def send_email(request):
form = BulkEmailForm(request.POST or None)
if request.method == 'POST':
if form.is_valid():
subject = form.cleaned_data['subject']
body = form.cleaned_data['body']
person_query = form.get_person_query()
emails = _get_emails(person_query, subject, body)
if 'preview' in request.POST:
try:
preview = emails[0]
except IndexError:
preview = None
else:
send_mass_mail(emails)
messages.success(request, "Emails sent successfully")
return HttpResponseRedirect(reverse('index'))
return render(
template_name='karaage/emails/send_email_form.html', context=locals(),
request=request)
def cancel(self, user, *args, **kwargs):
new_kwargs = dict(kwargs)
new_kwargs['silent'] = True
new_kwargs['user'] = user
new_kwargs['cancel_children'] = False
did_cancel = []
if kwargs.get('cancel_children', True):
for child in self.booking_parts.all():
if child.cancel.is_available():
did_cancel.append(child)
child.cancel(*args, **new_kwargs)
if not kwargs.get('silent', False):
interested_parties = [('Your booking #{} has been cancelled'.format(self.id), self.user.email)]
from_email = '*****@*****.**'
this_also = """
This also resulted in the cancellation of the parts:"""
for things in did_cancel:
this_also += "\n * {} (booked from {} to {})".format(things.lendable.name, things.start_date, things.end_date)
if not did_cancel:
this_also = ""
message = """
Hello,
Your booking number #{} has been cancelled by {}.
{}
Regards,
The Media Booking System
""".format(self.id, user, this_also)
datatuple = [(subject, message, from_email, [recipient]) for (subject, recipient) in interested_parties]
mail.send_mass_mail(datatuple, fail_silently=True)
def send_email(self):
"""Send email to selected athletes."""
email_addresses = set(self.cleaned_data['additional_emails'])
if self.cleaned_data['sent_to_all']:
for athlete in Athlete.objects.exclude(active=False).exclude(email__isnull=True).exclude(email=''):
email_addresses.update(athlete.email_addresses)
for coach in User.objects.exclude(email__isnull=True).exclude(email=''):
email_addresses.add(coach.email)
else:
for athlete in self.cleaned_data['athletes']:
email_addresses.update(athlete.email_addresses)
for team in self.cleaned_data['teams']:
for athlete in team.athletes.exclude(active=False).exclude(email__isnull=True).exclude(email=''):
email_addresses.update(athlete.email_addresses)
for coach in self.cleaned_data['coaches']:
email_addresses.add(coach.email)
if not email_addresses:
raise Exception('No email selected')
email_addresses.add('Spirit Cheer 07 <*****@*****.**>')
for email in email_addresses:
logger.info('Sending email to {}'.format(email))
send_mass_mail((self.cleaned_data['subject'], self.cleaned_data['message'], 'Spirit Cheer 07 <*****@*****.**>', (email,)) for email in email_addresses)
def enviarMail(request):
if request.method == 'POST':
formulario = ContactoForm(request.POST)
if formulario.is_valid():
nombre = formulario.cleaned_data['nombre']
correo = formulario.cleaned_data['correo']
mensaje = formulario.cleaned_data['mensaje'] + "\n" + formulario.cleaned_data['correo'] + "\n" + formulario.cleaned_data['celular']
""" direcciones de correo a enviar correo de contacto """
datatuple = (
(nombre, mensaje, correo, ['*****@*****.**']),
(nombre, mensaje, correo, ['*****@*****.**']),
)
send_mass_mail(datatuple)
return render(request, 'index.html')
else:
formulario = ContactoForm()
return render(request, 'contacto.html', {'formulario': formulario})
def test_connection_arg(self):
"""Test connection argument to send_mail(), et. al."""
mail.outbox = []
# Send using non-default connection
connection = mail.get_connection('mail.custombackend.EmailBackend')
send_mail('Subject', 'Content', '*****@*****.**', ['*****@*****.**'], connection=connection)
self.assertEqual(mail.outbox, [])
self.assertEqual(len(connection.test_outbox), 1)
self.assertEqual(connection.test_outbox[0].subject, 'Subject')
connection = mail.get_connection('mail.custombackend.EmailBackend')
send_mass_mail([
('Subject1', 'Content1', '*****@*****.**', ['*****@*****.**']),
('Subject2', 'Content2', '*****@*****.**', ['*****@*****.**']),
], connection=connection)
self.assertEqual(mail.outbox, [])
self.assertEqual(len(connection.test_outbox), 2)
self.assertEqual(connection.test_outbox[0].subject, 'Subject1')
self.assertEqual(connection.test_outbox[1].subject, 'Subject2')
connection = mail.get_connection('mail.custombackend.EmailBackend')
mail_admins('Admin message', 'Content', connection=connection)
self.assertEqual(mail.outbox, [])
self.assertEqual(len(connection.test_outbox), 1)
self.assertEqual(connection.test_outbox[0].subject, '[Django] Admin message')
connection = mail.get_connection('mail.custombackend.EmailBackend')
mail_managers('Manager message', 'Content', connection=connection)
self.assertEqual(mail.outbox, [])
self.assertEqual(len(connection.test_outbox), 1)
self.assertEqual(connection.test_outbox[0].subject, '[Django] Manager message')
def send_many_text(data_tuple):
"""
一次性发送多条消息: 自动添加前缀和主题签名
datatuple:
(
(subject0, message0, sender, recipient),
(subject1, message1, sender, recipient),
(subject2, message2, sender, recipient),
)
"""
data_tuple = ((add_prefix(d[0]), d[1], d[2], d[3]) for d in data_tuple)
send_mass_mail(data_tuple)
def send_server_update_notification():
r = requests.get(GITHUB_API_URL + '/repos/' + GITHUB_USER + '/' + GITHUB_REPO + '/commits/' + GITHUB_BRANCH)
data = r.json()
sha = data['sha']
author = data['commit']['author']['name']
send_mail = False
teerace_server_sha = cache.get('teerace_server_sha')
if teerace_server_sha is None:
date = datetime.strptime(data['commit']['author']['date'], '%Y-%m-%dT%H:%M:%SZ')
now = timezone.now()
if now - date < timedelta(days=1): # only do this if the last commit is not older than one day to prevent spam mails
send_mail = True
else:
if sha != teerace_server_sha:
send_mail = True
if send_mail:
from race.models import Server
cache.set('teerace_server_sha', sha, timeout=None)
if not DEFAULT_FROM_MAIL:
return
# only notify people with servers online
servers_online = Server.objects.filter(
last_connection_at__gte=(datetime.now()-timedelta(minutes=10))
)
users = []
for server in servers_online:
users.append(server.maintained_by)
if users:
users = set(users)
messages = [
(
u'Teerace: New server available',
u'Hello {username}\r\n\r\nThere is a new version of the '
'teerace server available.\r\n\r\nThe latest commit with '
'the message "{commit_message}" was done by {commiter}.'
'\r\nPlease decide for yourself if it is necessary to '
'compile the new version. For more information visit {url}'
'\r\n\r\ncheers\r\nTeerace team'.format(username=user.username,
commit_message=data['commit']['message'],
commiter=author,
url=data['html_url']
),
DEFAULT_FROM_MAIL,
[user.email]
) for user in users
]
send_mass_mail(messages, fail_silently=not DEBUG)
def mail_members(request):
if request.method == "POST":
form = MailMembersForm(request.POST)
else:
form = MailMembersForm()
if form.is_valid():
members = form.get_members()
subject = form.cleaned_data["subject"]
message = form.cleaned_data["message"]
sender = request.user.username + "@stacken.kth.se"
recipients = form.cleaned_data["recipients"]
if recipients:
recipients = [("", [recipient])
for recipient in recipients.split(",")]
else:
recipients = [(f"{member.first_name} {member.last_name}",
[member.email, f"{member.username}@stacken.kth.se"])
for member in members]
extra_to = form.cleaned_data["extra_to"]
if not extra_to:
extra_to = "*****@*****.**"
recipients.append(("", [extra_to]))
context = {
"recipients": recipients,
"form": form,
"test": True,
"exception": None,
}
if request.POST.get("do_it", "") == "true":
context["test"] = False
messages = [(subject, message, sender, email)
for (_, email) in recipients]
try:
send_mass_mail(messages, fail_silently=False)
except:
context["exception"] = sys.exc_info()
return render(request, "mail_members_test.html", context)
return render(
request,
"mail_members.html",
{
"form": form,
},
)
def send_notifications():
emails_list = []
email_from = 'ANS Support <*****@*****.**>'
# Problems
# Up
up_problems = models.Problem.objects.filter(send_up_email=True)
for problem in up_problems:
# Check if there are any email addresses to send to
addresses = problem.notification_addresses_list
if len(addresses) > 0:
# Send email
email_to = addresses
email_subject = "".join([
"[AgileNMS] INFO: ",
str(problem.check),
" no longer has a problem '" + problem.name + "'"
])
email_message = render_to_string(
'monitoring/emails/problem_up.txt', {'problem': problem})
emails_list.append(
(email_subject, email_message, email_from, email_to))
# Clear send_up_email flag
problem.send_up_email = False
problem.save()
# Down
down_problems = models.Problem.objects.filter(send_down_email=True)
for problem in down_problems:
# Check if there are any email addresses to send to
addresses = problem.notification_addresses_list
if len(addresses) > 0:
# Send email
email_to = addresses
email_subject = "".join([
"[AgileNMS] ERROR: ",
str(problem.check), " has a problem '" + problem.name + "'"
])
email_message = render_to_string(
'monitoring/emails/problem_down.txt', {'problem': problem})
emails_list.append(
(email_subject, email_message, email_from, email_to))
# Clear send_down_email flag
problem.send_down_email = False
problem.save()
print tuple(emails_list)
# Send emails
send_mass_mail(tuple(emails_list))
def email(request):
students = Student.objects.all()
to_emails = []
i = 0
for stu in students:
to_emails.append(stu.email)
message1 = ('TA evaluations', 'Here is a link to fill out your evaluations: http://localhost:8000/login ', '*****@*****.**', to_emails)
send_mass_mail((message1,), fail_silently=False)
context = {
}
return render(request, "ta/email.html", context)
def subscribe(request):
sub = forms.Subscribe()
if request.method == 'POST':
sub = forms.Subscribe(request.POST)
subject = 'Welcome to DataFlair'
message = 'Hope you are enjoying your Django Tutorials'
recepient = str(sub['Email'].value())
send_mass_mail(datatuple=(subject, message, EMAIL_HOST_USER,
recepient))
return render(request, 'subscribe/success.html',
{'recepient': recepient})
return render(request, 'subscribe/index.html', {'form': sub})
def send_many_mail(req):
title = '阿里叫你回家'
content1 = '恭喜你获得一瓶老干妈'
email_from = settings.DEFAULT_FROM_EMAIL
recieve1 = [
'*****@*****.**',
]
content2 = 'good！！！'
msg1 = (title, content1, email_from, recieve1)
msg2 = (title, content2, email_from, ['*****@*****.**'])
send_mass_mail((msg1, msg2))
return HttpResponse("ok")
def send_notifications(subscription_type, **kwargs):
logger.debug("sending notification for {0}".format(subscription_type))
context = kwargs or {}
context.update({
'domain': settings.SITE_DOMAIN,
'env': settings.ENVIRONMENT
})
subscribers = Subscription.objects.filter(subscription_type=subscription_type)
subject = render_to_string('subscriptions/email_subject.txt', context).strip()
body = render_to_string('subscriptions/email_body.txt', context).strip()
messages = [(subject, body, settings.DEFAULT_FROM_EMAIL,
[subscriber.user.email]) for subscriber in subscribers]
send_mass_mail(messages, fail_silently=True)
def send_many_email(req):
title = "恭喜你中了一等奖"
msg = '特奖励澧县1日游'
email_from = settings.DEFAULT_FROM_EMAIL
reciever1 = [
'*****@*****.**',
'*****@*****.**'
]
msg1 = (title, msg, email_from, reciever1)
msg2 = (title, msg, email_from, ['*****@*****.**', '*****@*****.**'])
send_mass_mail((msg1, msg2), fail_silently=True)
return HttpResponse("ok")
def edit_handler(sender, **kwargs):
if not kwargs['created'] and 'volunteers' not in kwargs['update_fields']:
event = kwargs['instance']
volunteer_emails = _get_volunteer_emails(event=event)
subject = event.organization.name + " update their " + event.title + " event."
message = "You are receiving this message because you are registered for this event and the organizer has " \
"updated some details about the event. \nPlease find a link to the updated event below.\n\n" \
"\nYour event: https://voluntyr.herokuapp.com/Event/" + str(event.id)
emails = _make_emails(volunteer_emails, settings.DEFAULT_FROM_EMAIL,
subject, message)
send_mass_mail(emails)
def send_actual_email(selected_users, subject, body):
site = Site.objects.get(pk=settings.SITE_ID)
subject_template = Template(subject)
body_template = Template(body)
datatuple = ()
for user in selected_users:
context = Context({'site': site, 'user': user})
datatuple += ((subject_template.render(context),
body_template.render(context),
settings.DEFAULT_FROM_EMAIL, [user.email]), )
print 'Sending mass mail'
send_mass_mail(datatuple)
def contact(request):
if request.method == 'POST':
fname = request.POST.get('fname')
lname = request.POST.get('lname')
address = request.POST.get('address')
subject = request.POST.get('subject')
#send_mail(subject, fname, lname, ['*****@*****.**'], fail_silently=False)
message1 = ('Subject here', fname, '*****@*****.**',
['*****@*****.**'])
message2 = ('Another Subject', lname, '*****@*****.**',
['*****@*****.**'])
send_mass_mail((message1, message2), fail_silently=False)
return render(request, 'website/contact.html')
def notify_on_changes(event):
participant_emails = list(event.participation_set.values_list(
'user__email',
flat=True
))
subject = f'Update information on event {event.title}'
message = f'{event.description}\n'
message += f'{event.title} will be from {localtime(event.start_date)} to {localtime(event.end_date)}\n'
message += f'Location: {event.location}\n'
message += 'Regards,'
datatuple = ((subject, message, settings.EMAIL_HOST_USER, [email])
for email in participant_emails)
send_mass_mail(datatuple)
def send_bulk_mail(subject, body, recipients):
"""
Sends an email with the given subject and body to every recipient in the
set/list of recipients. The emails are send one-by-one (so that no
addresses are "leaked", e.g. by putting all receivers in the "TO: " field).
The sender email address is read from the settings.
"""
message_tuples = [(subject, body, settings.DEFAULT_FROM_EMAIL, [r])
for r in recipients]
send_mass_mail(message_tuples)
def notify(self, subject, message):
from django.core.mail import send_mass_mail
from smtplib import SMTPException
subs = [
user.email for user in self.subscribers.all()
if user.email is not None
]
try:
send_mass_mail(
(subject, message, settings.ISSUES_MAIL_ADDRESS, subs))
except SMTPException as e:
print "Issue Notification: Couldn't send mail because", e
def send_many_email(req):
title = "加油"
content1 = "恭喜帅磊磊喜提高铁一辆"
email_from = settings.DEFAULT_FROM_EMAIL
reciever1 = ['*****@*****.**', '*****@*****.**']
content2 = "皮一下，超好玩的"
#邮件1&2
msg1 = (title, content1, email_from, reciever1)
msg2 = ("小哥哥", content2, email_from,
['*****@*****.**', '*****@*****.**'])
#使用send_mass_mail
send_mass_mail((msg1, msg2), fail_silently=True)
return HttpResponse("ok 666")
def mail_send(request):
# 发送一封邮件
# send_mail(主题， 内容， 从哪发送(发送人账号)， 接受人列表, ...) 前四个必填
# send_mail('邮箱主题', '这是内容<a href="http://127.0.0.1:8000/">返回</a>', '*****@*****.**', ['*****@*****.**'])
# 发送多封邮件
m1 = ('邮箱主题', '1', '*****@*****.**', ['*****@*****.**'])
m2 = ('邮箱主题', '2', '*****@*****.**', ['*****@*****.**'])
m3 = ('邮箱主题', '3', '*****@*****.**', ['*****@*****.**'])
m4 = ('邮箱主题', '4', '*****@*****.**', ['*****@*****.**'])
send_mass_mail((m1, m2, m3, m4))
return HttpResponse('发送成功')
def handle(self, *args, **options):
emails = []
subject = 'Przypomnienie ;)'
date_loan = datetime.date.today() - datetime.timedelta(days=options['days'])
friend_who_have_loaned_books = LoanBook.objects.filter(date__lte=date_loan)
for friend in friend_who_have_loaned_books:
message = f"Cześć {friend.friend_name},\n\n" \
f"mam nadzieję, że książka: {friend.book.title} Ci się podoba. " \
f"Jak tylko skończysz czytać, proszę zwróć ją. Chcę jeszcze do niej kiedyś zajrzeć :)"
emails.append((subject, message, settings.DEFAULT_FROM_EMAIL, [friend.friend_email]))
send_mass_mail(emails)
self.stdout.write(f'Sent {len(emails)} reminders.')
def test_connection_sharing(self):
"""RequestsBackend reuses one requests session when sending multiple messages"""
datatuple = (
('Subject 1', 'Body 1', '*****@*****.**', ['*****@*****.**']),
('Subject 2', 'Body 2', '*****@*****.**', ['*****@*****.**']),
)
mail.send_mass_mail(datatuple)
self.assertEqual(self.mock_request.call_count, 2)
session1 = self.mock_request.call_args_list[0][
0] # arg[0] (self) is session
session2 = self.mock_request.call_args_list[1][0]
self.assertEqual(session1, session2)
self.assertEqual(self.mock_close.call_count, 1)
def request_contact(request, pk):
apartment = get_object_or_404(Apartment, pk=pk)
tenant = User.objects.get(email_address=request.user.email_address)
tenant_email = request.user.email_address
message_to_tenant = ('Request Received', 'Congratulations {}, one of our agents will contact shortly'.format(tenant.first_name), '*****@*****.**', ['{}'.format(tenant_email)])
message_to_agent = ('Request for contact', '{0} is interested in {1}. His mobile number is {2}'.format(tenant.get_full_name(), apartment.title, tenant.profile.mobile_number), '*****@*****.**', ['*****@*****.**'])
datatuple = (
message_to_tenant,
message_to_agent,
)
send_mass_mail(datatuple)
messages.success(request, 'Congratulations, one of our agents will contact shortly')
return redirect('apartments:detail', pk=apartment.pk)
def handle(self, *args, **options):
emails = []
subject = 'Enroll in a course'
date_joined = datetime.date.today() - datetime.timedelta(days=options['days'])
users = User.objects.annotate(course_count=Count('courses_joined')).filter(course_count=0, date_joined__lte=date_joined)
for user in users:
message = 'Dear {},\n\nWe noticed that you didn\'t enroll in any courses yet. What are you waiting for?'.format(user.first_name)
emails.append((subject,
message,
settings.DEFAULT_FROM_EMAIL,
[user.email]))
send_mass_mail(emails)
self.stdout.write('Sent {} reminders'.format(len(emails)))
def on_save_articles(instance, created, **kwargs):
if created:
suivi, created = Suivis.objects.get_or_create(nom_suivi='articles')
titre = "Permacat - nouvel article"
message = " Un nouvel article a été créé " + \
"\n Vous pouvez y accéder en suivant ce lien : https://permacat.herokuapp.com" + instance.get_absolute_url() + \
"\n\n------------------------------------------------------------------------------" \
"\n vous recevez cet email, car vous avez choisi de suivre les articles sur le site http://www.Perma.Cat/forum/articles/"
emails = [suiv.email for suiv in followers(suivi) if instance.auteur != suiv]
try:
send_mass_mail([(titre, message, "*****@*****.**", emails), ])
except:
pass
def test_save_mass_mail_to_db(self):
"""
Test that using send_mass_mail creates multiple Message objects in DB instead, when
EMAIL_BACKEND is set.
"""
self.assertEqual(Message.objects.count(), 0)
with self.settings(EMAIL_BACKEND="mailer.backend.DbBackend"):
message1 = ('Subject ☺', 'Body', '*****@*****.**',
['*****@*****.**'])
message2 = ('Another Subject ☺', 'Body', '*****@*****.**',
['*****@*****.**'])
mail.send_mass_mail((message1, message2))
self.assertEqual(Message.objects.count(), 2)
def notify_comment_tagged_users(user_ids, comment_id):
"""
Notify users about being tagged on comments.
"""
comment = Comment.objects.get(id=comment_id)
users = User.objects.filter(id__in=user_ids)
subject = "You are tagged on a comment"
text = "You are tagged on the following comment:\n\n{}".format(
comment.text)
from_email = "*****@*****.**"
messages = [(subject, text, from_email, [x.email]) for x in users]
mail.send_mass_mail(messages, fail_silently=False)
def review_submit(request):
if request.method == "POST":
r = Review()
r.Name = request.POST.get("Name")
r.Email = request.POST.get("Email")
r.Review = request.POST.get("Review")
try:
image = request.FILES['attachment']
print(image)
r.photo = image
r.save()
try:
message1 = ("New Review by "+r.Name, r.Name+" - "+r.Review+" email-id: "+r.Email,EMAIL_HOST_USER, ["*****@*****.**"])
f= f'Hey Dear {r.Name},\nThanks for your review on my website. I will publish it soon.\nHave a good day:)'
message2 = ("Thanks for Review", f,EMAIL_HOST_USER, [r.Email])
send_mass_mail((message1, message2), fail_silently=False)
except Exception as e:
print('Email sending error: ',e)
try:
msg = EmailMessage(
'New review image',
'this is the image',
'EMAIL_HOST_USER',
['*****@*****.**'],
headers={'Message-ID': 'foo'},
)
msg.content_subtype = "html"
if image:
print('extension',str(r.photo.name).split(".")[-1])
mime_image = MIMEImage(r.photo.read(),_subtype=str(r.photo.name).split(".")[-1])
mime_image.add_header('Content-ID', '<image>')
msg.attach(mime_image)
print('mime image',mime_image)
msg.send()
except:
pass
except Exception as e:
print('image is not given',e)
r.save()
try:
message1 = ("New Review by "+r.Name, r.Name+" - "+r.Review+" email-id: "+r.Email,EMAIL_HOST_USER, ["*****@*****.**"])
f= f'Hey Dear {r.Name},\nThanks for your review on my website. I will publish it soon.\nYou can send your image to show on website on this email: [email protected]\nHave a good day:)'
message2 = ("Thanks for Review", f,EMAIL_HOST_USER, [r.Email])
send_mass_mail((message1, message2), fail_silently=False)
except Exception as e:
print('Email sending error: ',e)
return redirect('/')
else:
return redirect('/')
def add_announcement(request):
if request.method == 'POST':
form = AnnouncementForm(request.POST)
if form.is_valid():
obj = Announcement()
obj.title = form.cleaned_data['title']
obj.target = form.cleaned_data['target']
obj.user = request.user
obj.body = form.cleaned_data['body']
obj.save()
if 'send_emailBoolean' in request.POST:
send_emailBoolean = request.POST['send_emailBoolean']
else:
send_emailBoolean = False
if send_emailBoolean:
truemessage = render_to_string(
'core/announcement_email.html', {
'user':
request.user.first_name + request.user.last_name,
'body': form.cleaned_data['body'],
'target': form.cleaned_data['target']
})
message_list = []
for user in User.objects.all():
if user.email != '':
message_list.append((obj.title, truemessage,
settings.ANN_EMAIL, [user.email]))
send_mass_mail(message_list,
fail_silently=True,
auth_user=settings.ANN_EMAIL)
messages.success(
request,
"Announcement has been successfully posted and users have been notified via email."
)
return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
else:
messages.success(request,
"Announcement has been successfully posted.")
return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
else:
error_string = "Announcement was not successfully posted, because of the following errors: "
for field in form:
for error in field.errors:
error_string += error + ' '
messages.error(request, error_string)
return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
def contact(request):
name = (request.POST.get('fname', ' '))
email = (request.POST.get('eid', ' '))
query = (request.POST.get('query', ' '))
suggest = (request.POST.get('suggest', ' '))
myth = (request.POST.get('myth', ' '))
if email == " " and name == " " and query == " " and suggest == " " and myth == " ":
email, name, query, suggest, myth = 0, 0, 0, 0, 0
else:
li = 'email: '+email + "\n"+"name: "+name+"\n"+"query: " + \
query+"\n"+'suggestion: '+suggest+"\n"+"myth: "+myth
text = name + ', thank you for showing your interest.Soon we will catch you.You can visit our instagram page fight against corona.This message is only for verification of your email id.Our team request you to stay at home and stay safe.'
print(
name,
email,
query,
suggest,
myth,
)
if len(name) >= 3 and name[0].isupper() == True and (
query) == "" or len(query) >= 5 and (suggest) == "" or len(
suggest) >= 5 and myth == "" or len(myth) >= 5:
print("hello")
message1 = (
'This data is coming from user end',
li,
settings.EMAIL_HOST_USER,
[
'*****@*****.**', '*****@*****.**',
'*****@*****.**'
],
)
message2 = ('Check mail from covaidwarriors.com', text,
settings.EMAIL_HOST_USER, [email])
send_mass_mail((message1, message2), fail_silently=False)
print(message1, message2)
messages.success(
request,
" BOOYAH! Your data has been submitted successfully.Soon we will contact you at your given email id."
)
else:
messages.error(
request,
"Please fill the field correctly.Hover each field to see the format of a field."
)
return render(request, 'corona/contact.html')
def result_notification_send(request, status):
if request.method != "POST":
return HttpResponseNotAllowed(["POST"])
if not request.user.has_perm("reviews.can_manage"):
return access_not_permitted(request)
fields = ["submission_pks", "from_address", "subject", "body"]
if not all([k in request.POST for k in fields]):
return HttpResponseBadRequest()
try:
submission_pks = [int(pk) for pk in request.POST["submission_pks"].split(",")]
except ValueError:
return HttpResponseBadRequest()
submissions = SubmissionBase.objects.filter(
result__status=status,
)
submissions = submissions.filter(pk__in=submission_pks)
submissions = submissions.select_related("result")
submissions = submissions.select_subclasses()
notification_template_pk = request.POST.get("notification_template", "")
if notification_template_pk:
notification_template = NotificationTemplate.objects.get(
pk=notification_template_pk
)
else:
notification_template = None
emails = []
for submission in submissions:
rn = ResultNotification()
rn.submission = submission
rn.template = notification_template
rn.to_address = submission.submitter.email
rn.from_address = request.POST["from_address"]
rn.subject = request.POST["subject"]
rn.body = Template(request.POST["body"]).render(
Context({
"submission": submission.notification_email_context()
})
)
rn.save()
emails.append(rn.email_args)
send_mass_mail(emails)
return redirect("pinax_submissions:result_notification", status=status)
def task_send_email():
"""
Sends email notifications about tasks deadlines every day
"""
messages_list = []
for task in Task.objects.all():
if task.developer and task.status != 'Done':
messages_list.append(
('Task deadline is coming!',
'{} days left until {} deadline!'.format(
task.due_date - datetime.datetime.today(), Task.title),
settings.EMAIL_HOST_USER, Task.developer.email))
send_mass_mail(tuple(messages_list))
logger.info("Sent email to ")
def handle(self, *args, **options):
letter_list = Letter.objects.filter(destination_time__lte=timezone.now(),
email_sent='not sent')
email_list = []
for letter in letter_list:
email_list.append((letter.subject,
letter.message,
letter.user.email,
[letter.user.email]))
letter.email_sent = 'sent'
letter.save()
send_mass_mail(email_list, fail_silently=False)
