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