def send_verification_mail_for_email_update(request, user, new_email, verification_type):
    """
    Sends an email with a verification link to users when
    they update their email. The email is sent to the new email.
    The actual update of the email happens only after
    the verification link is clicked.
    The ``verification_type`` arg is both the name of the urlpattern for
    the verification link, as well as the names of the email templates
    to use.
    """
    verify_url = reverse(verification_type, kwargs={
        "uidb36": int_to_base36(user.id),
        "token": default_token_generator.make_token(user),
        "new_email": new_email
    }) + "?next=" + (next_url(request) or "/")
    context = {
        "request": request,
        "user": user,
        "new_email": new_email,
        "verify_url": verify_url,
    }
    subject_template_name = "email/%s_subject.txt" % verification_type
    subject = subject_template(subject_template_name, context)
    send_mail_template(subject, "email/%s" % verification_type,
                       settings.DEFAULT_FROM_EMAIL, new_email,
                       context=context)

def send_order_email(request, order):
    """
    Send order receipt email on successful order.
    """
    settings.use_editable()

    address = request.session['address']

    store = request.session['stores']
    store_name = store[0].name
    store_address = store[0].address
    store_contact = store[0].contact_number

    order_context = {"order": order, "request": request,
                     "order_items": order.items.all(), "address": address,
                     "store_name": store_name, "store_address": store_address,
                     "store_contact": store_contact}
    order_context.update(order.details_as_dict())
    try:
        get_template("shop/email/order_receipt.html")
    except TemplateDoesNotExist:
        receipt_template = "email/order_receipt"
    else:
        receipt_template = "shop/email/order_receipt"
        from warnings import warn
        warn("Shop email receipt templates have moved from "
             "templates/shop/email/ to templates/email/")
    send_mail_template(settings.SHOP_ORDER_EMAIL_SUBJECT,
        receipt_template, settings.SHOP_ORDER_FROM_EMAIL,
        order.billing_detail_email, context=order_context,
        fail_silently=settings.DEBUG)

def modularpage_processor(request, page):
    formblock_ct = ContentType.objects.get(app_label='clubhouse_forms',\
            model='formblock')

    # TODO: Fix this to find form objects in any of the BlockContexts registered here
    formblocks = page.modularpage.content.filter(block_type=formblock_ct)
    from clubhouse.forms import Initialised

    for formblock in formblocks:
        registry_key = 'form:%s' % formblock.block_object.pk
        form_model = formblock.block_object.form
        form = FormForForm(formblock.block_object.form, RequestContext(request),
                           None, None)

        post_data = request.POST or {}
        if form.submit_key in post_data:
            form = FormForForm(formblock.block_object.form,
                    RequestContext(request), request.POST, request.FILES or None)

        if form.is_valid():
            url = page.get_absolute_url()
            if is_spam(request, form, url):
                return redirect(url)
            attachments = []
            for f in form.files.values():
                f.seek(0)
                attachments.append((f.name, f.read()))
            entry = form.save()
            subject = form_model.email_subject
            if not subject:
                subject = "%s - %s" % (form_model.title, entry.entry_time)
            fields = [(v.label, format_value(form.cleaned_data[k]))
                      for (k, v) in form.fields.items()]
            context = {
                "fields": fields,
                "message": form_model.email_message,
                "request": request,
            }
            email_from = form_model.email_from or settings.DEFAULT_FROM_EMAIL
            email_to = form.email_to()
            if email_to and form_model.send_email:
                send_mail_template(subject, "email/form_response", email_from,
                                   email_to, context)
            headers = None
            if email_to:
                # Add the email entered as a Reply-To header
                headers = {'Reply-To': email_to}
            email_copies = split_addresses(form_model.email_copies)
            if email_copies:
                send_mail_template(subject, "email/form_response_copies",
                                   email_from, email_copies, context,
                                   attachments=attachments, headers=headers)
            form_valid.send(sender=request, form=form, entry=entry)
            form.is_submitted = True
        else:
            form_invalid.send(sender=request, form=form)

        Initialised.register(registry_key, form)

    return {}

