Ejemplo n.º 1
0
def new_order_handler(sender, **kwargs):
	order = kwargs['order']
	email = order.user.email
	# Se crea la entrada del log para la nueva orden creada.
	logger.info("Nueva orden creada por " + email +
				" en " + order.restaurant.name + 
				". Numero de orden: " + order.order_number)

	# Enviar mail de confirmacion al dueño de la orden
	try:
		plaintext_file = FileSetting.objects.get(key='ORDER_TEMPLATE_TEXT').value.file
		plaintext_file.open()
		plaintext = plaintext_file.read()
		plaintext = Template(plaintext.decode("UTF-8"))
		plaintext_file.close()

		html_file = FileSetting.objects.get(key='ORDER_TEMPLATE_HTML').value.file
		html_file.open()
		html = html_file.read()
		html = Template(html.decode("UTF-8"))
		html_file.close()
		
		context = Context({"restaurant": order.restaurant.name, "order_num": order.order_number})

		subject = 'DeliveryRD - Confirmacion de orden'
		from_email = GlobalSetting.objects.get(key='DEFAULT_FROM_EMAIL').value
		text_content = plaintext.render(context)
		html_content = html.render(context)
		msg = EmailMultiAlternatives(subject, text_content, from_email, [email])
		msg.attach_alternative(html_content, "text/html")
		msg.send(fail_silently=False)
	except Exception as e:
		logger.error("new_order_handler: Problema al enviar mail. Error: " + e)
Ejemplo n.º 2
0
def user_post_save(sender, instance, created, **kwargs):
    
    if created:
        # Add user to the frontend users group
        try:
            group = Group.objects.get(name="FTEFrontEndUsers")
            instance.groups.add(group)
        except Exception as e:
            logger.error("user_post_save: " + e)

    # Send user the verification email
    email = instance.email
    try:
        fe_user = FTEFrontendUser.objects.get(email=email)
    except ObjectDoesNotExist:
        print (ObjectDoesNotExist.message)
        raise ObjectDoesNotExist
    if not fe_user.confirmed_emails:
        if not fe_user.unconfirmed_emails:
            fe_user.add_unconfirmed_email(email);
        try:
            # plaintext   = get_template(GlobalSetting.objects.get(key='EMAIL_TEMPLATE_TEXT').value)
            plaintext_file = FileSetting.objects.get(key='EMAIL_TEMPLATE_TEXT').value.file
            plaintext_file.open()
            plaintext = plaintext_file.read()
            plaintext = Template(plaintext.decode("UTF-8"))
            plaintext_file.close()

            # html        = get_template(GlobalSetting.objects.get(key='EMAIL_TEMPLATE_HTML').value)
            html_file = FileSetting.objects.get(key='EMAIL_TEMPLATE_HTML').value.file
            html_file.open()
            html = html_file.read()
            html = Template(html.decode("UTF-8"))
            html_file.close()
            confirmation_url = GlobalSetting.objects.get(key='EMAIL_CONFIRMATION_URL').value
            confirmation_link = (confirmation_url +
                                fe_user.email + '/' +
                                fe_user.confirmation_key + '/')
            context = Context({"email": fe_user.email, "confirmation_link": confirmation_link})

            subject = 'DeliveryRD - Confirmacion de email'
            from_email = GlobalSetting.objects.get(key='DEFAULT_FROM_EMAIL').value
            text_content = plaintext.render(context)
            html_content = html.render(context)
            msg = EmailMultiAlternatives(subject, text_content, from_email, [email])
            msg.attach_alternative(html_content, "text/html")
            msg.send(fail_silently=False)
        except Exception as e:
            logger.error("user_post_save: Error enviando mail. Error: " + e)
