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_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] )