Example #1
0
    def __init__(self, api_key):
        import sendwithus
        import sendwithus.encoder

        class JSONEncoder(sendwithus.encoder.SendwithusJSONEncoder):
            def default(self, obj):
                import bson
                import datetime
                if isinstance(obj, datetime.datetime):
                    return {
                        'year': obj.year,
                        'month': obj.month,
                        'day': obj.day,
                        'hour': obj.hour,
                        'minute': obj.minute,
                        'second': obj.second,
                        'weekday': obj.weekday(),
                    }
                if isinstance(obj, bson.ObjectId):
                    return str(obj)
                return super().default(obj)

        self.__json_encoder = JSONEncoder
        self.__swu = sendwithus.api(api_key=api_key,
                                    json_encoder=self.__json_encoder)
        self.__load_templates()
Example #2
0
def test_invalid_request(api_key, api_options):
    """Test raises APIError with invalid api request & raise_errors=True"""
    swu_api = sendwithus.api(api_key, raise_errors=True, **api_options)

    with pytest.raises(APIError):
        swu_api.create_email('name', '',
                             '<html><head></head><body></body></html>')
Example #3
0
def test_raise_errors_option(api_key, api_options):
    """Test raises no exception if raise_errors=False"""
    swu_api = sendwithus.api(api_key, raise_errors=False, **api_options)
    response = swu_api.create_email('name', '',
                                    '<html><head></head><body></body></html>')

    assert 400 == response.status_code
def main():
    global swu

    parser = argparse.ArgumentParser(description=DESCRIPTION)
    parser.add_argument('-a', '--apikey', type=str, required=True)
    parser.add_argument('command', choices=CMD_COMMANDS)
    parser.add_argument('resource', choices=CMD_RESOURCES)
    parser.add_argument('directory', nargs='?', default='.')

    args = parser.parse_args()
    swu = sendwithus.api(args.apikey)

    func_map = {
        'pull': {
            'snippets': pull_snippets,
            'templates': pull_templates
        },
        'push': {
            'snippets': push_snippets,
            'templates': push_templates
        }
    }

    try:
        func = func_map[args.command][args.resource]
    except KeyError:
        print 'Unknown Command: {} {}'.format(args.command, args.resource)
    else:
        func(swu, args.directory)
 def setUp(self):
     self.api = api(self.API_KEY, **self.options)
     self.email_address = '*****@*****.**'
     self.segment_id = 'seg_VC8FDxDno9X64iUPDFSd76'
     self.recipient = {
         'name': 'Matt',
         'address': '*****@*****.**'}
     self.incomplete_recipient = {'name': 'Matt'}
     self.email_data = {
         'name': 'Jimmy',
         'plants': ['Tree', 'Bush', 'Shrub']}
     self.email_data_with_decimal = {
         'decimal': decimal.Decimal('5.5')
     }
     self.sender = {
         'name': 'Company',
         'address': '*****@*****.**',
         'reply_to': '*****@*****.**'}
     self.cc_test = [{
         'name': 'Matt CC',
         'address': '*****@*****.**'}]
     self.bcc_test = [{
         'name': 'Matt BCC',
         'address': '*****@*****.**'}]
     self.enabled_drip_campaign_id = 'dc_Rmd7y5oUJ3tn86sPJ8ESCk'
     self.disabled_drip_campaign_id = 'dc_AjR6Ue9PHPFYmEu2gd8x5V'
     self.false_drip_campaign_id = 'false_drip_campaign_id'
Example #6
0
def send_with_template(reciever,data,subject,sender):  #subject is optional
    import sendwithus
    api = sendwithus.api(api_key='sendwithus API key')
    r = api.send(
    email_id='template ID',   
    recipient= {# give the reciever here
                'address': reciever
              },
    email_data={#you can change the tags and variables here
                'company_name':'DSC VIT',
                'name': data['name'],
                'reg_no':data['regno']
            },
    locale='en-IN'      #specify the location
    
    #you can also add sender details if required
    '''sender={
        'address': sender,
        'reply_to':'*****@*****.**',  # Optional
        'name': 'Company'  # Optional
            }'''
    #esp_account='Your esp ID'
    #you can also add this param if you want to use email delivering service
     )
    print (r.status_code)   #response code
def main():
    global swu

    parser = argparse.ArgumentParser(description=DESCRIPTION)
    parser.add_argument('-a', '--apikey', type=str, required=True)
    parser.add_argument('command', choices=CMD_COMMANDS)
    parser.add_argument('resource', choices=CMD_RESOURCES)
    parser.add_argument('directory', nargs='?', default='.')

    args = parser.parse_args()
    swu = sendwithus.api(args.apikey)

    func_map = {
        'pull': {
            'snippets': pull_snippets,
            'templates': pull_templates
        },
        'push': {
            'snippets': push_snippets,
            'templates': push_templates
        }
    }

    try:
        func = func_map[args.command][args.resource]
    except KeyError:
        print 'Unknown Command: {} {}'.format(args.command, args.resource)
    else:
        func(swu, args.directory)
