# -*- coding: utf-8 -*-
import hmac
import time
import hashlib
import requests
import json
from ordereddict import OrderedDict
 
timestamp = int(time.time())
auth_key = 'xxxxxxxxxxxxxxxxxx'  # Chave pública
secret = 'xxxxxxxxxxxxxxxxxxxx'  # Chave privada
auth_data = {
    "auth_key": auth_key,
    "auth_timestamp": timestamp,
    "auth_version": "1.0",
}
data = {
    # O endereço de email tem que estar entre os caracteres <>. O nome pode estar do lado separado por um espaço
    u'recipient_list': [
        "Destinatario1 <teste@teste.com.br>", "<destinatario2@exemplo.com>"
    ],
  
    # O endereço de email do remetente segue a mesma regra que os emails dos destinatários
    u'from': 'Remetente <teste@teste.com.br>',
    u'subject': u'Apenas um teste',
    u'message_text': u'Apenas um teste'
}


def encode_param_without_escaping(key, value):
    if isinstance(value, list):
        return '&'.join([key + '[]=' + item for item in value])
    else:
        if isinstance(value, dict):
            value = json.dumps(value)
    return "{key}={value}".format(key=key, value=value) 
    
# Transformar o payload em Query String
auth_params_dict = OrderedDict(sorted(auth_data.items()))
params_list = []
for key, value in auth_params_dict.iteritems():
    params_list.append(encode_param_without_escaping(key, value))
msg_default = '&'.join(params_list)
  
data.update(auth_data)
params_dict = OrderedDict(sorted(data.items()))
  
# Criar a 'auth_signature'
hmac_dict = {
    'key': secret,
    'digestmod': hashlib.sha256
}
hmac_dict.update({'msg': 'POST\n/api/send_mail/\n' + msg_default})
auth_signature_post_text = hmac.new(**hmac_dict).hexdigest()
  
url_base = '{0}{1}?auth_key={2}&auth_timestamp={3}&auth_version=1.0&auth_signature={4}'
url_post_text = url_base.format(
    'http://www.mitte.pro', '/api/send_mail/', auth_key, timestamp, auth_signature_post_text
)

response = requests.post(url_post_text, {}, params_dict)

print ""
print url_post_text
print response.content

const _request = require('request');
const signature = require('apysignature');
const querystring = require("querystring");
 
const self = {
    _urlBase: 'http://www.mitte.pro',
    _host: 'localhost',
    _auth_key: 'xxxxxxxxxxxxxxxxxxxxxxx',
    _auth_secret: 'xxxxxxxxxxxxxxxxxxxx',
    _params: {
        // O endereço de email tem que estar entre os caracteres <>. O nome pode estar do lado separado por um espaço
        recipient_list: [
            "Destinatario1 <destinatario1@exemplo.com>", "<destinatario2@exemplo.com>"
        ],
 
        // O endereço de email do remetente segue a mesma regra que os emails dos destinatários
        from: 'Remetente <paulo.dsn.cir@alterdata.com.br>',
        subject: "Apenas um teste",
        message_text: "Apenas um teste"
    },
 
    toType: function (obj) {
       return ({}).toString.call(obj).match(/\s([a-zA-Z]+)/)[1].toLowerCase()
    },
    stringifyParams: function () {
        for (var key in self._params) {
            if (self._params.hasOwnProperty(key))
                if (self.toType(self._params[key]) != "string")
                    self._params[key] = JSON.stringify(self._params[key]);
        }
    },
    getUrl: function() {
        self.stringifyParams();
        var signedReq = new signature.Request('post', '/api/send_mail/', self._params);
        var token = new signature.Token(self._auth_key, self._auth_secret);
        token.sign(signedReq);
        var authDict = signedReq.getAuthDict();
        return self._urlBase + '/api/send_mail/?' + querystring.stringify(authDict);
    },
    sendRequest: function () {
        var url = self.getUrl();
        _request({url: url, method: 'POST', json: true, body: self._params},
            function (error, response, body) {
                if (response && response.statusCode == 200)
                    console.info(response);
                    
                else {
                    console.error(error);
                }
            }
        );
    }
};
 
self.sendRequest();