def reservation_send(request):
    if not request.is_ajax():
        raise Http404()

    if request.method != 'POST':
        raise Http404()

    f = settings.RESERV_EMAIL_FROM
    t = settings.RESERV_EMAIL_TO
    if f and t:
        C = {
            'message': "Reservation request raised",
            'fields': []
        }

        for k, v in request.POST.iteritems():
            if k != 'csrfmiddlewaretoken':
                C['fields'].append((k,v,))

        send_mail_template(
            addr_from=f,
            addr_to=[t, ],
            template='email/form_response',
            subject="WEB RESERVATION REQUEST",
            context=C,
        )

    return HttpResponse("test")

    def save(self, request):
        """
        Saves a new comment and sends any notification emails.
        """
        comment = self.get_comment_object()
        obj = comment.content_object
        if request.user.is_authenticated():
            comment.user = request.user
            comment.user_name = best_name(comment.user)

        comment.by_author = request.user == getattr(obj, "user", None)
        comment.ip_address = ip_for_request(request)
        comment.replied_to_id = self.data.get("replied_to")
        comment.save()
        comment_was_posted.send(sender=comment.__class__, comment=comment,
                                request=request)
        notify_emails = split_addresses(settings.COMMENTS_NOTIFICATION_EMAILS)
        notify_emails.append(obj.user.email)
        reply_to_comment = comment.replied_to
        if reply_to_comment is not None:
            notify_emails.append(reply_to_comment.user.email)
        if notify_emails:
            subject = "[HydroShare Support] New comment by {c_name} for: {res_obj}".format(
                c_name=comment.user_name, res_obj=str(obj))
            context = {
                "comment": comment,
                "comment_url": add_cache_bypass(comment.get_absolute_url()),
                "request": request,
                "obj": obj,
            }
            send_mail_template(subject, "email/comment_notification",
                               settings.DEFAULT_FROM_EMAIL, notify_emails,
                               context)

        return comment

 def save(self, request):
     """
     Saves a new comment and sends any notification emails.
     """
     comment = self.get_comment_object()
     obj = comment.content_object
     if request.user.is_authenticated():
         comment.user = request.user
     comment.by_author = request.user == getattr(obj, "user", None)
     comment.ip_address = ip_for_request(request)
     comment.replied_to_id = self.data.get("replied_to")
     comment.save()
     comment_was_posted.send(sender=comment.__class__, comment=comment,
                             request=request)
     notify_emails = split_addresses(settings.COMMENTS_NOTIFICATION_EMAILS)
     if notify_emails:
         subject = _("New comment for: ") + str(obj)
         context = {
             "comment": comment,
             "comment_url": add_cache_bypass(comment.get_absolute_url()),
             "request": request,
             "obj": obj,
         }
         send_mail_template(subject, "email/comment_notification",
                            settings.DEFAULT_FROM_EMAIL, notify_emails,
                            context)
     return comment

    def post(self, request, *args, **kwargs):
        order = Order.objects.get(pk=kwargs['pk'])

        if order.status == 1:
            order.status = 2 # set to payed
            order.save()

            order_context = {"order": order, "request": request,
                             "order_items": order.items.all()}
            order_context.update(order.details_as_dict())

            # send email with order to producer
            send_mail_template("Bestellung #%i" % order.id,
                           "email/producer_notification",
                           settings.SHOP_ORDER_FROM_EMAIL,
                           settings.SHOP_PRODUCER_EMAIL,
                           context=order_context,
                           addr_bcc=settings.SHOP_ORDER_EMAIL_BCC or None)

            # send email with payment received notification to customer
            send_mail_template("Zahlung zu Bestellung #%i erhalten" % order.id,
                           "email/customer_notification",
                           settings.SHOP_ORDER_FROM_EMAIL,
                           order.billing_detail_email,
                           context=order_context)

        return redirect('order_detail', pk=order.pk)

    def send_email_to_requester(self, request):
        template = "openhelpdesk/email/report/info_to_request"
        operator = request.user
        operator_name = operator.username
        if operator.last_name and operator.first_name:
            operator_name = '{} {}'.format(operator.first_name,
                                           operator.last_name)
        context = {'report_name': self._meta.verbose_name.lower(),
                   'operator': operator,
                   'operator_name': operator_name,
                   'ticket_id': self.ticket_id,
                   'email_background_color': (
                       OrganizationSetting.email_objects.get_color(
                           self.ticket.requester.email))}

        try:
            site_conf = SiteConfiguration.objects.get(site=self.ticket.site)
            addr_from = site_conf.email_addr_from
        except (SiteConfiguration.DoesNotExist, Ticket.DoesNotExist):
            addr_from = SiteConfiguration.get_no_site_email_addr_from()

        subject = subject_template("{}_subject.html".format(template), context)
        addr_to = [self.ticket.requester.email]
        change_ticket_url = '{}#tab_messages'.format(
            reverse(admin_urlname(self.ticket._meta, 'change'),
                    args=(self.ticket_id,)))
        context.update({'report': self, 'request': request,
                        'change_ticket_url': change_ticket_url})
        send_mail_template(subject, template, addr_from, addr_to,
                           context=context, attachments=None)

