def test_attach(self):

        from pyramid_mailer.message import Message
        from pyramid_mailer.message import Attachment

        msg = Message(
            subject="testing",
            recipients=["[email protected]"],
            sender='sender',
            body="testing"
            )

        attachment = Attachment(
            data=b"this is a test",
            content_type="text/plain"
            )

        msg.attach(attachment)

        a = msg.attachments[0]

        self.assertTrue(a.filename is None)
        self.assertEqual(a.disposition, 'attachment')
        self.assertEqual(a.content_type, "text/plain")
        self.assertEqual(a.data, b"this is a test")

def mailer_send(subject="!",
                sender=None,
                recipients=[],
                body=None,
                html=None,
                attachments=[]):
    try:
        request = get_current_request()
        if sender is None:
            sender = request.registry.settings['mail.default_sender']

        mailer = get_mailer(request)
        message = Message(subject=subject,
                          sender=sender,
                          recipients=recipients,
                          body=body,
                          html=html)
        for attachment in attachments:
            attachment = Attachment(attachment.title,
                                    attachment.mimetype,
                                    attachment)
            message.attach(attachment)

        if transaction.get().status == Status.COMMITTED:
            mailer.send_immediately(message)
        else:
            mailer.send(message)

    except Exception:
        pass

def confirmation(request):
    '''
    Generates confirmation page and confirmation emails to user and D2L site 
    admin.
    '''
    if not logged_in(request):
        return HTTPFound(location=request.route_url('login'))
    form = SelectCoursesForm()
    csrf_token = request.session.get_csrf_token()

    submitter_email = request.session['uniqueName'] + '@' + \
        request.registry.settings['EMAIL_DOMAIN']
    name = request.session['firstName'] + ' ' + request.session['lastName']
    sender = request.registry.settings['mail.username']

    '''remove for production'''
    submitter_email = '[email protected]'

    message = Message(subject="Course Combine Confirmation",
        sender=sender,
        recipients=[sender, submitter_email])
    message.body = make_msg_text(name, submitter_email, request)
    message.html = make_msg_html(name, submitter_email, request)
    mailer = get_mailer(request)
    mailer.send_immediately(message, fail_silently=False)

    return{'csrf_token': csrf_token,
        'name': name,
        'form': form, 
        'base_course': request.session['base_course'],
        'courses_to_combine': request.session['courses_to_combine']
        }

    def test_is_bad_headers_if_bad_headers(self):

        from pyramid_mailer.message import Message

        msg = Message(subject="testing\n\r", sender="[email protected]\nexample.com", body="testing", recipients=["[email protected]"])

        self.assertTrue(msg.is_bad_headers())

 def test_to_message_multipart_with_qpencoding(self):
     from pyramid_mailer.message import Message, Attachment
     response = Message(
         recipients=['To'],
         sender='From',
         subject='Subject',
         body='Body',
         html='Html'
         )
     this = os.path.abspath(__file__)
     with open(this, 'rb') as data:
         attachment = Attachment(
             filename=this,
             content_type='application/octet-stream',
             disposition='disposition',
             transfer_encoding='quoted-printable',
             data=data,
             )
         response.attach(attachment)
         message = response.to_message()
         payload = message.get_payload()[1]
     self.assertEqual(
         payload.get('Content-Transfer-Encoding'),
         'quoted-printable'
         )
     self.assertEqual(
         payload.get_payload(),
         _qencode(self._read_filedata(this,'rb')).decode('ascii')
         )

    def test_is_bad_headers_if_subject_empty(self):
        from pyramid_mailer.message import Message
        msg = Message(sender="[email protected]",
                      body="testing",
                      recipients=["[email protected]"])

        self.assert_(not(msg.is_bad_headers()))

    def test_attach_as_body(self):
        from pyramid_mailer.message import Message
        from pyramid_mailer.message import Attachment

        charset = 'iso-8859-1'
        text_encoded = b'LaPe\xf1a'
        text = text_encoded.decode(charset)
        transfer_encoding = 'quoted-printable'
        body = Attachment(
            data=text,
            transfer_encoding=transfer_encoding
            )
        msg = Message(
            subject="testing",
            sender="[email protected]",
            recipients=["[email protected]"],
            body=body
            )
        body_part = msg.to_message()

        self.assertEqual(
            body_part['Content-Type'],
            'text/plain; charset="iso-8859-1"'
            )
        self.assertEqual(
            body_part['Content-Transfer-Encoding'],
            transfer_encoding
            )
        self.assertEqual(
            body_part.get_payload(),
            _qencode(text_encoded).decode('ascii')
            )

    def test_attach_as_html(self):
        from pyramid_mailer.message import Message
        from pyramid_mailer.message import Attachment

        charset = 'iso-8859-1'
        text_encoded = b'LaPe\xf1a'
        html_encoded = b'<p>' + text_encoded + b'</p>'
        html_text = html_encoded.decode(charset)
        transfer_encoding = 'quoted-printable'
        html = Attachment(
            data=html_text,
            transfer_encoding=transfer_encoding
            )
        msg = Message(
            subject="testing",
            sender="[email protected]",
            recipients=["[email protected]"],
            html=html,
            )

        html_part = msg.to_message()

        self.assertEqual(
            html_part['Content-Type'],
            'text/html; charset="iso-8859-1"'
            )
        self.assertEqual(
            html_part['Content-Transfer-Encoding'],
            transfer_encoding
            )
        self.assertEqual(
            html_part.get_payload(),
            _qencode(html_encoded).decode('ascii')
            )

    def test_attach_as_body_and_html_utf8(self):
        from pyramid_mailer.message import Message
        from pyramid_mailer.message import Attachment

        charset = "utf-8"
        # greek small letter iota with dialtyika and tonos; this character
        # cannot be encoded to either ascii or latin-1, so utf-8 is chosen
        text_encoded = b"\xce\x90"
        text = text_encoded.decode(charset)
        html_encoded = b"<p>" + text_encoded + b"</p>"
        html_text = html_encoded.decode(charset)
        transfer_encoding = "quoted-printable"
        body = Attachment(data=text, transfer_encoding=transfer_encoding)
        html = Attachment(data=html_text, transfer_encoding=transfer_encoding)
        msg = Message(subject="testing", sender="[email protected]", recipients=["[email protected]"], body=body, html=html)
        message = msg.to_message()
        body_part, html_part = message.get_payload()

        self.assertEqual(body_part["Content-Type"], 'text/plain; charset="utf-8"')

        self.assertEqual(body_part["Content-Transfer-Encoding"], transfer_encoding)

        payload = body_part.get_payload()
        self.assertEqual(payload, _qencode(text_encoded).decode("ascii"))

        self.assertEqual(html_part["Content-Type"], 'text/html; charset="utf-8"')
        self.assertEqual(html_part["Content-Transfer-Encoding"], transfer_encoding)
        payload = html_part.get_payload()
        self.assertEqual(payload, _qencode(html_encoded).decode("ascii"))

    def test_attach_as_html(self):
        import codecs
        from pyramid_mailer.message import Message
        from pyramid_mailer.message import Attachment

        charset = 'latin-1'
        text_encoded = b('LaPe\xf1a')
        text = text_encoded.decode(charset)
        text_html = '<p>' + text + '</p>'
        transfer_encoding = 'quoted-printable'
        html = Attachment(data=text_html,
                          transfer_encoding=transfer_encoding)
        msg = Message(subject="testing",
                      sender="[email protected]",
                      recipients=["[email protected]"],
                      html=html)
        html_part = msg.to_message()

        self.assertEqual(
            html_part['Content-Type'], 'text/html')
        self.assertEqual(
            html_part['Content-Transfer-Encoding'], transfer_encoding)
        self.assertEqual(html_part.get_payload(),
                         codecs.getencoder('quopri_codec')(
                             text_html.encode(charset))[0].decode('ascii'))

    def email(self):
        id = self.request.matchdict['id']
        test = Tests.by({'id':id,'alias':self.request.user.alias}).first()
        if not test:
            raise HTTPForbidden()
        file = self._generate_pdf(id)
        self.response['id'] = id
        self.response['emails'] = self.request.params.get('email.addresses',None)
        
        if 'form.submitted' in self.request.params:
            if self.request.params['email.ok'] == '1':
                emails = self.request.params['email.addresses'].replace(' ','').split(',')
                for email in emails:
                    if not Validate.email(email):
                        self.notify('Invalid email address',warn=True)
                        return self.template('email.pt')
                        
                try:
                    message = Message(subject=self._email_fmt(id, str(Properties.get('MAILER_TO_SUBJECT','Submission'))),
                                      sender=str(Properties.get('MAILER_GLOBAL_FROM_ADDRESS','System')),
                                      recipients=emails,
                                      body=self._email_fmt(id, str(Properties.get('MAILER_BODY','Submission'))))
                    attachment = Attachment('submission_' + str(id) + '.pdf', 'application/pdf', file)
                    message.attach(attachment)
                    mailer = get_mailer(self.request)
                    mailer.send(message)
                    self.notify('Email sent!')
                except Exception as e:
                    print "ERROR: " + str(e)
                    self.notify('Unable to send email!',warn=True)
            else:
                self.notify('Unable to send example email!',warn=True)

        return self.template('email.pt')

    def test_attach_as_body_and_html_latin1(self):
        from pyramid_mailer.message import Message
        from pyramid_mailer.message import Attachment

        charset = "iso-8859-1"
        text_encoded = b"LaPe\xf1a"
        text = text_encoded.decode(charset)
        html_encoded = b"<p>" + text_encoded + b"</p>"
        html_text = html_encoded.decode(charset)
        transfer_encoding = "quoted-printable"
        body = Attachment(data=text, transfer_encoding=transfer_encoding)
        html = Attachment(data=html_text, transfer_encoding=transfer_encoding)
        msg = Message(subject="testing", sender="[email protected]", recipients=["[email protected]"], body=body, html=html)
        message = msg.to_message()
        body_part, html_part = message.get_payload()

        self.assertEqual(body_part["Content-Type"], 'text/plain; charset="iso-8859-1"')
        self.assertEqual(body_part["Content-Transfer-Encoding"], transfer_encoding)
        payload = body_part.get_payload()
        self.assertEqual(payload, _qencode(text_encoded).decode("ascii"))

        self.assertEqual(html_part["Content-Type"], 'text/html; charset="iso-8859-1"')
        self.assertEqual(html_part["Content-Transfer-Encoding"], transfer_encoding)
        payload = html_part.get_payload()
        self.assertEqual(payload, _qencode(html_encoded).decode("ascii"))