Example #8
0
def send_welcome_email(email_address):
    api_key = os.environ['SEND_WITH_US']
    set_password_link = create_link(email_address, 'password')
    swu = sendwithus.api(api_key)
    swu.send(
        email_id='tem_58MQPDcuQvGKoXG3aVp4Zb',
        recipient={'address': email_address},
        email_data={'setPasswordLink': set_password_link})
Example #9
0
 def send_testmail(self, data):
     api = sendwithus.api(api_key=settings.SWU_API_KEY)
     r = api.send(
       email_id='tem_ed8qjPxQtAEqHwDWVzNwU4',
       recipient={'address': '*****@*****.**'},
       email_data=data
     )
     return r
Example #10
0
def test_authentication_error(api_options):
    """Test raises AuthenticationError with invalid api key"""
    invalid_api = sendwithus.api('INVALID_KEY',
                                 raise_errors=True,
                                 **api_options)

    with pytest.raises(AuthenticationError):
        invalid_api.emails()
Example #11
0
def send_password_reset_email(email_address):
    api_key = os.environ['SEND_WITH_US']
    set_password_link = create_link(email_address, 'password')
    swu = sendwithus.api(api_key)
    swu.send(
        email_id='tem_shSnhmqCSMAwdLbPhuwY4U',
        recipient={'address': email_address},
        email_data={'setPasswordLink': set_password_link})
 def test_send_invalid_apikey(self):
     """ Test send with invalid API key. """
     invalid_api = api('INVALID_API_KEY', **self.options)
     result = invalid_api.send(
         self.EMAIL_ID,
         self.recipient,
         email_data=self.email_data)
     self.assertFail(result)
     self.assertEqual(result.status_code, 403)  # bad api key
Example #13
0
def test_authentication_error(api_options):
    """Test raises AuthenticationError with invalid api key"""
    invalid_api = sendwithus.api(
        'INVALID_KEY',
        raise_errors=True,
        **api_options
    )

    with pytest.raises(AuthenticationError):
        invalid_api.emails()
    def test_invalid_request(self):
        """Test raises APIError with invalid api request & raise_errors=True"""
        swu_api = api(self.API_KEY, raise_errors=True, **self.options)

        self.assertRaises(
            APIError,
            swu_api.create_email,
            'name',
            '',
            '<html><head></head><body></body></html>'
        )
Example #15
0
 def save(self):
     api = sendwithus.api(api_key=settings.SWU_API_KEY)
     template_id = self.cleaned_data['email_templates']
     for d in self.get_data(self.cleaned_data):
         res = api.send(
                         email_id=template_id,
                         recipient={'address': d['email']},
                         email_data=d
                       )
         if res.status_code != 200:
             raise Exception(res.text)
             break
Example #16
0
 def setUp(self):
     self.api = api(self.API_KEY, **self.options)
     self.recipient = {
             'name': 'Matt',
             'address': '*****@*****.**'}
     self.incomplete_recipient = {'name': 'Matt'}
     self.email_data = {
             'name': 'Jimmy',
             'plants': ['Tree', 'Bush', 'Shrub']}
     self.sender = {
             'name': 'Company',
             'address':'*****@*****.**',
             'reply_to':'*****@*****.**'}
Example #17
0
def test_invalid_request(api_key, api_options):
    """Test raises APIError with invalid api request & raise_errors=True"""
    swu_api = sendwithus.api(
        api_key,
        raise_errors=True,
        **api_options
    )

    with pytest.raises(APIError):
        swu_api.create_email(
            'name',
            '',
            '<html><head></head><body></body></html>'
        )
Example #18
0
def test_send_invalid_apikey(
    api_options,
    email_id,
    recipient,
    email_data
):
    """ Test send with invalid API key. """
    invalid_api = sendwithus.api('INVALID_API_KEY', **api_options)
    result = invalid_api.send(
        email_id,
        recipient,
        email_data=email_data
    )
    assert result.status_code == 403  # bad api key
Example #19
0
def test_raise_errors_option(api_key, api_options):
    """Test raises no exception if raise_errors=False"""
    swu_api = sendwithus.api(
        api_key,
        raise_errors=False,
        **api_options
    )
    response = swu_api.create_email(
        'name',
        '',
        '<html><head></head><body></body></html>'
    )

    assert 400 == response.status_code
