def save(self, request, **kwargs): email = self.cleaned_data["email"] token_generator = kwargs.get("token_generator", default_token_generator) for user in self.users: temp_key = token_generator.make_token(user) # save it to the password reset model # password_reset = PasswordReset(user=user, temp_key=temp_key) # password_reset.save() current_site = get_current_site() # send the password reset email path = reverse("account_reset_password_from_key", kwargs=dict(uidb36=user_pk_to_url_str(user), key=temp_key)) url = build_absolute_uri( request, path, protocol=app_settings.DEFAULT_HTTP_PROTOCOL) context = {"site": current_site, "user": user, "password_reset_url": url} if app_settings.AUTHENTICATION_METHOD \ != AuthenticationMethod.EMAIL: context['username'] = user_username(user) send_db_mail('password-reset', email, context) return self.cleaned_data["email"]
def send_by_dbmail(request): if request.method == 'POST': kwargs = dict() for f in allowed_fields: if request.POST.get(f): kwargs[f] = request.POST.get(f) api_key = kwargs.get('api_key') if api_key: del kwargs['api_key'] if not cache.get(api_key): get_object_or_404( ApiKey, api_key=api_key, is_active=True) cache.set(api_key, 1, timeout=None) args = [] if request.POST.get('data'): args = [json.loads(request.POST['data'])] if kwargs.get('slug') and kwargs.get('recipient'): send_db_mail( kwargs.pop('slug'), kwargs.pop('recipient'), *args, **kwargs) return HttpResponse('OK') raise Http404
def check_model(sender, instance, created, **kwargs): user = User.objects.get(pk=1) field_value_time = str( datetime.now().date().strftime("%d/%m/%y")) + " " + str( datetime.now().time().strftime("%H:%M")) obj = ArticleRevision.objects.all()[len(ArticleRevision.objects.all()) - 1] field_name = 'title' field_value_name = getattr(obj, field_name) field_name = 'content' field_value_content = getattr(obj, field_name) field_name = 'user' field_value_user = getattr(obj, field_name) count = 0 articles = ArticleRevision.objects.all() for article in articles: if field_value_name == getattr(article, 'title'): count += 1 user_mails = User.objects.all() if count > 1: MailTemplate.objects.create( name="The Article was changed", subject="The Article was changed in " + str(datetime.now().time().strftime("%H:%M")), message="The Article '" + str(field_value_name) + "' was changed by " + str(field_value_user) + " in " + str(field_value_time) + ". Now content of the '" + str(field_value_name) + "' is " + str(field_value_content), slug="The Article was changed in " + str(datetime.now().date().strftime("%d/%m/%y")) + " " + str(datetime.now().time().strftime("%H:%M")), is_html=False, ) for users in user_mails: send_db_mail("TheArticlewaschangedin" + str(datetime.now().date().strftime("%d%m%y")) + "" + str(datetime.now().time().strftime("%H%M")), users.email, use_celery=False) else: MailTemplate.objects.create( name="The Article was created", subject="The Article was created in " + str(datetime.now().time().strftime("%H:%M")), message="The Article '" + str(field_value_name) + "' was created by " + str(field_value_user) + " in " + str(field_value_time) + ". The content of the '" + str(field_value_name) + "' is " + str(field_value_content), slug="The Article was created in " + str(datetime.now().date().strftime("%d/%m/%y")) + " " + str(datetime.now().time().strftime("%H:%M")), is_html=False, ) for users in user_mails: send_db_mail("TheArticlewascreatedin" + str(datetime.now().date().strftime("%d%m%y")) + "" + str(datetime.now().time().strftime("%H%M")), users.email, use_celery=False)
def send_mail(self): from dbmail import send_db_mail email_list = self.get_email_list() if email_list and not self.signal.is_sent(self.pk): send_db_mail( self.signal.template.slug, email_list, self.site, self.kwargs, self.instance, **self.get_interval() ) self.signal.mark_as_sent(self.pk)
def send_mail(self): from dbmail import send_db_mail email_list = self.get_email_list() if email_list and not self.signal.is_sent(self.pk): send_db_mail( self.signal.template.slug, email_list, self.site, self.kwargs, self.instance, queue=SIGNALS_MAIL_QUEUE, **self.get_interval() ) self.signal.mark_as_sent(self.pk)
def send_mail(slug, to, context): domain = context.get('domain') or getattr(settings, 'DOMAIN', '') protocol = context.get('protocol') or getattr(settings, 'PROTOCOL', 'http') site_name = context.get('site_name') or getattr(settings, 'SITE_NAME', '') common_context = { 'domain': domain, 'protocol': protocol, 'site_name': site_name, } common_context.update(context) send_db_mail(slug, to, common_context, use_celery=False)
def send_mail(self): from dbmail import send_db_mail email_list = self.get_email_list() if email_list and not self.signal.is_sent(self.pk): for email in email_list.split(","): email = email.strip() if email: send_db_mail( self.signal.template.slug, email, self.site, self.kwargs, self.instance, queue=SIGNALS_MAIL_QUEUE, **self.get_interval() ) self.signal.mark_as_sent(self.pk)
def offer_change_hook(sender, instance, **kwargs): """Update Statistics based on vendor's wares count and value.""" prev_stats = Statistics.objects.current(instance.vendor) new_stats = Statistics.objects.create(instance.vendor, save=False) if new_stats == prev_stats: return new_stats.save() if prev_stats.tariff != new_stats.tariff: send_db_mail( 'tariff-changed', instance.vendor.user.email, { 'tariff': new_stats.tariff, 'discounts': Discount.objects.filter(vendor=instance.vendor, usages__gt=0) })
def verify_email(user, verification_code): if not settings.SKIP_SENDING_EMAIL: try: app_name = "Orchid Roots" send_db_mail( 'verify-mail', user.email, { 'app_name': app_name, 'fullname': user.fullname, 'verification_code': verification_code, }, ) except Exception as e: print(str(e))
def forget_password_email(user, forget_pass_code): if not settings.SKIP_SENDING_EMAIL: try: app_name = "Orchid Roots" send_db_mail( 'reset-passcode', user.email, { 'app_name': app_name, 'fullname': user.fullname, 'forget_pass_code': forget_pass_code, }, user=user, ) except Exception as e: print(str(e))
def send_test_msg(pk, email, user=None, use_celery=True): template = MailTemplate.objects.get(pk=pk) slug = template.slug var_list = re.findall('\{\{\s?(\w+)\s?\}\}', template.message) context = {} for var in var_list: context[var] = '%s' % var.upper().replace('_', '-') return send_db_mail(slug, email, user, context, use_celery=use_celery)
def verify_email(user, verification_url): try: app_name = 'Laowai Panda' request = CrequestMiddleware.get_request() base_url = ("{0}://{1}").format(request.scheme , request._get_raw_host()) send_db_mail( 'verify-mail', user.email, { 'base_url':base_url, 'app_name': app_name, 'verification_url': verification_url, }, user = user, ) except: pass
def send_temp_password_email(user, temp_code): try: app_name = 'Laowai Panda' request = CrequestMiddleware.get_request() base_url = ("{0}://{1}").format(request.scheme , request._get_raw_host()) send_db_mail( 'reset-passcode', user.email, { 'app_name':app_name, 'base_url':base_url, 'temp_code': temp_code, }, user = user, ) except: pass
def send_report_question(reporter_user, question_url): try: app_name = 'Laowai Panda' request = CrequestMiddleware.get_request() base_url = ("{0}://{1}").format(request.scheme , request._get_raw_host()) send_db_mail( 'laowai_panda-question-report', settings.SYS_ADMINS, { 'app_name':app_name, 'base_url':base_url, 'email': reporter_user.email, 'username': reporter_user.username, 'question_url': question_url, }, ) except: pass
def transition_change_notification(order): """ This function shall be called, after an Order object performed a transition change. """ if not isinstance(order, BaseOrder): raise TypeError("Object order must inherit from class BaseOrder") emails_in_queue = False for notification in Notification.objects.filter(transition_target=order.status): recipient = notification.get_recipient(order) if recipient is None: continue # emulate a request object which behaves similar to that one, when the customer submitted its order emulated_request = EmulateHttpRequest(order.customer, order.stored_request) customer_serializer = app_settings.CUSTOMER_SERIALIZER(order.customer) render_context = {'request': emulated_request, 'render_label': 'email'} order_serializer = OrderDetailSerializer(order, context=render_context) language = order.stored_request.get('language') context = { 'customer': customer_serializer.data, 'order': order_serializer.data, 'ABSOLUTE_BASE_URI': emulated_request.build_absolute_uri().rstrip('/'), 'render_language': language, } try: latest_delivery = order.delivery_set.latest() context['latest_delivery'] = DeliverySerializer(latest_delivery, context=render_context).data except (AttributeError, models.ObjectDoesNotExist): pass # try: # template = notification.mail_template.translated_templates.get(language=language) # except MailTemplate.DoesNotExist: # template = notification.mail_template attachments = {} for notiatt in notification.notificationattachment_set.all(): attachments[notiatt.attachment.original_filename] = notiatt.attachment.file.file # mail.send(recipient, template=template, context=context, # attachments=attachments, render_on_delivery=True) send_db_mail(notification.mail_template.slug, recipient, context, attachments=attachments, use_celery=False) emails_in_queue = True if emails_in_queue: email_queued()
def send_by_dbmail(request): if request.method == 'POST': kwargs = dict() for f in allowed_fields: if request.POST.get(f): kwargs[f] = request.POST.get(f) api_key = kwargs.get('api_key') if api_key: del kwargs['api_key'] if not cache.get(api_key): get_object_or_404(ApiKey, api_key=api_key, is_active=True) cache.set(api_key, 1, timeout=defaults.CACHE_TTL) args = [] if request.POST.get('data'): args = [json.loads(request.POST['data'])] if kwargs.get('slug') and kwargs.get('recipient'): send_db_mail(kwargs.pop('slug'), kwargs.pop('recipient'), *args, **kwargs) return HttpResponse('OK') raise Http404
def send_mail_with_db_mail(self, request, **kwargs): current_site = kwargs["site"] if "site" in kwargs \ else Site.objects.get_current() activate_url = reverse("account_confirm_email", args=[self.key]) if request is not None: activate_url = build_absolute_uri(request, activate_url, protocol=app_settings.DEFAULT_HTTP_PROTOCOL) else: activate_url = 'http://%s%s' % (current_site.domain, activate_url) ctx = { "user": self.email_address.user, "activate_url": activate_url, "current_site": current_site, 'expiration_days': app_settings.EMAIL_CONFIRMATION_EXPIRE_DAYS, "key": self.key, } send_db_mail('email-confirmation', self.email_address.email, ctx) self.sent = timezone.now() self.save() signals.email_confirmation_sent.send(sender=self.__class__, confirmation=self)
def send_mail(): send_db_mail( # slug - which defined on db template 'welcome-template', # recipient can be list, or str separated with comma or simple string # '*****@*****.**' or '[email protected], [email protected]' or # ['*****@*****.**', '*****@*****.**'] or string Mail group slug '*****@*****.**', # All *args params will be accessible on template context { 'first_name': 'Rishikesh' }, # You can access to all model fields. For m2m and fk fields, you should use module_name # MyModel.objects.get(pk=1), ####################################################################### ### Optional kwargs: ####################################################################### # from_email='', cc=['*****@*****.**'], bcc=['*****@*****.**'], # # For store on mail logs # user=User.objects.get(pk=1), # # Current language code, which selected by user # language='ru', # # This options is documented on the Django docs # attachments=[(filename, content, mimetype)], # files=['hello.jpg', 'world.png'], # headers={'Custom-Header':'Some value'}, # # For working with different queue, you can specify queue name on the settings, or on option # queue='default', # # Time for retry failed send. Working with celery only # retry_delay=300, # # Max retries, when sending is failed # max_retries=3, # # You can disable retry function # retry=True, # # Hard limit on seconds # time_limit=30, # # Postpone send email for specified seconds # send_after=60, # # You can disable celery for debug messages, or when error is occurred, # # and email can not be delivered by celery. # # Or some part of your app run on instance, where celery is not used. # use_celery=True, # # ... # # another named arguments, which supported by specified backend # # ... )
def make_sended(modeladmin, request, queryset): obj = MTemplate.objects.all()[len(MTemplate.objects.all())-1] field = 'slug' slug = getattr(obj, field) send_db_mail(str(slug), '*****@*****.**', use_celery=False) queryset.update(status='s', draft=True)
def vendor_closed_hook(sender, instance, **kwargs): """Finalize Billing and Statistics for a closed vendor.""" Billing.objects.get(vendor=instance).close() Statistics.objects.create(vendor=instance) send_db_mail('tariff-closed', instance.user.email, {"vendor": instance})
def post(self, request, *args, **kwargs): """Create a user account in case of anonymous user.""" if "abort" in request.POST: # we haven't created order so just quit return redirect("cart") addresses_form = core_forms.AddressesForm( data=request.POST, billing=core_utils.get_billing_address_from_request(self.request), shipping=core_utils.get_shipping_address_from_request( self.request), billing_form_class=self.get_billing_form_class(), shipping_form_class=self.get_shipping_form_class(), ) kwargs['addresses_form'] = addresses_form if request.user.is_anonymous(): # create a user account for anonymous and log him in adapter = account.adapter.get_adapter(request) # first verify email and included captcha form email_form = core_forms.SecuredEmailForm(request.POST, request=request) kwargs['email_form'] = email_form if not (email_form.is_valid() and addresses_form.is_valid()): return self.get(request, *args, **kwargs) # if EmailForm showed password and it was correct it would return user user = email_form.cleaned_data.get("user") if user is None: email = email_form.cleaned_data['email'] # if email and captcha is alright then register the user # addresses_form.full_clean() name = addresses_form.cleaned_data['shipping'].get('name') or \ addresses_form.cleaned_data['billing'].get('name') user, created = core_models.User.objects.get_or_create( name=name, email=email) mail_context = {'user': user} if created: email_address = account.models.EmailAddress.objects.add_email( request, user, email, confirm=False, signup=False) email_address.set_as_primary() # email saying that we have saved user's login informations # with one-time login link 'admin-email-login' dbmail.send_db_mail("core-email-login", email, mail_context, user=user) # Do not send email confirmation - confirm the email # once the order itself is confirmed by email link # account.models.EmailConfirmation.create(email_address) # login new user without requesting their password adapter.login(request, user) # assigns Cart to new User in case user accound didn't exist before cart = utils.get_or_create_cart(self.request) if cart.user != request.user: cart.user = request.user cart.save() # check whether all products in the cart are not sold out. remove = [] for cartitem in cart.items.all(): if cartitem.item.quantity >= 0 and cartitem.quantity > cartitem.item.quantity: remove.append(cartitem) messages.warning( request, str(cartitem.item) + " " + str(_("has been sold out."))) if not cartitem.item.active: remove.append(cartitem) messages.warning( request, str(cartitem.item) + " " + str(_("has been removed by vendor."))) for cartitem in remove: cartitem.delete() # save precious adresses into database and request extra_info_form = model_forms.modelform_factory(models.OrderExtraInfo, exclude=['order'])( request.POST) kwargs['extra_info_form'] = extra_info_form if not all((addresses_form.is_valid(), extra_info_form.is_valid())): return self.get(self, *args, **kwargs) # Add the address to the request billing_address, shipping_address = \ addresses_form.save_to_request(self.request) # Here it is! Turn Cart into Order! order = models.Order.objects.create_from_cart(cart, self.request) utils.add_order_to_request(self.request, order) # Save addresses into the order order.set_shipping_address(shipping_address) order.set_billing_address(billing_address) order.save() return redirect("checkout-shipping")
def send_mail(slug, recipient, context=None, *args, **kwargs): context = context or {} context.update(get_context()) send_db_mail(slug, recipient, context, *args, **kwargs)
def send(self): """Send an email with proforma/invoice.""" send_db_mail("tariff-billed", self.vendor.user.email, {'bill': self}, attachments=[self.export_attachment()])