def accountant_mail(appstruct):
    """
    this function returns a message object for the mailer

    it consists of a mail body and an attachment attached to it
    """
    unencrypted = make_mail_body(appstruct)
    #print("accountant_mail: mail body: \n%s") % unencrypted
    #print("accountant_mail: type of mail body: %s") % type(unencrypted)
    encrypted = encrypt_with_gnupg(unencrypted)
    #print("accountant_mail: mail body (enc'd): \n%s") % encrypted
    #print("accountant_mail: type of mail body (enc'd): %s") % type(encrypted)

    message = Message(
        subject="[C3S] Yes! a new member",
        sender="[email protected]",
        recipients=["[email protected]"],
        body=encrypted
    )
    #print("accountant_mail: csv_payload: \n%s") % generate_csv(appstruct)
    #print(
    #    "accountant_mail: type of csv_payload: \n%s"
    #) % type(generate_csv(appstruct))
    csv_payload_encd = encrypt_with_gnupg(generate_csv(appstruct))
    #print("accountant_mail: csv_payload_encd: \n%s") % csv_payload_encd
    #print(
    #    "accountant_mail: type of csv_payload_encd: \n%s"
    #) % type(csv_payload_encd)

    attachment = Attachment(
        "C3S-SCE-AFM.csv.gpg", "application/gpg-encryption",
        csv_payload_encd)
    message.attach(attachment)

    return message

    def test_cc_without_recipients_2(self):

        from pyramid_mailer.message import Message

        msg = Message(subject="testing", sender="[email protected]", body="testing", cc=["[email protected]"])
        response = msg.to_message()
        self.assertTrue("Cc: [email protected]" in text_type(response))