def send_order_email(request, order):
    """
    Send order receipt email on successful order.
    """
    settings.use_editable()
    order_context = {"order": order, "request": request,
                     "order_items": order.items.all()}
    if order.has_reservables:
        order_context["has_reservables"] = True
    else:
        order_context["has_reservables"] = False
    order_context["hide_shipping"] = settings.SHOP_ALWAYS_SAME_BILLING_SHIPPING
    order_context.update(order.details_as_dict())
    try:
        get_template("shop/email/order_receipt.html")
    except TemplateDoesNotExist:
        receipt_template = "email/order_receipt"
    else:
        receipt_template = "shop/email/order_receipt"
        from warnings import warn
        warn("Shop email receipt templates have moved from "
             "templates/shop/email/ to templates/email/")
    send_mail_template(settings.SHOP_ORDER_EMAIL_SUBJECT,
                       receipt_template, settings.SHOP_ORDER_FROM_EMAIL,
                       order.billing_detail_email, context=order_context,
                       addr_bcc=settings.SHOP_ORDER_EMAIL_BCC or None)

    def send_email_to_operators_on_adding(self, request):
        template = "openhelpdesk/email/ticket/ticket_operators_creation"
        requester_name = _('no personal info assigned')
        if self.requester.last_name and self.requester.first_name:
            requester_name = '{} {}'.format(self.requester.first_name,
                                            self.requester.last_name)
        subject = subject_template(
            "{}_subject.html".format(template),
            {'ticket_name': self._meta.verbose_name.lower(),
             'username': self.requester.email or self.requester.username})
        try:
            site_conf = SiteConfiguration.objects.get(site=self.site)
            addr_from = site_conf.email_addr_from
            addr_to = site_conf.email_addrs_to
        except SiteConfiguration.DoesNotExist:
            addr_from = SiteConfiguration.get_no_site_email_addr_from()
            addr_to = SiteConfiguration.get_no_site_email_addrs_to()
        change_url = reverse(admin_urlname(self._meta, 'change'),
                             args=(self.pk,))

        email_background_color = (
            OrganizationSetting.email_objects.get_color(
                self.requester.email))
        context = {'ticket_name': self._meta.verbose_name, 'ticket': self,
                   'request': request, 'change_url': change_url,
                   'requester_username': self.requester.username,
                   'requester_email': self.requester.email or _(
                       'no email assigned'),
                   'requester_name': requester_name,
                   'email_background_color': email_background_color}
        send_mail_template(subject, template, addr_from, addr_to,
                           context=context, attachments=None)

def send_store_order_email(request, order):
    """
    Send order email to store on successful order.
    """
    settings.use_editable()

    address = request.session['address']
    store = request.session['stores']
    store_name = store[0].name
    store_email = [store[0].email]

    store_name_no_spaces = store_name.replace(" ", "")

    order_context = {"order": order, "request": request,
                     "order_items": order.items.all(), "address": address,
                     "store_name": store_name, "store_name_no_spaces": store_name_no_spaces}
    order_context.update(order.details_as_dict())
    try:
        get_template("shop/email/store_order.html")
    except TemplateDoesNotExist:
        receipt_template = "email/store_order"
    else:
        receipt_template = "shop/email/store_order"
        from warnings import warn
        warn("Shop email receipt templates have moved from "
             "templates/shop/email/ to templates/email/")
    send_mail_template(settings.SHOP_STORE_ORDER_EMAIL_SUBJECT,
        receipt_template, settings.SHOP_ORDER_FROM_EMAIL,
        store_email, context=order_context,
        fail_silently=settings.DEBUG)

def send_order_email(request, order):
    """
    Send order receipt email on successful order.
    """
    settings.use_editable()
    order_context = {"order": order, "request": request,
                     "order_items": order.items.all()}
    order_context.update(order.details_as_dict())
    from mezzanine.utils.email import send_mail_template
    send_mail_template(_("Order Receipt"), "email/order_receipt",
        settings.SHOP_ORDER_FROM_EMAIL, order.billing_detail_email,
        context=order_context, fail_silently=settings.DEBUG)

