def create(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
creator = request.data["user"]
book = request.data["book"]
is_seller = request.data["is_seller"]
try:
deal = Deal.objects.filter(book=book).exclude(
is_seller=is_seller)[0]
dealer = deal.user
Deal.objects.get(pk=deal.id).delete()
send_mail('email/deal.tpl', {
'user': creator,
'other_user': dealer,
'book': book
}, '*****@*****.**', [creator])
send_mail('email/deal.tpl', {
'user': dealer,
'other_user': creator,
'book': book
}, '*****@*****.**', [dealer])
return Response({"user": dealer.email},
status=status.HTTP_202_ACCEPTED)
except IndexError:
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return Response(serializer.data,
status=status.HTTP_201_CREATED,
headers=headers)
def user_signed_up_custom(request, user, **kwargs):
from_email = 'PyCon Korea <*****@*****.**>'
email = user.email
if not email:
return
send_mail('mail/welcome.html', {'user': user},
from_email, [email], fail_silently=True)
def send_visitor_checkout_email(visit_instance: Visit):
"""
Function to send email to visitor of a Visit on Check-out,
informing about details of Visitor and Visit
:param visit_instance: an instance of Visit, being checked-out
:return: None
"""
visitor = visit_instance.visitor
host = visit_instance.host
email_subject = f"Visit Details | {host}"
visitor_email = [visitor.email]
visit_data = {
'Host': str(host),
'Email': host.email,
'Phone': host.phone_number,
'Check-In Time': visit_instance.in_time,
'Check-Out Time': visit_instance.out_time,
'Address': str(host.office_branch),
}
if visit_instance.purpose:
visit_data['Purpose'] = visit_instance.purpose
send_mail(template_name='mailing/visitor_checkout_email.html',
context={
'email_subject': email_subject,
'visit_data': visit_data
},
from_email=settings.EMAIL_HOST,
recipient_list=visitor_email)
def StudentFormView(request):
form = StudentForm()
messages.info(request, 'Select 4 different problem statements')
if request.method == 'POST':
form = StudentForm(request.POST)
if form.is_valid():
instance = form.save(commit=False)
instance.problem_statement_1 = form.cleaned_data[
'problem_statement_1']
instance.problem_statement_2 = form.cleaned_data[
'problem_statement_2']
instance.problem_statement_3 = form.cleaned_data[
'problem_statement_3']
instance.problem_statement_4 = form.cleaned_data[
'problem_statement_4']
email_address = form.cleaned_data['team_leader_email']
send_mail('email/confirmation.tpl',
{'team_leader': form.cleaned_data['team_leader_name']},
'*****@*****.**', [
email_address,
])
messages.success(
request,
'You Have Successfully filled form. We have sent you one email about further details.'
)
instance.save()
return redirect('index')
return render(request, 'main/form.html', {'form': form})
def send_host_checkin_email(visit_instance: Visit):
"""
Function to send email to Host of a Visit on Check-In,
informing about the Visitor Details
:param visit_instance: an instance of Visit, being checked-in
:return: None
"""
visitor = visit_instance.visitor
host = visit_instance.host
in_time = visit_instance.in_time
purpose = visit_instance.purpose
host_email = [host.email]
visitor_name = str(visitor)
visitor_email = visitor.email
visitor_phone = visitor.phone_number
email_subject = f'Visitor Details | {visitor_name}'
visitor_data = {
'Visitor': visitor_name,
'Email': visitor_email,
'Phone': visitor_phone,
'Check-In Time': in_time,
}
if purpose:
visitor_data['Purpose'] = purpose
send_mail(template_name='mailing/host_checkin_email.html',
context={
'email_subject': email_subject,
'visitor_data': visitor_data,
},
from_email=settings.EMAIL_HOST,
recipient_list=host_email)
def send_email(self, template, data):
connections = UserConnectionField.objects.find_emails_connection_by_user(
self.user)
for connection in connections:
email = connection.value
send_mail(template, data, settings.EMAIL_FROM, [email])
def send_email_with_connection(self, template, data, email):
for iteration in range(len(settings.EMAIL_CONNACTIONS) - 1):
try:
smtp_connection = get_connection(
host=settings.EMAIL_CONNACTIONS[iteration].get(
'EMAIL_HOST'),
port=settings.EMAIL_CONNACTIONS[iteration].get(
'EMAIL_PORT'),
username=settings.EMAIL_CONNACTIONS[iteration].get(
'EMAIL_HOST_USER'),
password=settings.EMAIL_CONNACTIONS[iteration].get(
'EMAIL_HOST_PASSWORD'),
use_tls=settings.EMAIL_CONNACTIONS[iteration].get(
'EMAIL_USE_TLS'),
use_ssl=settings.EMAIL_CONNACTIONS[iteration].get(
'EMAIL_USE_SSL'),
)
send_mail(
template,
data,
settings.EMAIL_CONNACTIONS[iteration].get('EMAIL_FROM'),
[email],
connection=smtp_connection)
break
except:
pass
def instamojo_response(request):
user = request.user
payment_id = request.GET.get('payment_id')
payment_request_id = request.GET.get('payment_request_id')
api_key = settings.API_KEY
auth_token = settings.AUTH_TOKEN
api = Instamojo(api_key=api_key,auth_token=auth_token)
response = api.payment_request_payment_status(payment_request_id,payment_id)
if response['payment_request']['status'] == "Completed":
paid_amount = response['payment_request']['payment']['amount']
order = Order.objects.get(pk=payment_request_id)
if order.amount == float(paid_amount) and order.order_id == payment_request_id:
order.tracking_id = response['payment_request']['payment']['payment_id']
order.save()
cart_itmes = CourseEnrollment.objects.filter(order=order)
for item in cart_itmes:
setattr(item,'course_enrolled',True)
item.save()
send_mail('emails/checkout_success.html', {'user': item.owner_of_item(), 'item': item.course.course_name },
'*****@*****.**', [item.owner_of_item().email])
send_mail('emails/notify_mentor.html',
{'user': item.owner_of_item(), 'mentor':item.course.course_user.user_first_name, 'item': item.course.course_name },
'*****@*****.**', [item.course.course_user.email, '*****@*****.**'])
return render_to_response('portal/cart/checkout_result.html', {'success': 'success'})
else:
return render_to_response('portal/cart/checkout_result.html', {'failure': 'failure'})
else:
return render_to_response('portal/cart/checkout_result.html', {'failure': 'fail'})
def post(self, request, branch_code):
reservation = Reservation()
reservation.branch = Branch.objects.get(code=branch_code)
reservation.first_name = request.POST.get('first-name')
reservation.last_name = request.POST.get('last-name')
reservation.email = request.POST.get('email')
reservation.special_request = request.POST.get('special-request')
reservation.date = request.POST.get('date')
reservation.time = request.POST.get('time')
reservation.persons = int(request.POST.get('persons'))
reservation.save()
context = {
'reservation':
reservation,
'url':
request.build_absolute_uri(
reverse('acknowledge-reservation', args=[reservation.id]))
}
send_mail(
'reservation-mail.html',
context,
'*****@*****.**', # from
[reservation.branch.admin_email] # to
)
return redirect('reservation-complete', reservation.id)
def do_login(request):
msg =''
usuarioInfo = User.objects.all()
if request.method == 'POST':
user = authenticate(username=request.POST.get('username'), password=request.POST.get('password'))
email= request.POST.get('email')
if email is not None:
usuarioInfo = usuarioInfo.filter(email=email)
if len(usuarioInfo) > 0:
u = User.objects.get(email__exact=email)
password = User.objects.make_random_password()
u.set_password(password)
u.save()
send_mail('registration/email_rec_senha.tpl', {'senha':password, }, '*****@*****.**', [email])
msg = 'A nova senha foi enviada com sucesso para o e-mail cadastrado! Verifique seu lixo eletrônico.'
elif user is not None:
print('entrou loagr')
login(request, user)
return redirect('/index')
else:
msg = 'Usuário ou senha inválidos!'
return render(request,'registration/login.html',{'msg': msg} )
def form_valid(self, form):
"""Additional steps after form is validated.
Args:
form (Form): The valid form object.
"""
study = Study.objects.get(
pk=self.kwargs.get('pk'),
)
group = study.get_next_group()
# Create study registration object
registration = StudyRegistration.objects.create(
study_group=group,
user=self.request.user,
send_study_results=form.cleaned_data.get('send_study_results', False)
)
send_mail(
'research/email/consent_confirm.tpl',
{
'user': self.request.user,
'study': study,
'form': form,
'registration': registration,
},
settings.DEFAULT_FROM_EMAIL,
[self.request.user.email],
)
messages.success(
self.request,
'You are successfully enrolled into this study. You have been emailed a copy of your signed consent form.'.format(study.title) # noqa: E501
)
return redirect(study)
def serve(self, request):
if request.method == 'POST':
# create a form instance and populate it with data from the request:
form = IndustrialDevelopmentFundForm(request.POST)
idfund = {}
# check whether it's valid:
if form.is_valid():
idfund['idfund_invest_doamin'] = form.cleaned_data[
'idfund_invest_doamin']
idfund['idfund_company_name'] = form.cleaned_data[
'idfund_company_name']
idfund['idfund_contact_name'] = form.cleaned_data[
'idfund_contact_name']
idfund['idfund_contact_phone'] = form.cleaned_data[
'idfund_contact_phone']
idfund['idfund_contact_email'] = form.cleaned_data[
'idfund_contact_email']
idfund['idfund_project_demand'] = form.cleaned_data[
'idfund_project_demand']
send_mail('news/mail_template.html', {'idfund': idfund},
'*****@*****.**', ['*****@*****.**'])
result = True
else:
result = False
# if a GET (or any other method) we'll create a blank form
else:
form = IndustrialDevelopmentFundForm()
return render(request,
'news/industrial_development_fund_column_page.html',
self.get_context(request))
return HttpResponse(json.dumps({'result': result}),
content_type='application/json')
def handle(self, **options):
minutes = int(options.get('since'))
test = bool(options.get('test'))
dry = bool(options.get('dry'))
verbose = bool(options.get('verbose'))
notify = bool(options.get('notify'))
# Get New Users
today = datetime.datetime.now()
minutes = datetime.timedelta(minutes=minutes)
begin = today - minutes
if not test:
new_users = User.objects.filter(date_joined__range=(begin, today)).order_by('-date_joined')
else:
new_users = User.objects.all().order_by('date_joined')
new_users = [new_users[0]]
for user in new_users:
if verbose:
print "Welcoming " + str(user.username) + ' (' + str(user.email) + ').'
if not dry:
try:
send_mail( "email/welcome.tpl",
{'user': user},
from_email=settings.WELCOME_FROM_EMAIL,
recipient_list=[user.email],
fail_silently=False,
auth_user=None,
auth_password=None
)
except Exception, e:
print e
def form_valid(self, form):
"""If the form is valid, save the associated model."""
# self.object = form.save(commit=False)
self.object = form.save(commit=False)
email = form.cleaned_data['email']
first_name = form.cleaned_data['first_name']
last_name = form.cleaned_data['last_name']
user_type = form.cleaned_data['user_type']
settingssite = Configuracion.objects.get(id=1)
current_site = Site.objects.get_current()
user, password = User.get_or_register(email, first_name, last_name,
user_type)
if user:
send_mail(
'email/email_data_register.html',
{
'user': user,
'password': password,
'settingssite': settingssite,
'current_site': current_site.domain,
},
settings.DEFAULT_FROM_EMAIL,
[user],
)
return super(UserNewView, self).form_valid(form)
else:
return self.form_invalid(form)
def send_test_mail(modeladmin, request, queryset):
from_email = 'PyCon Korea <*****@*****.**>'
for obj in queryset:
email = obj.email
if not email:
continue
print(f'sent {email}')
send_mail('mail/test.html', {'user': obj}, from_email, [email])
def form_valid(self, form):
self.object = form.save()
email = "*****@*****.**"
send_mail('emails/activo.tpl', {
'nombre': 'jose luis',
'edad': 35
}, EMAIL_HOST_USER, [email])
return super().form_valid(form)
def request_page(self, request):
redir = request.query_params.get('redirect', None)
email = request.query_params.get('email', None)
key = Key.objects.get(email=email)
send_mail('email/key.tpl', {
'key': key,
'site_title': config('SITE_TITLE')
}, config('DEFAULT_FROM_EMAIL'), [key.email])
messages.add_message(request, messages.INFO, 'Email Sent')
return redirect(redir)
def send_mail_template(template,parameters,to_email):
pre_user = PreUser.objects.get(email=parameters['email'])
try:
send_mail(template, parameters, DEFAULT_FROM_EMAIL, to_email)
except:
pre_user.mail_send = False
else:
pre_user.mail_send = True
pre_user.save()
return "Ok"
def app_send_email_invitate(email, request, title, template, args):
data = {
'domain': request,
'site_name': 'AgesProt',
'protocol': 'http://',
'subject': title,
'args': args
}
email_template_name = template
send_mail(email_template_name, data, settings.DEFAULT_FROM_EMAIL, [email])
def form_valid(self, form):
form.save()
send_mail('emails/solution_created.html', {
'solution_name': form.instance.solution_name,
'solution_platform': form.instance.solution_platform,
'solution_contact': form.instance.solution_contact_phone,
'solution_deadline': form.instance.solution_deadline,
'solution_budget': form.instance.solution_budget ,
'solution_description': form.instance.solution_description
}, '*****@*****.**', [form.instance.solution_contact_email, '*****@*****.**'])
return FormView.form_valid(self, form)
def test_email(request):
form = Email()
if request.method == 'POST':
form = Email(request.POST)
if form.is_valid():
to = form.cleaned_data['email_id']
send_mail('email/confirmation.tpl', {'team_leader': 'Ravi'},
'*****@*****.**', [
to,
])
return render(request, 'main/email.html', {'form': form})
def get_cart(request):
context = {}
context.update(csrf(request))
if 'cart' in request.session:
product_list = list(request.session['cart'].keys())
product_list = Product.objects.filter(
pk__in=product_list).prefetch_related(
'photo_set',
'price_set__buyer_type',
'price_set__product',
)
context['product_list'] = product_list
if request.POST and 'method' in request.POST:
if 'clear_cart' == request.POST['method']:
request.session.pop('cart')
if 'make_an_order' == request.POST['method']:
if 'delivery' in request.POST and request.POST['delivery']:
delivery = request.POST['delivery']
else:
delivery = ''
if 'legal_entity' in request.POST and request.POST['legal_entity']:
legal_entity = LegalEntity.objects.get(
pk=int(request.POST['legal_entity']))
else:
legal_entity = None
receipt = Receipt(buyer=request.user,
delivery=delivery,
legal_entity=legal_entity)
receipt.save()
Order.objects.bulk_create([
Order(
quantity=v,
product=Product.objects.get(pk=k),
receipt=receipt,
) for k, v in request.session['cart'].items()
])
receipt.save()
request.session.pop('cart')
context = {'buyer': receipt.buyer, 'receipt': receipt}
recipient_list = []
for email in [receipt.buyer.seller.email]:
if email:
recipient_list.append(email)
send_mail('shop/receipt_email.html',
context,
from_email='*****@*****.**',
recipient_list=recipient_list)
send_sms(recipient=receipt.buyer.seller.phone,
text='Поступил заказ от клиента')
return redirect(reverse('buyer_receipt', kwargs={'pk':
receipt.pk}))
return render(request, 'shop/cart.html', context)
def test_send_email(self):
""" test we can send an email """
send_mail('test_message.email', {'context_var': "1"}, "from_email", ["to_email"])
self.assertEqual(len(mail.outbox), 1)
email = mail.outbox[0]
#now check the details are correct
self.assertEqual(email.to[0], "to_email")
self.assertEqual(email.from_email, "from_email")
self.assertEqual(email.subject, "Test Message")
self.assertEqual(email.template_name, "test_message.email")
self.assertEqual(email.body, "Test Message Body")
self.assertEqual(email.message().get_content_type(), "multipart/alternative")
self.assertIn("<p>Test Message HTML</p>", email.message().as_string())
def app_send_email(user, request, title, template, args):
data = {
'email': user.email,
'domain': request,
'site_name': 'AgesProt',
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'user': user,
'token': default_token_generator.make_token(user),
'protocol': 'http://',
'subject': title,
'args': args
}
email_template_name = template
send_mail(email_template_name, data, settings.DEFAULT_FROM_EMAIL, [user.email])
def send_host_signup_email(host_email, signup_form_link):
"""
Function to send mail to a person, enabling them to sign-up for a Host role.
:param host_email: Email of person intended to be created host
:param signup_form_link: Full Unique Link for the intended user
:return: None
"""
send_mail(template_name='mailing/host_sign_up_mail.html',
context={
'email_subject': 'Host | Registration Link',
'form_link': signup_form_link,
},
from_email=settings.EMAIL_HOST,
recipient_list=[host_email])
def re_send_mail():
pre_users = PreUser.objects.filter(mail_send=False).order_by('-id')
if pre_users.count() != 0:
pre_user = pre_users[0]
try:
send_mail('email/confirmation.tpl', {'email': pre_user.email,'username':pre_user.username,'fullname':pre_user.fullname,'code':pre_user.code,'password':pre_user.password}, DEFAULT_FROM_EMAIL ,[pre_user.email])
except:
pre_user.mail_send = False
mensaje = "error"
else:
pre_user.mail_send = True
mensaje = "enviado"
pre_user.save()
else:
mensaje = "no hay pre usuarios"
return mensaje
def save(self, *args, **kwargs):
post_obj = self
if post_obj.__class__.objects.filter(id=post_obj.id).exists():
pre_obj = post_obj.__class__.objects.get(id=post_obj.id)
# автоснятие заявки оптовика при установке типа покупателя
if pre_obj.wholesale_buyer_request == True and post_obj.buyer_type != None:
post_obj.wholesale_buyer_request = False
if post_obj.wholesale_buyer_request == True:
context = {'buyer': self}
from_email = '*****@*****.**'
recipient_list = []
for email in ['*****@*****.**']:
if email:
recipient_list.append(email)
send_mail('users/new_wholesale_buyer_email.html', context, from_email, recipient_list=recipient_list)
super(User, self).save(*args, **kwargs)
def send_email_task(template, email, request, subject, args):
data = {
'domain': request,
'protocol': 'http://',
'subject': subject,
'args': args
}
return send_mail(template, data, settings.EMAIL_HOST_USER, [email])
def send_email_task(template, email, request, subject, args):
data = {
'domain': request,
'protocol': 'http://',
'subject': subject,
'args': args
}
return send_mail(template, data, settings.EMAIL_HOST_USER, [email])
def send_password_reset_mail(user, template_name="email/password_reset_mail.tpl"):
ctx = {"user": user, "token": get_token_for_password_reset(user)}
return send_mail(
from_email=settings.DEFAULT_FROM_EMAIL,
recipient_list=[user.email],
template_name=template_name,
context=ctx,
)
def send_password_reset_mail(user, template_name='email/password_reset_mail.tpl'):
ctx = {
'user': user,
'token': get_token_for_password_reset(user),
}
return send_mail(from_email=settings.DEFAULT_FROM_EMAIL,
recipient_list=[user.email],
template_name=template_name,
context=ctx)
def send_password_reset_mail(user, template_name="email/password_reset_mail.tpl"):
ctx = {"user": user, "token": get_token_for_password_reset(user)}
return send_mail(
from_email=settings.DEFAULT_FROM_EMAIL,
recipient_list=[user.email],
template_name=template_name,
context=ctx,
)
def send_password_reset_mail(user, template_name='email/password_reset_mail.tpl'):
ctx = {
'user': user,
'token': get_token_for_password_reset(user),
}
return send_mail(from_email=settings.DEFAULT_FROM_EMAIL,
recipient_list=[user.email],
template_name=template_name,
context=ctx)
def order_confirmation(request, fkid):
tax = Tax.objects.get(pk=1)
invoice = Invoice.objects.get(pk=fkid)
shipping = Shipping_Cost.objects.get(pk=1)
invoice_details = InvoiceDetails.objects.filter(invoice_id=fkid)
total = 0
for invoice_detail in invoice_details:
total += invoice_detail.sub_amount
tax_amount = total * (tax.tax_rate_in_percentage / 100)
user = request.user
send_mail(
'bill.tpl', {
'user': user,
'invoice_details': invoice_details,
'tax': tax,
'tax_amount': tax_amount,
'shipping': shipping,
'invoice': invoice
}, settings.EMAIL_HOST_USER, [user.email])
def checkout_items(request):
user = request.user
total_cost = 0
for item_order in request.POST.getlist('order'):
item = CourseEnrollment.objects.get(pk=item_order)
total_cost = total_cost + item.course.course_fees
if total_cost > 0:
api_key = settings.API_KEY
auth_token = settings.AUTH_TOKEN
api = Instamojo(api_key=api_key,auth_token=auth_token)
api_request = api.payment_request_create(
purpose="ThinkFOSS transaction",
send_email=True,
email=user.email,
amount=total_cost,
redirect_url="http://www.thinkfoss.com/register/user/portal/student/instamojoresponse/"
)
order_id = api_request['payment_request']['id']
current_order = Order.objects.start_checkout(order_id, total_cost, user)
for item_order in request.POST.getlist('order'):
item = CourseEnrollment.objects.get(pk=item_order)
item.order = current_order
item.save()
return redirect(api_request['payment_request']['longurl'])
else:
# Free course
for item_order in request.POST.getlist('order'):
item = CourseEnrollment.objects.get(pk=item_order)
setattr(item,'course_enrolled',True)
item.save()
send_mail('emails/checkout_success.html', {'user': request.user, 'item': item.course.course_name },
'*****@*****.**', [user.email])
send_mail('emails/notify_mentor.html',
{'user': request.user, 'mentor':item.course.course_user.user_first_name , 'item': item.course.course_name },
'*****@*****.**', [item.course.course_user.email, '*****@*****.**'])
return render_to_response('portal/cart/checkout_result.html', {'success': 'success'})
def send_email_task(subject, message, from_mail, to_mail, template):
from_email = from_mail
user_mail = to_mail
context_dict = {
'title': subject,
'message': message,
}
send_mail(template, context_dict, from_email, [user_mail])
# email_sending/tmplates/email_sending/email_2.html
# mail = send_mail(
# subject=subject,
# message=message,
# from_email=from_mail,
# recipient_list=[to_mail]
# )
# if mail == 1:
# logger.info(f'\nMail sent!\nSUBJECT: {subject}\nMESSAGE: {message}\nSENDER: {from_mail}\nRECIVER: {to_mail}')
return None
def post(self, request, reservation_id):
reservation = Reservation.objects.get(pk=reservation_id)
reservation.status = request.POST.get('status')
reservation.save()
language = request.POST.get('language')
if language:
translation.activate(language)
request.session[translation.LANGUAGE_SESSION_KEY] = \
language
context = {
'reservation': reservation,
}
send_mail(
'acknowledge-email.html',
context,
'*****@*****.**', # from
[reservation.email] # to
)
return redirect('home')
def transition_view(self, request, object_id, extra_context=None):
"""
Transition a project through its lifecycle. Raise 403 forbidden if
it is not possible to perform this action (lack of permission,
transition not allowed).
"""
model = self.model
opts = model._meta
obj = self.get_object(request, unquote(object_id))
tx = request.GET.get('transition')
# Does the thing exist
if obj is None:
raise Http404(_('%(name)s object with primary key %(key)r does '
'not exist.') % {
'name': force_text(opts.verbose_name),
'key': escape(object_id)})
# Is current user allowed to do the stuff with the thing
# Should we use django_fsm.can_proceed instead?
if tx not in [t.name for t in
obj.get_available_user_status_transitions(request.user)]:
print("Requested transition '{0}' not available for the "
"current user {1}".format(tx, request.user))
raise PermissionDenied
t = [t for t in obj.get_available_user_status_transitions(request.user)
if t.name == tx][0]
# Who should get notified about this tx?
recipients = obj.get_users_to_notify(t.target)
recipients_text = ", ".join([r.fullname for r in recipients])
explanation = t.custom["explanation"].format(recipients_text)
# recipients.discard(request.user)
context = dict(
instigator=request.user,
object_name=force_text(obj),
title=t.custom["verbose"],
recipients=recipients_text,
explanation=explanation,
notify_default=t.custom["notify"],
breadcrumbs=self.get_breadcrumbs(request, obj),
model_name=capfirst(force_text(opts.verbose_name_plural)),
object=obj,
opts=opts,)
context.update(extra_context or {})
# User clicks "confirm" on transition.html
if request.method == 'POST':
# run transition, save changed object to db
getattr(obj, t.name)()
obj.save()
# Send email notifications if requested
do_notify = ('_notify' in request.POST) and (
request.POST.get('_notify') == u'on')
tmpl = 'email/email_base.tpl'
to_emails = [u.email for u in recipients]
from_email = settings.DEFAULT_FROM_EMAIL
if do_notify:
send_mail(tmpl, context, from_email, to_emails)
# Redirect the user back to the document change page
redirect_url = reverse('admin:%s_%s_change' %
(opts.app_label, opts.model_name),
args=(object_id,),
current_app=self.admin_site.name)
return HttpResponseRedirect(redirect_url)
return TemplateResponse(request, [
"admin/%s/%s/%s_transition.html" % (
opts.app_label, opts.model_name, t.name),
"admin/%s/%s/transition.html" % (opts.app_label, opts.model_name),
"admin/%s/%s_transition.html" % (opts.app_label, t.name),
"admin/%s/transition.html" % opts.app_label
], context, current_app=self.admin_site.name)
def save(self):
if self.approved:
old_status = Course.objects.get(pk=self.course_id)
if old_status.approved == False and self.approved == True:
send_mail('emails/course_approved.html', {'user': self.course_user, 'course': self.course_name }, '*****@*****.**', [self.course_user.email, '*****@*****.**'])
super(Course, self).save()
def form_valid(self, form):
form.instance.course_user = self.request.user
form.save(commit=True)
send_mail('emails/course_created.html', {'user': self.request.user, 'course': form.instance.course_name },
'*****@*****.**', [self.request.user.email,'*****@*****.**'])
return FormView.form_valid(self, form)
def send_mail_templated(template,dictionary,from_email,list_to_email):
send_mail(template, dictionary, from_email, list_to_email)
return 'Email send'
def send_submission_email(resource):
send_mail('emails/submission_received.tpl', {},
'*****@*****.**', [resource.email]
)