def confirmation(request):
    """
    Generates confirmation page and confirmation emails to user and D2L site 
    admin.
    """
    if not logged_in(request):
        return HTTPFound(location=request.route_url("login"))
    form = SelectCoursesForm()
    csrf_token = request.session.get_csrf_token()

    submitter_email = request.session["uniqueName"] + "@" + request.registry.settings["EMAIL_DOMAIN"]
    name = request.session["firstName"] + " " + request.session["lastName"]
    sender = request.registry.settings["mail.username"]

    """remove for production"""
    submitter_email = "[email protected]"

    message = Message(subject="Course Combine Confirmation", sender=sender, recipients=[sender, submitter_email])
    message.body = make_msg_text(name, submitter_email, request)
    message.html = make_msg_html(name, submitter_email, request)
    mailer = get_mailer(request)
    mailer.send_immediately(message, fail_silently=False)

    return {
        "csrf_token": csrf_token,
        "name": name,
        "form": form,
        "base_course": request.session["base_course"],
        "courses_to_combine": request.session["courses_to_combine"],
    }

    def test_add_cc(self):

        from pyramid_mailer.message import Message

        msg = Message("testing")
        msg.add_cc("[email protected]")

        self.assertEqual(msg.cc, ["[email protected]"])

    def test_add_recipient(self):

        from pyramid_mailer.message import Message

        msg = Message("testing")
        msg.add_recipient("[email protected]")

        self.assert_(msg.recipients == ["[email protected]"])

    def test_add_bcc(self):

        from pyramid_mailer.message import Message

        msg = Message("testing")
        msg.add_bcc("[email protected]")

        self.assert_(msg.bcc == ["[email protected]"])

 def _send_annotation(self, body, subject, recipients):
     body = body.decode('utf8')
     subject = subject.decode('utf8')
     message = Message(subject=subject,
                       recipients=recipients,
                       body=body)
     self.mailer.send(message)
     log.info('sent: %s', message.to_message().as_string())

    def test_to_message_with_html_attachment(self):
        from pyramid_mailer.message import Message, Attachment

        response = Message(recipients=["To"], sender="From", subject="Subject", body="Body")
        attachment = Attachment(data=b"data", content_type="text/html")
        response.attach(attachment)
        message = response.to_message()
        att_payload = message.get_payload()[1]
        self.assertEqual(att_payload["Content-Type"], 'text/html; charset="us-ascii"')
        self.assertEqual(att_payload.get_payload(), _bencode(b"data").decode("ascii"))