def order_handler(request, order_form, order):
  """
  Default order handler - called when the order is complete and
  contains its final data. Implement your own and specify the path
  to import it from via the setting ``SHOP_HANDLER_ORDER``.
  """
  settings.use_editable()
  items = order.items.all()
  
  customer_type = 'Retail'
  user_id = order.user_id
  
  if user_id:
    try:
      user = User.objects.get(id=user_id)
    except:
      pass
    else:
      if user.has_perm('custom.wholesale_customer'):
        customer_type = 'Wholesale'

  company_name = ''
  website = ''
  fullurl = ''
  if customer_type == 'Wholesale':
    try:
      company_name = user.get_profile().company_name
      website = user.get_profile().website
    except:
      pass
    else:
      if website:
        if "http://" not in website:
          fullurl = "http://" + website
        else:
          fullurl = website

  order_context = {
    "order": order,
    "request": request,
    "order_items": items,
    "customer_type": customer_type,
    "company_name": company_name,
    "website": website,
  }
  order_context.update(order.details_as_dict())
  from mezzanine.utils.email import send_mail_template
  send_mail_template(_(customer_type + " Order Completed on manai.co.uk"), "email/order_alert",
      settings.SERVER_EMAIL, settings.DEFAULT_FROM_EMAIL,
      context=order_context, fail_silently=settings.DEBUG)

def send_registration_confirmation_email(request):
  """
  Send order receipt email on successful order.
  """
  settings.use_editable()
  context = {"user": request.user, "site_url": settings.SITE_URL}
  template = "email/registration_confirmation"

  send_mail_template( "Thank you for registering with Manai",
                      template,
                      settings.SHOP_ORDER_FROM_EMAIL,
                      request.user.email,
                      context=context,
                      fail_silently=settings.DEBUG)

def send_invite_code_mail(code, site_url, login_url):
    context = {
        'code': code,
        'site_name': settings.SITE_TITLE,
        'site_url': site_url,
        'login_url': login_url,
    }
    send_mail_template(
        "Your Invitation to %s" % settings.SITE_TITLE,
        "invites/send_invite_email",
        settings.DEFAULT_FROM_EMAIL,
        code.registered_to,
        context=context,
        fail_silently=False,
    )

def form_processor(request, page):
    """
    Display a built form and handle submission.
    """
    form = FormForForm(page.form, RequestContext(request),
                       request.POST or None, request.FILES or None)
    if form.is_valid():
        url = page.get_absolute_url() + "?sent=1"
        if is_spam(request, form, url):
            return redirect(url)
        attachments = []
        for f in form.files.values():
            f.seek(0)
            attachments.append((f.name, f.read()))
        entry = form.save()
        subject = page.form.email_subject
        if not subject:
            subject = "%s - %s" % (page.form.title, entry.entry_time)
        fields = [(v.label, format_value(form.cleaned_data[k]))
                  for (k, v) in form.fields.items()]
        context = {
            "fields": fields,
            "message": page.form.email_message,
            "request": request,
            "page": page,
            "entry_id": entry.id,
        }

        url += '&entry_id=' + str(entry.pk)

        email_from = page.form.email_from or settings.DEFAULT_FROM_EMAIL
        email_to = form.email_to()
        if email_to and page.form.send_email:
            send_mail_template(subject, "email/form_response", email_from,
                               email_to, context)
        headers = None
        if email_to:
            # Add the email entered as a Reply-To header
            headers = {'Reply-To': email_to}
        email_copies = split_addresses(page.form.email_copies)
        if email_copies:
            send_mail_template(subject, "email/form_response_copies",
                               email_from, email_copies, context,
                               attachments=attachments, headers=headers)
        form_valid.send(sender=request, form=form, entry=entry)
        return redirect(url)
    form_invalid.send(sender=request, form=form)
    return {"form": form}

    def save(self, request):
        """
        Saves a new comment and sends any notification emails.
        """
        comment = self.get_comment_object()
        obj = comment.content_object
        comment.user = request.user
        user_name = request.user.get_full_name()
        if not user_name:
            user_name = request.user.username

        comment.user_name = user_name
        # comment.email = request.user.email

        comment.by_author = request.user == getattr(obj, "user", None)
        comment.ip_address = ip_for_request(request)
        comment.replied_to_id = self.data.get("replied_to")

        # Mezzanine's duplicate check that also checks `replied_to_id`.
        lookup = {
            "content_type": comment.content_type,
            "object_pk": comment.object_pk,
            "user_name": comment.user_name,
            "user_email": comment.user_email,
            "user_url": comment.user_url,
            "replied_to_id": comment.replied_to_id,
        }
        for duplicate in self.get_comment_model().objects.filter(**lookup):
            if (duplicate.submit_date.date() == comment.submit_date.date() and
                    duplicate.comment == comment.comment):
                return duplicate

        comment.save()
        comment_was_posted.send(sender=comment.__class__, comment=comment,
                                request=request)
        notify_emails = split_addresses(settings.COMMENTS_NOTIFICATION_EMAILS)
        if notify_emails:
            subject = ugettext("New comment for: ") + str(obj)
            context = {
                "comment": comment,
                "comment_url": add_cache_bypass(comment.get_absolute_url()),
                "request": request,
                "obj": obj,
            }
            send_mail_template(subject, "email/comment_notification",
                               settings.DEFAULT_FROM_EMAIL, notify_emails,
                               context)
        return comment