Ejemplo n.º 3
0
def send_confirmation_key(request):
    info = json.loads(request.body.decode("utf-8"))
    email = info['email']
    try:
        fe_user = FTEFrontendUser.objects.get(email=email)
    except ObjectDoesNotExist:
        print (ObjectDoesNotExist.message)
        return HttpResponse("Email no existe", status=401)
    if not fe_user.confirmed_emails:
        if not fe_user.unconfirmed_emails:
            fe_user.add_unconfirmed_email(email);
        try:
            plaintext_file = FileSetting.objects.get(key='EMAIL_TEMPLATE_TEXT').value.file
            plaintext_file.open()
            plaintext = plaintext_file.read()
            plaintext = Template(plaintext.decode("UTF-8"))
            plaintext_file.close()

            html_file = FileSetting.objects.get(key='EMAIL_TEMPLATE_HTML').value.file
            html_file.open()
            html = html_file.read()
            html = Template(html.decode("UTF-8"))
            html_file.close()
            confirmation_url = GlobalSetting.objects.get(key='EMAIL_CONFIRMATION_URL').value
            confirmation_link = (confirmation_url +
                                fe_user.email + '/' +
                                fe_user.confirmation_key + '/')
            context = Context({"email": fe_user.email, "confirmation_link": confirmation_link})

            subject = 'DeliveryRD - Confirmacion de email'
            from_email = GlobalSetting.objects.get(key='DEFAULT_FROM_EMAIL').value
            text_content = plaintext.render(context)
            html_content = html.render(context)
            msg = EmailMultiAlternatives(subject, text_content, from_email, [email])
            msg.attach_alternative(html_content, "text/html")
            msg.send(fail_silently=False)
        except Exception as e:
            logger.error("send_confirmation_key: Error enviando mail: " + e)
    return HttpResponse(confirmation_link, status=200)
Ejemplo n.º 4
0
    def process_response(self, request, response):

        # Caching is only applicable for text-based, non-streaming
        # responses. We also skip it for non-200 statuses during
        # development, so that stack traces are correctly rendered.
        is_text = response.get("content-type", "").startswith("text")
        valid_status = response.status_code == 200
        streaming = getattr(response, "streaming", False)
        if not is_text or streaming or (settings.DEBUG and not valid_status):
            return response

        # Cache the response if all the required conditions are met.
        # Response must be marked for updating by the
        # ``FetchFromCacheMiddleware`` having a cache get miss, the
        # user must not be authenticated, the HTTP status must be OK
        # and the response mustn't include an expiry age, indicating it
        # shouldn't be cached.
        marked_for_update = getattr(request, "_update_cache", False)
        anon = hasattr(request, "user") and not is_authenticated(request.user)
        timeout = get_max_age(response)
        if timeout is None:
            timeout = settings.CACHE_MIDDLEWARE_SECONDS
        if anon and valid_status and marked_for_update and timeout:
            cache_key = cache_key_prefix(request) + request.get_full_path()
            _cache_set = lambda r: cache_set(cache_key, r.content, timeout)
            if callable(getattr(response, "render", None)):
                response.add_post_render_callback(_cache_set)
            else:
                _cache_set(response)

        # Second phase rendering for non-cached template code and
        # content. Split on the delimiter the ``nevercache`` tag
        # wrapped its contents in, and render only the content
        # enclosed by it, to avoid possible template code injection.
        token = nevercache_token()
        try:
            token = token.encode("utf-8")
        except AttributeError:
            pass
        parts = response.content.split(token)
        # Restore csrf token from cookie - check the response
        # first as it may be being set for the first time.
        csrf_token = None
        try:
            csrf_token = response.cookies[settings.CSRF_COOKIE_NAME].value
        except KeyError:
            try:
                csrf_token = request.COOKIES[settings.CSRF_COOKIE_NAME]
            except KeyError:
                pass
        if csrf_token:
            request.META["CSRF_COOKIE"] = csrf_token
        context = RequestContext(request)
        for i, part in enumerate(parts):
            if i % 2:
                part = Template(
                    part.decode("utf-8")).render(context).encode("utf-8")
            parts[i] = part
        response.content = b"".join(parts)
        response["Content-Length"] = len(response.content)
        if hasattr(request, "_messages"):
            # Required to clear out user messages.
            request._messages.update(response)
        # Response needs to be run-through the CSRF middleware again so
        # that if there was a {% csrf_token %} inside of the nevercache
        # the cookie will be correctly set for the the response
        if csrf_middleware_installed():
            response.csrf_processing_done = False
            csrf_mw = CsrfViewMiddleware()
            csrf_mw.process_response(request, response)
        return response