def Postback():
pagarme.authentication_key('ak_test_jbIXhrHXHOaUUNKtUVrkT9HGL60SSg')
postback = pagarme.transaction.specific_postback(
"7341631", "po_ck368bv1v00b0vs733f9uuuc3")
post_in_string = json.dumps(postback)
parsed_json = (json.loads(post_in_string))
return parsed_json["model_id"], parsed_json["status"]
def Transfer():
pagarme.authentication_key('ak_test_jbIXhrHXHOaUUNKtUVrkT9HGL60SSg')
transfer_params = {
'amount': '1000',
'recipient_id': 're_ck0zjmw1s007ier6eysyd3agj'
}
transfer = pagarme.transfer.create(transfer_params)
transf_in_string = json.dumps(transfer)
parsed_json = (json.loads(transf_in_string))
return parsed_json["id"], parsed_json["amount"], parsed_json["source_id"]
def Antecipacao():
pagarme.authentication_key('ak_test_jbIXhrHXHOaUUNKtUVrkT9HGL60SSg')
params = {
'payment_date': time.time() * 1000 + 86400000,
'timeframe': 'start',
'requested_amount': '5000'
}
recipientId = 're_ck0zjmw1s007ier6eysyd3agj'
bulk_anticipation = pagarme.bulk_anticipation.create(recipientId, params)
ante_in_string = json.dumps(bulk_anticipation)
parsed_json = (json.loads(ante_in_string))
return parsed_json["id"], parsed_json["amount"], recipientId
def RecorrenciaSplit():
pagarme.authentication_key('ak_test_jbIXhrHXHOaUUNKtUVrkT9HGL60SSg')
subscription = pagarme.subscription.create({
"card_number": "4111111111111111",
"card_cvv": "123",
"card_expiration_date": "0922",
"card_holder_name": "Marv Fishburne",
"customer":{
"email":"*****@*****.**",
"name":"Sir Jorah Mormont",
"document_number":"18152564000105",
"address":{
"zipcode":"04571020",
"neighborhood":"Cidade Moncoes",
"street":"R. Dr. Geraldo Campos Moreira",
"street_number":"240"
},
"phone": {
"number":"987654321",
"ddd":"11"
}
},
"split_rules":[
{
"recipient_id": "re_ck0zkjmuj00gln86dajtwrfws",
"percentage": "25"
},
{
"recipient_id": "re_ck0zjmw1s007ier6eysyd3agj",
"percentage": "75"
}
],
"payment_method": "credit_card",
"plan_id": "435922",
"postback_url": "http://requestb.in/zyn5obzy"
})
sub_in_string = json.dumps(subscription)
parsed_json = (json.loads(sub_in_string))
return parsed_json["id"]
def Recorrencia():
pagarme.authentication_key('ak_test_jbIXhrHXHOaUUNKtUVrkT9HGL60SSg')
subscription = pagarme.subscription.create({
"card_number":
"4111111111111111",
"card_cvv":
"123",
"card_expiration_date":
"0922",
"card_holder_name":
"Marv Fishburne",
"customer": {
"email": "*****@*****.**",
"name": "Sir Jorah Mormont",
"document_number": "18152564000105",
"address": {
"zipcode": "04571020",
"neighborhood": "Cidade Moncoes",
"street": "R. Dr. Geraldo Campos Moreira",
"street_number": "240"
},
"phone": {
"number": "987654321",
"ddd": "11"
}
},
"payment_method":
"credit_card",
"plan_id":
"435922",
"postback_url":
"http://requestb.in/zyn5obzy"
})
sub_in_string = json.dumps(subscription)
parsed_json = (json.loads(sub_in_string))
return parsed_json["id"]
import pagarme from settings import PAGARME_API_KEY pagarme.authentication_key(PAGARME_API_KEY)
'ContactForm',
'PROCESSING',
'AUTHORIZED',
'PAID',
'REFUNDED',
'PENDING_REFUND',
'WAITING_PAYMENT',
'REFUSED',
'UserPaymentProfileDoesNotExist',
'PagarmePaymentItemDoesNotExist',
'ImpossibleUserCreation',
'BOLETO',
'CREDIT_CARD',
]
authentication_key(settings.CHAVE_PAGARME_API_PRIVADA)
def get_payment_item(slug: str) -> PagarmeItemConfig:
"""
Find PagarmeItemConfig with its PagarmeFormConfig on database
:param slug:
:return: PagarmeItemConfig
"""
return PagarmeItemConfig.objects.filter(
slug=slug).select_related('default_config').get()
def list_payment_item_configs() -> List[PagarmeItemConfig]:
"""
List PagarmeItemConfig ordered by slug
from datetime import datetime
from typing import Tuple
import pagarme as _pagarme
from dateutil.relativedelta import MO, relativedelta
from django.conf import settings
from django.utils.timezone import now
_pagarme.authentication_key(settings.PAGARME_API_KEY)
PYTOOLS_PRICE = 9999
PYTOOLS_PROMOTION_PRICE = 4999
def pytools_capture(token: str, user_creation: datetime):
price = PYTOOLS_PROMOTION_PRICE if is_on_pytools_promotion_season(
user_creation) else PYTOOLS_PRICE
return _pagarme.transaction.capture(token, {'amount': price})
class PagarmeValidationException(Exception):
pass
class PagarmeNotPaidTransaction(Exception):
pass
def confirm_boleto_payment(user_id, notification: dict, raw_post: str,
expected_signature):
transaction = extract_transaction(notification, raw_post,
expected_signature)
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.1/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = os.environ.get('SECRET_KEY')
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = os.environ.get('DEBUG', False)
PRODUCTION = os.environ.get('PRODUCTION', False)
# Payment settings
pagarme.authentication_key(os.environ.get('PAGARME_API_KEY'))
PAGARME_API_KEY = os.environ.get('PAGARME_API_KEY')
PAGARME_CRYPTO = os.environ.get('PAGARME_CRYPTO')
CONFIRMATION_LINK = os.environ.get('CONFIRMATION_LINK')
CASH_OUT_COMMISSION = float(os.environ.get('CASH_OUT_COMMISSION', 15))
PAYMENT_DESCRIPTION = os.environ.get('PAYMENT_DESCRIPTION')
PLATFORM_COMMISSION = os.environ.get('PLATFORM_COMMISSION', 0)
# Application definition
import pagarme
# adicionar chave de autenticação da API
pagarme.authentication_key('SUA_CHAVE_AQUI')
recipient1_id = 're_cjbfmzwxq00xqkq6dbmev1zb0'
recipient2_id = 're_cjbfmzxhy00z3rs6e8caj6t84'
transaction_data = {
"amount":
25000,
"card_number":
"4111111111111111",
"card_cvv":
"123",
"card_expiration_date":
"0922",
"card_holder_name":
"Cliente Fiel",
"customer": {
"external_id": "#1234",
"name": "Cliente Fiel",
"type": "individual",
"country": "br",
"email": "*****@*****.**",
"documents": [{
"type": "cpf",
"number": "00000000000"
}],
"phone_numbers": ["+5511999999999", "+5511888889999"],
"birthday": "1990-01-01"
import pagarme, os, paypalrestsdk
pagarme.authentication_key(
os.environ.get('api_key', "ak_test_K25D1A2mFSZ4sX6GatWv1ocF80hdCa"))
#paypal = paypalrestsdk.Api({
# 'mode':os.environ.get('paypal_mode','sandbox'),
# 'client_id':os.environ.get('paypal_client_id',"AaUAkwOv3dMunBPR7KleXCfEi1HoimA2tCpGuGiH_kuic-DzmgeDEios5P1fgWl5nAeEDIE83YF5SetV"),
# 'client_secret':os.environ.get('paypal_client_secret',"EMhI_C1VsLfek1GX4DEOtGzerKUh1Xnwol5OlyreSLCanPJgpMz5SNQ6KhmMIi4M25cPewdrrmSzs4WQ")
#})
gateway = pagarme
def Split():
pagarme.authentication_key('ak_test_jbIXhrHXHOaUUNKtUVrkT9HGL60SSg')
params = {
"amount":
"21000",
"card_number":
"4111111111111111",
"card_cvv":
"123",
"card_expiration_date":
"0922",
"card_holder_name":
"Marius Fishburne",
"postback_url":
"http://requestb.in/pkt7pgpk",
"split_rules": [{
"recipient_id": "re_ck0zkjmuj00gln86dajtwrfws",
"percentage": "50",
"liable": "false",
"charge_processing_fee": "false"
}, {
"recipient_id": "re_ck0zjmw1s007ier6eysyd3agj",
"percentage": "50",
"liable": "true",
"charge_processing_fee": "true"
}],
"customer": {
"external_id": "#3311",
"name": "Morpheus Fishburne",
"type": "individual",
"country": "br",
"email": "*****@*****.**",
"documents": [{
"type": "cpf",
"number": "30621143049"
}],
"phone_numbers": ["+5511999998888", "+5511888889999"],
"birthday": "1965-01-01"
},
"billing": {
"name": "Trinity Moss",
"address": {
"country": "br",
"state": "sp",
"city": "Cotia",
"neighborhood": "Rio Cotia",
"street": "Rua Matrix",
"street_number": "9999",
"zipcode": "06714360"
}
},
"shipping": {
"name": "Neo Reeves",
"fee": "1000",
"delivery_date": "2000-12-21",
"expedited": True,
"address": {
"country": "br",
"state": "sp",
"city": "Cotia",
"neighborhood": "Rio Cotia",
"street": "Rua Matrix",
"street_number": "9999",
"zipcode": "06714360"
}
},
"items": [{
"id": "r123",
"title": "Red pill",
"unit_price": "10000",
"quantity": "1",
"tangible": True
}, {
"id": "b123",
"title": "Blue pill",
"unit_price": "10000",
"quantity": "1",
"tangible": True
}]
}
trx = pagarme.transaction.create(params)
trx_in_string = json.dumps(trx)
parsed_json = (json.loads(trx_in_string))
return parsed_json["id"]
from flask import Flask, jsonify, request, Blueprint
import pagarme
import json
import os
apipagarme = Blueprint('apipagarme', __name__, template_folder='templates')
pagarme.authentication_key(os.getenv('PAGARME_KEY'))
@apipagarme.route("/card/payment", methods=['POST'])
def payment():
response = {}
payload = request.get_json()
if (payload == None):
status = {"message": "Error Request"}
return jsonify(status), 400
card = request.json['card']
customer = request.json['customer']
billing = request.json['billing']
items = request.json['items']
try:
card_id = pagarme.card.create(card)['id']
except Exception:
response = {"message": "there was an error in the card registration."}
return jsonify(response), 500
def get(self, request, *args, **kwargs):
context = base_context(request.user)
capacity = request.GET.get("capacidade")
date = ast.literal_eval(request.GET.get("date"))
period = ast.literal_eval("[" + request.GET.get("period") + "]")
placeprice_pk = request.GET.get("placeprice_pk")
place_pk = request.GET.get("place_pk")
data = json.loads(request.GET.get("data"))
place = Place.objects.get(pk=place_pk)
context["place"] = place
seller = place.sellerprofile
buyer = context["buyer"]
birthday = buyer.birthday
placeprice = PlacePrice.objects.get(pk=placeprice_pk)
pagarme.authentication_key(settings.PAGARME_API_KEY)
# Billing
zip_code = request.GET.get("zip_code").replace("-", "")
number = request.GET.get("number")
state = request.GET.get("state")
city = request.GET.get("city")
neighbourhood = request.GET.get("neighbourhood")
street = request.GET.get("street")
# Faz a Transação
params = {
"amount":
data["amount"],
"card_hash":
data["card_hash"],
"installments":
data["installments"],
"customer": {
"external_id":
str(buyer.pk),
"name":
buyer.name,
"type":
"individual",
"country":
"br",
"email":
buyer.email,
"documents": [{
"type":
"cpf",
"number":
buyer.cpf.replace(".", "").replace("-", "")
}],
"phone_numbers": [
"+" + buyer.cellphone.replace("(", "").replace(
")", "").replace("-", "")
],
"birthday":
str(birthday.year) + "-" + add_left_zero(str(birthday.month)) +
"-" + add_left_zero(str(birthday.day))
},
"billing": {
"name": buyer.name,
"address": {
"country": "br",
"state": state,
"city": city,
"neighborhood": neighbourhood,
"street": street,
"street_number": number,
"zipcode": zip_code
}
},
"items": [{
"id": str(placeprice.pk),
"title": "EXEMPLO",
"unit_price": data["amount"],
"quantity": "1",
"tangible": False
}],
"split_rules": [{
"recipient_id": seller.pagarme_id,
"percentage": "100",
"liable": True,
"charge_processing_fee": True
}]
}
trx = pagarme.transaction.create(params)
pagarme_transaction = trx["id"]
if period == [0, 1]:
period = "max"
else:
period = "min"
unavailability = PlaceUnavailability.objects.create(
place=place,
period=period,
day=date[2] + "-" + date[1] + "-" + date[0],
)
PlaceReservation.objects.create(
place=place,
placeprice=placeprice,
buyer=buyer,
unavailability=unavailability,
creation=datetime.now(),
pagarme_transaction=pagarme_transaction,
value=data["amount"] / 100)
context["encryption_key"] = settings.PAGARME_ENCRYPTION_KEY
return render(request, "place_purchase.html", context)
# Create your views here.
from django.conf import settings
from django.http import JsonResponse, HttpResponseBadRequest
from django.shortcuts import render
from django.views.decorators.csrf import csrf_exempt
from pagarme import authentication_key, transaction
authentication_key(settings.CHAVE_LINDART_API_PRIVADA)
def produto(request):
ctx = {
'CHAVE_LINDART_CRIPTOGRAFIA_PUBLICA':
settings.CHAVE_LINDART_CRIPTOGRAFIA_PUBLICA
}
return render(request, 'pagamentos/produto.html', ctx)
@csrf_exempt
def captura(request):
token = request.POST['token']
transacao = transaction.find_by_id(token)
valor = transacao['authorized_amount']
valor_minimo = 8000
if valor < valor_minimo:
return HttpResponseBadRequest(
f'Valor {valor} menor que o minimo de {valor_minimo}')
transaction.capture(token, {'amount': valor})
return JsonResponse({'token': 'ok'})
import pagarme, isodate
from django.conf import settings
from django.http import JsonResponse
from django.shortcuts import redirect, render
from transacaosite.models import *
from apisite.models import Inventario
import json
pagarme.authentication_key(settings.PAGAR_ME_TOKEN)
def calc_moeda(trans):
valor_total = 0
for dados in trans:
preco_com_quantidade = float(dados['preco_item']) * int(
dados['quantidade'])
valor_total += preco_com_quantidade
valor_total = valor_total * 100
valor_total = int(valor_total)
return str(valor_total)
def calc_total(trans):
valor_total = 0
for dados in trans:
preco_com_quantidade = float(dados['preco_item']) * int(
dados['quantidade'])
valor_total += preco_com_quantidade
return str(valor_total)
from flask import Flask #Importando a classe FLASK
from flask import jsonify #Módulo Flask para JSON
from flask import render_template #Módulo Flask para HTML
from flask import request #Módulo que determina o método HTTP (GET ou POST)
from flask import flash #Módulo para exibit popups
from forms import TransactionForm #Importa a classe criada em FORMS.PY
from forms import BalanceForm #Importa a classe criada em FORMS.PY
import pagarme
pagarme.authentication_key('ak_test_1bJgehkFPIQwihtavxJ0Ko7GCRKcYu')
app = Flask(__name__) #Instância o Flask
app.secret_key = 'development key' #Chave de desenvolvimento
@app.route('/', methods=['GET'])#Responsável por interpretar a rota/url
def home():
#return "Hello", 200
#return jsonify({"mensage":"Hello JSON!"})
return render_template("home.html") #Renderizando home.html fazendo uso do módulo render_template
@app.route('/about', methods=['GET'])
def about():
return render_template('about.html')
@app.route('/transaction', methods=['GET', 'POST'])
def transaction():
form = TransactionForm()
if request.method == 'POST':
if form.validate()==False:
def get(self, request, *args, **kwargs):
context = base_context(request.user)
# =========== BEGIN REFUND
placereservation_pk = request.GET.get("placereservation_pk")
place_refund = request.GET.get("place_refund")
placereservation = PlaceReservation.objects.get(pk=placereservation_pk)
reservation = placereservation
place = placereservation.place
pagarme_transaction = placereservation.pagarme_transaction
pagarme.authentication_key(settings.PAGARME_API_KEY)
trx = pagarme.transaction.find_by({'id': pagarme_transaction})[0]
# print(trx)
print()
print()
print()
cancellation_policy = place.cancellation_policy
print('cancellation_policy', cancellation_policy)
days_before_event = (reservation.unavailability.day -
datetime.datetime.today().date()).days
print('days_before_event', days_before_event)
hours_after_creating_reservation = (datetime.datetime.today().replace(
tzinfo=None) - reservation.creation.replace(tzinfo=None)
).total_seconds() / 60 / 60
print('hours_after_creating_reservation',
hours_after_creating_reservation)
place_reservation_price = reservation.value
print('place_reservation_price', place_reservation_price)
refund = False
if cancellation_policy == "flexivel":
# flexivel
# Cancelamento até 48 horas após fazer a reserva e até 7 dias antes do evento, após este período pagamento integral do valor da reserva.
if hours_after_creating_reservation < 48 and days_before_event < 7:
refund = 1
elif cancellation_policy == "moderada":
# moderada
# Cancelamento até 48 horas após fazer a reserva e até 14 dias antes do evento, após este período pagamento integral do valor da reserva.
if hours_after_creating_reservation < 48 and days_before_event < 14:
refund = 1
elif cancellation_policy == "rigorosa":
# rigorosa
# 50% do reembolso caso o cancelamento ocorra ate 48 horas após fazer a reserva e até 21 dias antes do evento, após este período pagamento integral do valor da reserva.
if hours_after_creating_reservation < 48 and days_before_event < 21:
refund = 0.5
amount = trx["authorized_amount"]
refunded = trx["refunded_amount"]
print(amount)
print(refunded)
if refund == 1:
if amount != refunded:
params_refund = {'amount': amount - refunded}
else:
if refunded < amount / 2:
params_refund = {'amount': amount / 2 - refunded}
refunded_trx = pagarme.transaction.refund(trx['id'], params_refund)
# =========== END REFUND
placereservation.canceled = True
placereservation.save()
return render(
request,
"control_panel/buyer_placereservation_cancelled_confirmed.html",
context)