def send_reminder_email(user,subject):
    """
    Send order receipt email on successful order.
    """ 
    settings.use_editable()
    site = Site.objects.get_current()
    url= site.domain+'/member-services/join-ipra/'
    order_context = {"user": user,"update_url":url,"subject":subject}
    #order_context.update(order.details_as_dict())

    receipt_template = "email/account_reminder"

    send_mail_template(subject,
                       receipt_template, 'IPRA <[email protected]>',
                       user.email, context=order_context,
                       addr_bcc=None)

    def send_email_to_requester(self, request):
        template = "openhelpdesk/email/report/info_to_request"
        context = {'report_name': self._meta.verbose_name.lower(),
                   'operator': request.user.username,
                   'ticket_id': self.ticket_id}

        subject = subject_template("{}_subject.html".format(template), context)
        addr_from = request.user.email
        addr_to = [self.ticket.requester.email]
        change_ticket_url = '{}#tab_messages'.format(
            reverse(admin_urlname(self.ticket._meta, 'change'),
                    args=(self.ticket_id,)))
        context.update({'report': self, 'request': request,
                        'change_ticket_url': change_ticket_url})
        send_mail_template(subject, template, addr_from, addr_to,
                           context=context, attachments=None)

def suggest_store(request, template="blog/suggest_store.html"):
	if request.is_ajax():
		if request.method == 'POST':
			form = SuggestStoreForm(request.POST)
			if form.is_valid():
				data = json.dumps({'success':True})
				response_kwargs = {"content_type": 'application/json'}
				email_from = settings.DEFAULT_FROM_EMAIL
				email_to = settings.SUGGEST_STORE_EMAIL_TO
				subject = form.cleaned_data['email_subject']
				message = form.cleaned_data['email_message']
				sender_email = "Anonymous"
				if request.user.is_authenticated(): 
					sender_email = request.user.email

				context = {
					"message": message,
					"request": request,
					"from_email": sender_email
				}
				if email_to and email_from:
					send_mail_template(subject, "email/suggest_store_response", email_from,
						email_to, context, fail_silently=settings.DEBUG)

				return HttpResponse(data, **response_kwargs)
			elif form.errors:
				data = json.dumps(form.errors)
				response_kwargs = {"content_type": 'application/json', "status": 400}
				return HttpResponse(data, **response_kwargs)
		else:
			form = SuggestStoreForm()
			if request.user.is_authenticated():
				form.fields['email_from'].initial = request.user.email
			else:
				form.fields['email_from'].initial = settings.SERVER_EMAIL
			form.fields['email_subject'].initial = settings.SUGGEST_STORE_EMAIL_SUBJECT
			form.fields['email_from'].label = ''
			form.fields['email_subject'].label = ''
			form.fields['email_message'].label = 'Store Name or Link'

			form.fields['email_from'].widget.attrs['style'] = 'display:none'
			form.fields['email_subject'].widget.attrs['style'] = 'display:none'
			context = {"form": form, "action_url": reverse("suggest_store")}
			response = render(request, template, context)
			return response
	else:
		raise Http404()