def init_api(self) -> mercadopago.MP:
if self.settings.get('client_id') and not self.settings.get('secret'):
mp = mercadopago.MP(self.settings.get('client_id'))
else:
mp = mercadopago.MP(self.settings.get('client_id'),
self.settings.get('secret'))
return mp
def __init__(self, acquirer):
self.url = "https://api.mercadopago.com"
mp_token = mercadopago.MP(acquirer.mercadopago_client_id,
acquirer.mercadopago_client_secret)
if acquirer.environment == "test":
access_token = acquirer.mercadopago_test_access_token
else:
access_token = mp_token.get_access_token()
# print("-----mp-----",mp)
self.mp = mercadopago.MP(access_token)
self.accessToken = access_token
def compute_mercadopago_url(self):
if self.state == 'open':
preference = {
'items': [{
'title': self.name,
'quantity': 1,
'currency_id': 'ARS',
'unit_price': self.amount_total
}]
}
computed_url = None
mercadopago_client_obj = self.env['ir.config_parameter'].search([
('key', '=', 'mercadopago_client')
])
if mercadopago_client_obj:
mercadopago_key_obj = self.env['ir.config_parameter'].search([
('key', '=', 'mercadopago_key')
])
if mercadopago_key_obj:
mercadopago_client = mercadopago_client_obj.value
mercadopago_key = mercadopago_key_obj.value
mp = mercadopago.MP(mercadopago_client, mercadopago_key)
preferenceResult = mp.create_preference(preference)
url = preferenceResult['response']['init_point']
computed_url = url
if not computed_url:
self.mercadopago_url = 'N/A'
else:
self.mercadopago_url = computed_url
def index(req, **kwargs):
preference = {
"items": [
{
"title": "Multicolor kite",
"quantity": 1,
"currency_id": "CURRENCY_ID", # Available currencies at: https://api.mercadopago.com/currencies
"unit_price": 10.0
}
]
}
mp = mercadopago.MP("CLIENT_ID", "CLIENT_SECRET")
preferenceResult = mp.create_preference(preference)
url = preferenceResult["response"]["init_point"]
output = """
<!doctype html>
<html>
<head>
<title>Pay</title>
</head>
<body>
<a href="{url}">Pay</a>
</body>
</html>
""".format (url=url)
return output
def index():
mp = mercadopago.MP(myconf.take('mercadopago.client_id'),
myconf.take('mercadopago.client_secret'))
print(myconf.take('mercadopago.client_id'),
myconf.take('mercadopago.client_secret'))
# creamos un dict con los datos del pago solicitado:
preference = {
"items": [{
"title":
"Samsung J7",
"description":
"celular nueva gama",
"quantity":
1,
"unit_price":
9000,
"currency_id":
"ARS",
"picture_url":
"https://www.mercadopago.com/org-img/MP3/home/logomp3.gif"
}],
"marketplace_fee":
2.29 # fee to collect
}
# llamamos a MP para que cree un link...
preferenceResult = mp.create_preference(preference)
try:
url = preferenceResult["response"]["sandbox_init_point"]
redirect(url)
except:
raise
response.view = "generic.html"
return {"pref": preferenceResult}
def __mercadoPago(carrito):
mp = mercadopago.MP('TEST-1534881774722776-120914-533d8cfe4ab6b720548a020387446186-129446137')
# user = request.user
# articulo_orden = ArticuloOrden.objects.filter(usuario=user, finalizado=False)
items=[]
for key,value in carrito.items():
datos = {
'title': value['name'],
'quantity': value['quantity'],
'currency_id': 'ARS',
'unit_price': float(value['price']),
}
items.append(datos)
preference = {
"items":items,
"back_urls": [
{
"success": reverse('eess:payment_received')
},
],
"auto_return": "approved",
}
preferenceResult = mp.create_preference(preference)
url_forward = preferenceResult['response']['init_point']
print(preferenceResult)
return HttpResponseRedirect(url_forward)
def compute_mercadopago_url(self):
if self.state == 'sale':
preference = {
'items': [{
'title': self.name,
'quantity': 1,
'currency_id': 'ARS',
'unit_price': self.amount_total
}]
}
computed_url = None
acquirer_id = self.env['payment.acquirer'].sudo().search(
[('provider', '=', 'mercadopago')], limit=1)
if acquirer_id.mercadopago_client_id and acquirer_id.mercadopago_client_secret:
mp = mercadopago.MP(acquirer_id.mercadopago_client_id,
acquirer_id.mercadopago_client_secret)
preferenceResult = mp.create_preference(preference)
if acquirer_id.environment == 'prod':
url = preferenceResult['response']['init_point']
else:
url = preferenceResult['response']['sandbox_init_point']
computed_url = url
if not computed_url:
self.mercadopago_url = 'N/A'
else:
self.mercadopago_url = computed_url
def index(req, **kwargs):
# Create an instance with your MercadoPago credentials (CLIENT_ID and CLIENT_SECRET):
# Argentina: https://www.mercadopago.com/mla/herramientas/aplicaciones
# Brasil: https://www.mercadopago.com/mlb/ferramentas/aplicacoes
mp = mercadopago.MP("CLIENT_ID", "CLIENT_SECRET")
filters = {"external_reference": "Bill001"}
# Search payment data according to filters
searchResult = mp.search_payment(filters)
# Show payment information
output = """
<!doctype html>
<html>
<head>
<title>Search payments</title>
</head>
<body>
<table border='1'>
<tr><th>id</th><th>external_reference</th><th>status</th></tr>"""
for payment in searchResult["response"]["results"]:
output += "<tr>"
output += "<td>" + payment["id"] + "</td>\n"
output += "<td>" + payment["external_reference"] + "</td>\n"
output += "<td>" + payment["status"] + "</td>\n"
output += "</tr>"
output += """
</table>
</body>
</html>
"""
return output
def MercadoPago(mp_public_key, mp_access_token, id_pedido, total):
# INTEGRACIÓN CON MERCADO PAGO
mp = mercadopago.MP(mp_public_key, mp_access_token)
Nombre_producto = "Compra en: Cat People"
Total = total
preference = {
"items": [{
"id": 'ID-CAT-' + str(id_pedido),
"title": Nombre_producto,
"currency_id": "CLP",
"description": "Compra a Be Fashion",
"quantity": 1,
"unit_price": Total
}],
"back_urls": {
"success": "localhost:8000/compra_exito/",
"failure": "localhost:8000/compra_fallo/",
"pending": "localhost:8000/compra_proceso/"
},
"external_reference":
id_pedido
}
preferenceResult = mp.create_preference(preference)
obj = {'preferenceResult': preferenceResult, 'preference': preference}
return obj
def test_get_preference(self):
preference = {
"items": [
{
"title": "sdk-python",
"quantity": 1,
"currency_id": "ARS",
"unit_price": 10.5
}
]
}
mp = mercadopago.MP(client_id, client_secret)
create_preference_result = mp.create_preference(preference)
#print(create_preference_result)
self.assertEquals(create_preference_result["status"], 201)
created_preference_id = create_preference_result["response"]["id"]
get_preference_result = mp.get_preference(created_preference_id)
self.assertEquals(get_preference_result["status"], 200)
obtained_preference = get_preference_result["response"]
self.assertEquals(obtained_preference["items"][0]["title"], "sdk-python")
self.assertEquals(obtained_preference["items"][0]["quantity"], 1)
self.assertEquals(obtained_preference["items"][0]["currency_id"], "ARS")
self.assertEquals(obtained_preference["items"][0]["unit_price"], 10.5)
print("test_get_preference OK!")
def mercadopago():
# Conecta ao mercado pago para fazer o pagamento da fatura
# Conect at mercadopago
import mercadopago
import json
fatura = db.faturas_cliente(request.args(0))
# https://www.mercadopago.com.br/developers/en/plugins_sdks/sdks/official/python/
mp = mercadopago.MP("CLIENT_ID", "CLIENT_SECRET")
preference = {
"items": [{
"back_url": URL('default', 'index'),
"title": "Fatura #%s, %s" % ("6932", "Toy car"),
"quantity": 1,
"currency_id": "BRL",
"unit_price": 19.9,
"payer": {
"name": "Client First Name",
"surname": "Client Last Name",
"email": "*****@*****.**",
},
"back_urls": {
"success": URL('defautl', 'index'),
"failure": URL('default', 'faturas'),
"pending": URL('')
}
}]
}
preferenceResult = mp.create_preference(preference)
redirect(preferenceResult['response']['init_point'])
return json.dumps(preferenceResult, indent=4)
def purchase(request, product_id):
product = get_object_or_404(Product, id=product_id)
preference = {
"items": [{
"title": product.name,
"quantity": 1,
"currency_id": "ARS",
"unit_price": float(product.price)
}],
"back_urls": {
"success": request.build_absolute_uri(reverse('mp-back-success')),
"failure": request.build_absolute_uri(reverse('mp-back-failure')),
"pending": request.build_absolute_uri(reverse('mp-back-pending')),
}
}
mp = mercadopago.MP(settings.MP_CLIENT_ID, settings.MP_CLIENT_SECRET)
preferenceResult = mp.create_preference(preference)
order = Order.objects.create(product=product,
user=request.user,
preference=preferenceResult["response"]["id"])
payment_url = preferenceResult["response"]["sandbox_init_point"]
return redirect(payment_url)
def index(req, **kwargs):
preference = {
"items": [
{
"title": "sdk-python",
"quantity": 1,
"currency_id": "ARS",
"unit_price": 10.5
}
]
}
mp = mercadopago.MP("CLIENT_ID", "CLIENT_SECRET")
preferenceResult = mp.preference.create(preference)
url = preferenceResult["response"]["init_point"]
output = """
<!doctype html>
<html>
<head>
<title>MercadoPago SDK - Create Preference and Show Checkout Example</title>
</head>
<body>
<a href="{url}" name="MP-Checkout" class="blue-l-arall-rn">Pagar</a>
<script type="text/javascript" src="//resources.mlstatic.com/mptools/render.js"></script>
</body>
</html>
""".format (url=url)
return output
def index(req, **kwargs):
mp = mercadopago.MP("CLIENT_ID", "CLIENT_SECRET")
filters = {"external_reference": "ext1425"}
searchResult = mp.search_payment(filters)
return json.dumps(searchResult, indent=4)
def index(req, **kwargs):
mp = mercadopago.MP("CLIENT_ID", "CLIENT_SECRET")
paymentInfo = mp.get_payment (kwargs["id"])
if paymentInfo["status"] == 200:
return json.dumps(paymentInfo, indent=4)
else:
return None
def funcionesComprasAdmin():
if request.method == 'GET':
resultado = listadocompras()
return jsonify(resultado)
if request.method == 'DELETE':
comp = Compra()
comp.set_carrito(request.args['carrito'])
bajacompra(comp)
return "ok"
if request.method == 'POST':
now = datetime.now()
comp = Compra()
comp.set_carrito(request.args['carrito'])
comp.set_estado('ESPERA')
comp.set_fecha(
str(now.year) + '-' + str(now.month) + '-' + str(now.day))
comp.set_hora(
str(now.hour) + ':' + str(now.minute) + ':' + str(now.second))
comp.set_total(request.args['total'])
comp.set_usuario(request.args['usuario'])
altacompra(comp)
aux = request.args.getlist('items[]')
items = []
for item in aux:
items.append(json.loads(item))
print(items)
preference = {
"items": items,
"back_urls": {
'pending':
'https://flask-ecommerce-mate.herokuapp.com/finalizarcompra?carrito='
+ request.args['carrito'],
'success':
'https://flask-ecommerce-mate.herokuapp.com/finalizarcompra?carrito='
+ request.args['carrito'],
'failure':
'https://flask-ecommerce-mate.herokuapp.com/cancelarcompra?carrito='
+ request.args['carrito']
},
"auto_return": 'approved'
}
mp = mercadopago.MP(
"TEST-2010310189255433-020423-ab4183ae168fc66489c83ac9a88b909a-522644875"
)
mp.sandbox_mode(True)
preferenceResult = mp.create_preference(preference)
url = preferenceResult["response"]["init_point"]
return url
if request.method == 'PUT':
comp = Compra()
comp.set_carrito(request.args['carrito'])
comp.set_estado(request.args['estado'])
modificarcompra(comp)
return "ok"
def index(req, **kwargs):
mp = mercadopago.MP("CLIENT_ID", "CLIENT_SECRET")
paymentInfo = mp.get_payment_info(kwargs["id"])
if paymentInfo["status"] == 200:
return paymentInfo["response"]
else:
return None
def getForm_mercado_pago(request):
mp = mercadopago.MP(settings.CLIENT_ID, settings.CLIENT_SECRET)
if request.GET['carro']:
try:
carro = Carro.objects.get(pk=request.GET['carro'])
except Carro.DoesNotExist:
carro = False
if carro:
pedido = carro.pedido
preference = {
"items": [],
'payer': {
'name':
"%s %s" % (carro.propietario.first_name,
carro.propietario.last_name),
'email':
carro.propietario.email
},
'shipments': {
'cost': float(pedido.metodoenvio.precio),
},
'back_urls': {
'success':
request.build_absolute_uri(
reverse('retorn_mercado_pago',
kwargs={'pedido': pedido.id})),
'pending':
"%s" % (settings.MERCADO_PAGO_FAIL),
'failure':
"%s" % (settings.MERCADO_PAGO_FAIL),
},
'notification_url': "%s/mercadopago_ipn/" % (settings.DOMAIN),
}
for linea in carro.lineas.all():
item = {
'title': linea.producto.full_name,
'picture_url': linea.producto.get_thum(0),
'quantity': linea.cantidad,
'currency_id': "PEN",
"unit_price": float(linea.get_precio())
}
preference['items'].append(item)
preferenceResult = mp.create_preference(preference)
return HttpResponse(json.dumps(preferenceResult, indent=4),
content_type='application/json;charset=utf8')
else:
return HttpResponse(json.dumps({'error': 'No Existe Carro'},
indent=4),
content_type='application/json;charset=utf8')
else:
return HttpResponse(json.dumps({'error': 'Solicitud no Valida'},
indent=4),
content_type='application/json;charset=utf8')
def __init__(self,
access_token: str,
sandbox_mode: bool = False,
**kwargs) -> None:
self.access_token = access_token
self.sandbox_mode = sandbox_mode
self.init_point = 'sandbox_init_point' if self.sandbox_mode else 'init_point'
self.mp = mercadopago.MP(self.access_token)
self.mp.sandbox_mode(self.sandbox_mode)
super(MercadoPagoProvider, self).__init__(**kwargs)
def __init__(self, params):
self._params = params
# traer el token de la configuración, si no existe lo creamos
access_token = self._params.get_param('mercadopago_access_token', default=False)
if not access_token:
access_token = self._regenerate_token()
# crear el objeto mp y guardarlo
self._mp = mercadopago.MP(access_token)
def mercadopago_ipn(request):
mp = mercadopago.MP(settings.CLIENT_ID, settings.CLIENT_SECRET)
paymentInfo = mp.get_payment_info(request.GET.get('id'))
print paymentInfo
# Show payment information
if paymentInfo["status"] == 200:
return paymentInfo["response"]
else:
return None
def index(req, **kwargs):
mp = mercadopago.MP("CLIENT_ID", "CLIENT_SECRET")
filters = {
"status": "approved",
"operation_type": "regular_payment",
"payer_email": "[email protected] [email protected]"
}
searchResult = mp.search_payment(filters)
return json.dumps(searchResult, indent=4)
def index(req, **kwargs):
mp = mercadopago.MP("CLIENT_ID", "CLIENT_SECRET")
filters = {
"status": "approved",
"offset": 0,
"limit": 10
}
searchResult = mp.search_payment(filters)
return json.dumps(searchResult, indent=4)
def cart_confirm_mp(request):
if request.method == 'GET':
pass
preference = {
"items": [
{
"title": "Título del art.",
"quantity": 1,
"currency_id": "ARS", # Available currencies at: https://api.mercadopago.com/currencies
"unit_price": 1800
}
],
"payers": [
{
"name": "Marcelo",
"surname": "Longobardi",
"email": "*****@*****.**",
"phone.number": "3816168252",
"identification": {
"type": "DNI",
"number": "20203911",
},
"address": {
"zip_code": "4107",
"street_name": "LA RIOJA",
"street_number": "150",
}
},
],
# "back_urls": [
# {
# "success": reverse('eess:payment_received'),
# "failure": reverse('eess:payment_failure'),
# "pending": reverse('eess:payment_pending')
# },
# ]
}
access_token = "TEST-1534881774722776-120914-533d8cfe4ab6b720548a020387446186-129446137"
mp = mercadopago.MP(access_token)
mp.sandbox_mode(True) # rw
preferenceresult = mp.create_preference(preference)
# back_urls
preferenceresult['response']['back_urls']['success'] = reverse('eess:payment_received')
preferenceresult['response']['back_urls']['failure'] = reverse('eess:payment_failure')
preferenceresult['response']['back_urls']['pending'] = reverse('eess:payment_pending')
# url = preferenceresult["response"]["init_point"]
url = preferenceresult["response"]["sandbox_init_point"]
return redirect(url)
def index(req, **kwargs):
mp = mercadopago.MP("CLIENT_ID", "CLIENT_SECRET")
filters = {
"payment_type_id": "credit_card",
"operation_type": "regular_payment",
"installments": 12,
"description": "Your-item-title"
}
searchResult = mp.search_payment(filters)
return json.dumps(searchResult, indent=4)
def index(req, **kwargs):
mp = mercadopago.MP("CLIENT_ID", "CLIENT_SECRET")
filters = {
"payment_type": "credit_card",
"operation_type": "regular_payment",
"range": "date_created",
"begin_date": "2014-10-21T00:00:00Z",
"end_date": "2014-10-25T24:00:00Z"
}
searchResult = mp.search_payment(filters)
return json.dumps(searchResult, indent=4)
def index(req, **kwargs):
mp = mercadopago.MP("CLIENT_ID", "CLIENT_SECRET")
filters = {
"status": "approved",
"operation_type": "regular_payment",
"range": "date_created",
"begin_date": "NOW-1MONTH",
"end_date": "NOW"
}
searchResult = mp.search_payment(filters)
return json.dumps(searchResult, indent=4)
def index(req, **kwargs):
# Create an instance with your MercadoPago credentials (CLIENT_ID and CLIENT_SECRET):
# Argentina: https://www.mercadopago.com/mla/herramientas/aplicaciones
# Brasil: https://www.mercadopago.com/mlb/ferramentas/aplicacoes
mp = mercadopago.MP("CLIENT_ID", "CLIENT_SECRET")
# Get the payment reported by the IPN. Glossary of attributes response in https://developers.mercadopago.com
paymentInfo = mp.get_payment_info(kwargs["id"])
# Show payment information
if paymentInfo["status"] == 200:
return paymentInfo["response"]
else:
return None
def gerar_checkout(self, cr, context=None):
if not self.mercado_pago_id_preferencia:
mp = mercadopago.MP(self.company_id.mercado_pago_access_token)
response = mp.get("/v1/customers/search", {
"email": self.partner_id.email
})
cliente = None
if response["status"] == 200:
if len(response['response']['results']) > 0:
cliente = response['response']['results'][0]
if not cliente:
if self.partner_id.company_type == 'person':
type = "CPF"
else:
type = "CNPJ"
cliente = mp.post("/v1/customers", {
"name": self.partner_id.name,
"email": self.partner_id.email,
"identification": {
"type": type,
"number": self.partner_id.vat
}
})
preferencia = self.criar_preferencia(cr, mp, cliente)
if preferencia['status'] == 201:
self.write({
'mercado_pago_init_point': preferencia['response']['init_point'],
'mercado_pago_sandbox_init_point': preferencia['response']['sandbox_init_point'],
'mercado_pago_id_preferencia': preferencia['response']['id']
})
return {
'type': 'ir.actions.act_url',
'target': 'new',
'url': self.mercado_pago_init_point,
}
else:
return {
'type': 'ir.actions.act_url',
'target': 'new',
'url': self.mercado_pago_init_point,
}
def create_mercadopago_checkout(request):
if request.is_secure():
protocol = 'https'
else:
protocol = 'http'
host = protocol +"://" + request.get_host()
mp = mercadopago.MP(
settings.MERCADOPAGO_CLIENT_ID,
settings.MERCADOPAGO_CLIENT_SECRET
)
items = []
cart = Cart(request)
for c in cart.items():
items.append({
"title": c.product.title,
"quantity": 1,
"currency_id": "VEF",
"unit_price": c.product.pricing
})
preference = {
"items": items,
"external_reference": {
"user_id":request.user.id,
"shipping_addresss_id":request.session['shipping_address'],
"billing_addresss_id":request.session['billing_address'],
"cart_id":cart.cart_id,
},
"back_urls": {
"failure": host + reverse("payment_cancel"),
"pending": host + reverse("payment_fail"),
"success": host + reverse("payment_sucesss")
},
"notification_url": host + reverse("payment_mercadopago_process")
}
preferenceResult = mp.create_preference(preference)
return Response(
{'result':preferenceResult['response']['init_point']}
)