Example #20
0
def test_send_invalid_apikey(
    api_options,
    email_id,
    recipient,
    email_data
):
    """ Test send with invalid API key. """
    invalid_api = sendwithus.api('INVALID_API_KEY', **api_options)
    result = invalid_api.send(
        email_id,
        recipient,
        email_data=email_data
    )
    assert result.status_code == 403  # bad api key
def main():
    main_parser = argparse.ArgumentParser(description=DESCRIPTION)
    main_parser.add_argument('-a', '--apikey', type=str, required=True, help="required, used for authentication")
    main_parser.add_argument('-d', '--data', type=str, required=False, help="optional, required only in conjunction with render command, specifies a file containing data used for template rendering")
    main_parser.add_argument('-e', '--email', type=str, required=False, help="optional, required only in conjunction with send command, specifies the email address to which the email will be sent to")

    subparsers = main_parser.add_subparsers(help='commands', dest='command')

    pull_parser = subparsers.add_parser('pull', help='process pull templates and snippets')
    pull_parser.add_argument('resource', choices=CMD_RESOURCES)
    pull_parser.add_argument('directory', nargs='?', default='.')

    push_parser = subparsers.add_parser('push', help='process push templates and snippets')
    push_parser.add_argument('resource', choices=CMD_RESOURCES)
    push_parser.add_argument('directory', nargs='?', default='.')

    render_parser = subparsers.add_parser('render', help='process render templates')
    render_parser.add_argument('template', nargs='?', help="Required, specifies path to template version which is to be rendered. <template_name>/<template_version>.html")

    send_parser = subparsers.add_parser('send', help='process send email')
    send_parser.add_argument('template', nargs='?', help="Required, specifies path to template version which is to be sent. <template_name>/<template_version>.html")

    args = main_parser.parse_args()
    swu = sendwithus.api(args.apikey)

    func_map = {
        'pull': {
            'snippets': pull_snippets,
            'templates': pull_templates
        },
        'push': {
            'snippets': push_snippets,
            'templates': push_templates
        }
    }

    try:
        if args.command == 'render':
            render_template(swu, args.data, args.template)
        elif args.command == 'send':
            send_mail(swu, args.data, args.email, args.template)
        else:
            func = func_map[args.command][args.resource]
            func(swu, args.directory)
    except KeyError:
        print 'Unknown Command: {} {}'.format(args.command, args.resource)
Example #22
0
def get_swu_templates():
    key = settings.SWU_API_KEY
    api = sendwithus.api(api_key=key)
    resp = api.emails()
    return resp.json()
    def test_raise_errors_option(self):
        """Test raises no exception if raise_errors=False"""
        swu_api = api(self.API_KEY, raise_errors=False, **self.options)
        response = swu_api.create_email('name', '', '<html><head></head><body></body></html>')

        self.assertEqual(400, response.status_code)
Example #24
0
 def setUp(self):
     self.api = api(self.API_KEY, **self.options) 
Example #25
0
File: app.py Project: Ceasar/photos
import json

from flask import Flask, jsonify, request, render_template
import sendwithus


api = sendwithus.api(api_key='test_a1352c77daceca6ad24ba21a28b071735ee53f73')
with open('templates/share_photos.html') as f:
    res = api.create_template(
        name='Email Name',
        subject='Email Subject',
        html=f.read(),
        text='Optional text content'
    )
    share_template_id = res.json()['id']

app = Flask(__name__)

with open('photos.json') as f:
    photos = json.loads(f.read())


@app.route('/')
def index():
    return render_template('index.html')


def gen_photos(q):
    for photo in photos:
        if q in photo['title']:
            yield photo
Example #26
0
 def __init__(self, app):
     api_key = app.config["SENDWITHUS_API_KEY"]
     self.api = sendwithus.api(api_key=api_key)
Example #27
0
def api(api_key, api_options):
    return sendwithus.api(api_key, **api_options)
Example #28
0
def api(api_key, api_options):
    return sendwithus.api(api_key, **api_options)
Example #29
0
 def api(self):
     ctx = _app_ctx_stack.top
     if not hasattr(ctx, 'sendwithus_api'):
         ctx.sendwithus_api = sendwithus_api.api(api_key=self.api_key,
                                                 **self.api_options)
     return ctx.sendwithus_api
Example #30
0
from __future__ import absolute_import

# django/libs
import sendwithus
from django.conf import settings

api = sendwithus.api(api_key=settings.SENDWITHUS_KEY)
Example #31
0
 def __init__(self):
     self.api = sendwithus.api(api_key=settings.SENDWITHUS_KEY)
    def test_authentication_error(self):
        """Test raises AuthenticationError with invalid api key"""
        invalid_api = api('INVALID_KEY', raise_errors=True, **self.options)

        self.assertRaises(AuthenticationError, invalid_api.emails)