def add_card_form_pagodigital(request):
######## Metodo POST ########
if request.method == 'POST':
data = request.POST
template = 'pagodigital/redirect.html'
# Verifico las key mandatorias
keys = [
'name', 'phone', 'address', 'id_card', 'email', 'city', 'state',
'cc_number', 'cc_exp_month', 'cc_exp_year', 'cc_cvv',
'cc_fr_number', 'cc_fr_name', 'user_id', 'token'
]
json_loader = __validate_json(data, keys)
if json_loader['status'] == 'error':
return HttpResponse(json.dumps(json_loader),
content_type='application/json',
status=http_BAD_REQUEST)
# Obtengo el usuario y el form vinculado al token
user = User.get(data['user_id'])
form = Form.get(user, data['token'])
if form is None:
message = 'form not available'
body = {'status': 'error', 'message': message}
return HttpResponse(json.dumps(body),
content_type='application/json',
status=http_BAD_REQUEST)
# Obtengo settings del integrator
api_key = IntegratorSetting.get_var(form.integrator, 'api_key')
api_secret = IntegratorSetting.get_var(form.integrator, 'api_secret')
redirect_url = IntegratorSetting.get_var(form.integrator,
'redirect_url_add_card')
jwt_endpoint = IntegratorSetting.get_var(form.integrator,
'jwt_endpoint')
jwt_user = IntegratorSetting.get_var(form.integrator, 'jwt_user')
jwt_pass = IntegratorSetting.get_var(form.integrator, 'jwt_pass')
# Obtengo el JWT
pd_jwt_gw = PagoDigitalJWTGateway(jwt_endpoint, jwt_user, jwt_pass)
try:
ret, content = pd_jwt_gw.doPost()
if not ret:
context = {'redirect_url': redirect_url}
return render(request, template, context)
if not 'TOKEN' in content:
context = {'redirect_url': redirect_url}
return render(request, template, context)
pd_jwt = content['TOKEN']
except Exception as e:
context = {'redirect_url': redirect_url}
return render(request, template, context)
# Realizar add card y obtener token
pd_ac_endpoint = IntegratorSetting.get_var(form.integrator,
'add_card_endpoint')
pd_gw = PagoDigitalGateway(pd_ac_endpoint, api_key, api_secret, pd_jwt)
pd_card = PagoDigitalCard(data['cc_number'], data['cc_cvv'],
data['cc_fr_number'], data['cc_exp_month'],
data['cc_exp_year'], data['name'],
data['id_card'], data['address'],
data['email'], data['phone'], data['city'],
data['state'])
try:
ret, content = pd_gw.doPost(pd_card.to_dict())
if not ret:
context = {'redirect_url': redirect_url}
return render(request, template, context)
if 'CODIGO_RESPUESTA' in content:
if str(content['CODIGO_RESPUESTA']) not in SUCCESS_CODES:
context = {'redirect_url': redirect_url}
return render(request, template, context)
else:
context = {'redirect_url': redirect_url}
return render(request, template, context)
except Exception as e:
context = {'redirect_url': redirect_url}
return render(request, template, context)
# Deshabilito cualquier tarjeta existente
cards = Card.objects.filter(user=user, enabled=True)
for card in cards:
card.disable()
# Creo la tarjeta o la obtengo si ya existe
card = Card.get_by_token(user, content['TOKEN'])
if card is not None:
card.enable()
else:
card_exp = "%s/%s" % (data['cc_exp_month'],
data['cc_exp_year'][-2:])
card = Card.create_with_token(user, content['TOKEN'],
data['cc_number'][-4:], card_exp,
data['cc_fr_name'], form.integrator)
context = {'redirect_url': redirect_url}
return render(request, template, context)
def add_card_form_prisma(request):
data = request.POST
template = 'prisma/redirect.html'
# Verifico las key mandatorias
keys = [
'card_number', 'card_expiration_month', 'card_expiration_year',
'security_code', 'card_holder_name', 'card_type', 'user_id', 'token'
]
json_loader = __validate_json(data, keys)
if json_loader['status'] == 'error':
return HttpResponse(json.dumps(json_loader),
content_type='application/json',
status=http_BAD_REQUEST)
# Obtengo el id de la tarjeta
payment_method_id = get_prisma_card_id(data['card_type'])
if payment_method_id is None:
context = {'redirect_url': redirect_url}
return render(request, template, context)
# Obtengo el usuario y el form vinculado al token
user = User.get(data['user_id'])
form = Form.get(user, data['token'])
if form is None:
context = {'redirect_url': redirect_url}
return render(request, template, context)
# Obtengo settings del integrator
public_apikey = IntegratorSetting.get_var(form.integrator, 'public_apikey')
private_apikey = IntegratorSetting.get_var(form.integrator,
'private_apikey')
success_url = IntegratorSetting.get_var(form.integrator,
'redirect_url_success')
failed_url = IntegratorSetting.get_var(form.integrator,
'redirect_url_failed')
endpoint = IntegratorSetting.get_var(form.integrator, 'endpoint')
prisma_gw = PrismaGateway(endpoint, public_apikey, private_apikey)
# Obtengo Token de pago
try:
ret, content = prisma_gw.get_payment_token(
data) # Revisar que devuelve
if not ret:
context = {'redirect_url': redirect_url}
return render(request, template, context)
payment_token = content['id']
except Exception as e:
context = {'redirect_url': redirect_url}
return render(request, template, context)
# Realizo pago para tokenizar tarjeta
payment_id = "PH_%s_card_%d" % (user.user_id, int(time()))
cc_bin = data['card_number'][:6]
add_card_tx = PrismaTx(user.user_id, user.email, payment_id, payment_token,
cc_bin, 1, payment_method_id)
try:
ret, content = prisma_gw.payment(add_card_tx.serialize())
if not ret:
context = {'redirect_url': redirect_url}
return render(request, template, context)
card_token = content['customer_token']
except Exception as e:
context = {'redirect_url': redirect_url}
return render(request, template, context)
# Deshabilito cualquier tarjeta existente
cards = Card.objects.filter(user=user, enabled=True)
for card in cards:
card.disable()
# Creo la tarjeta o la obtengo si ya existe
card = Card.get_by_token(user, card_token)
if card is not None:
card.enable()
else:
card_exp = "%s/%s" % (data['card_expiration_month'],
data['card_expiration_month'])
card = Card.create_with_token(user, card_token,
data['card_number'][-4:], card_exp,
data['card_brand'], form.integrator,
data['security_code'])
context = {'redirect_url': redirect_url}
return render(request, template, context)
def userpayment_form_pagodigital(request):
######## Metodo POST ########
if request.method == 'POST':
data = request.POST
template = 'pagodigital/redirect.html'
# Verifico las key mandatorias
keys = [
'name', 'phone', 'address', 'id_card', 'email', 'city', 'state',
'cc_number', 'cc_exp_month', 'cc_exp_year', 'cc_cvv',
'cc_fr_number', 'cc_fr_name', 'user_id', 'token'
]
json_loader = __validate_json(data, keys)
if json_loader['status'] == 'error':
return HttpResponse(json.dumps(json_loader),
content_type='application/json',
status=http_BAD_REQUEST)
# Obtengo el usuario y el form vinculado al token
user = User.get(data['user_id'])
form = Form.get(user, data['token'])
if form is None:
message = 'form not available'
body = {'status': 'error', 'message': message}
return HttpResponse(json.dumps(body),
content_type='application/json',
status=http_BAD_REQUEST)
# Verifico que no tenga un User Payment activo
active_up = UserPayment.get_active(user)
if active_up is not None:
message = 'enabled user payment already exists'
body = {'status': 'error', 'message': message}
return HttpResponse(json.dumps(body),
content_type='application/json',
status=http_BAD_REQUEST)
up = form.user_payment
# Obtengo settings del integrator
api_key = IntegratorSetting.get_var(form.integrator, 'api_key')
api_secret = IntegratorSetting.get_var(form.integrator, 'api_secret')
success_url = IntegratorSetting.get_var(form.integrator,
'redirect_url_success')
failed_url = IntegratorSetting.get_var(form.integrator,
'redirect_url_failed')
jwt_endpoint = IntegratorSetting.get_var(form.integrator,
'jwt_endpoint')
jwt_user = IntegratorSetting.get_var(form.integrator, 'jwt_user')
jwt_pass = IntegratorSetting.get_var(form.integrator, 'jwt_pass')
# Obtengo el JWT
pd_jwt_gw = PagoDigitalJWTGateway(jwt_endpoint, jwt_user, jwt_pass)
try:
ret, content = pd_jwt_gw.doPost()
if not ret:
message = "%s - %s" % (content['STATUS_MESSAGE'],
content['MESSAGE'])
up.reply_error(message)
context = {'redirect_url': failed_url}
return render(request, template, context)
if not 'TOKEN' in content:
message = "JWT ERROR - TOKEN key not found"
up.reply_error(message)
context = {'redirect_url': failed_url}
return render(request, template, context)
pd_jwt = content['TOKEN']
except Exception as e:
message = 'jwt error: %s' % e
up.reply_error(message)
context = {'redirect_url': failed_url}
return render(request, template, context)
# Realizar add card y obtener token
pd_ac_endpoint = IntegratorSetting.get_var(form.integrator,
'add_card_endpoint')
pd_gw = PagoDigitalGateway(pd_ac_endpoint, api_key, api_secret, pd_jwt)
pd_card = PagoDigitalCard(data['cc_number'], data['cc_cvv'],
data['cc_fr_number'], data['cc_exp_month'],
data['cc_exp_year'], data['name'],
data['id_card'], data['address'],
data['email'], data['phone'], data['city'],
data['state'])
new_card = True
try:
ret, content = pd_gw.doPost(pd_card.to_dict())
if not ret:
message = "%s - %s" % (content['STATUS_MESSAGE'],
content['MESSAGE'])
up.reply_error(message)
context = {'redirect_url': failed_url}
return render(request, template, context)
if 'CODIGO_RESPUESTA' in content:
if str(content['CODIGO_RESPUESTA']) not in SUCCESS_CODES:
message = "ADD CARD ERROR - code: %s - message: %s" % (
content['CODIGO_RESPUESTA'], content['RESPUESTA'])
up.reply_error(message)
context = {'redirect_url': failed_url}
return render(request, template, context)
elif 'CODIGO_ERROR' in content and content[
'CODIGO_ERROR'] == 'PD38':
if 'TOKEN' not in content:
message = "ADD CARD ERROR - CODIGO_ERROR PD38 but TOKEN not returned"
up.reply_error(message)
context = {'redirect_url': failed_url}
return render(request, template, context)
new_card = False
else:
message = "ADD CARD ERROR - CODIGO_RESPUESTA not found"
up.reply_error(message)
context = {'redirect_url': failed_url}
return render(request, template, context)
except Exception as e:
message = 'add card error: %s' % e
up.reply_error(message)
context = {'redirect_url': failed_url}
return render(request, template, context)
# Habilito tarjeta en UP
up.enabled_card = True
# Deshabilito cualquier tarjeta existente
cards = Card.objects.filter(user=user, enabled=True)
for card in cards:
card.disable()
# Creo la tarjeta o la obtengo si ya existe
card = Card.get_by_token(up.user, content['TOKEN'])
if card is not None:
card.enable()
elif new_card:
card_exp = "%s/%s" % (data['cc_exp_month'],
data['cc_exp_year'][-2:])
card = Card.create_with_token(user, content['TOKEN'],
data['cc_number'][-4:], card_exp,
data['cc_fr_name'], form.integrator)
else:
up.enabled_card = False
message = 'add card error: Token %s not found' % content['TOKEN']
up.reply_error(message)
context = {'redirect_url': failed_url}
return render(request, template, context)
# Verifico si es trial y aplico descuento si corresponde
if up.is_trial:
trial_flag = True
disc_flag = False
disc_pct = 0
else:
trial_flag = False
if up.has_discount:
disc_flag = True
disc_pct = up.disc_pct
else:
disc_pct = 0
disc_flag = False
# Genero tx id sumando al userid el timestamp
payment_id = "PH_%s_%d" % (user.user_id, int(time()))
# Creo el registro en PaymentHistory
ph = PaymentHistory.create(up, payment_id, form.integrator, card,
disc_pct)
if ph.amount > 0:
# Realizar pago
pd_tx_endpoint = IntegratorSetting.get_var(form.integrator,
'process_tx_endpoint')
pd_gw = PagoDigitalGateway(pd_tx_endpoint, api_key, api_secret,
pd_jwt)
try:
pd_tx = PagoDigitalTx(int(ph.amount), card.token)
ret, content = pd_gw.doPost(pd_tx.to_dict())
print ret
print content
except Exception as e:
message = 'Payment error: %s' % e
up.reply_error(message)
ph.error('', message)
return False
else:
ret = True
content = {
'CODIGO_RESPUESTA': '-10',
'id': '-10',
'message': 'Pago con descuento del 100%'
}
if ret:
# Obtengo los valores segun la respuesta de Pagodigital
pr = pagodigital_translator(content)
# Seteo los valores de la UserPayment
up.status = pr["up_status"]
up.message = pr["up_message"]
up.enabled = pr["up_recurrence"]
if up.status == 'AC':
# calcular next_payment_day
up.payment_date = up.calc_payment_date()
# Fija la fecha de expiration del usuario
user.set_expiration(up.payment_date)
if disc_flag:
up.disc_counter -= 1
if trial_flag:
up.trial_counter -= 1
else:
up.channel = 'R'
up.save()
# Seteo los valores del PaymentHistory
ph.status = pr["ph_status"]
ph.gateway_id = pr["ph_gatewayid"]
ph.message = pr["ph_message"]
ph.save()
if ph.status == 'A':
redirect_url = success_url
else:
redirect_url = failed_url
if pr["user_expire"]:
user.expire()
# POST to promiscuus
if ph.trial:
ph.trial_duration = up.trial_recurrence
else:
ph.trial_duration = 0
resp_promiscuus = post_to_promiscuus(ph, 'payment_commit')
if resp_promiscuus['status'] == 'error':
ph.message = "%s - Promiscuus error: %s" % (
ph.message, resp_promiscuus['message'])
ph.save()
context = {'redirect_url': redirect_url}
return render(request, template, context)
else:
message = "could not create user payment"
up.reply_error(message)
ph.error('', message)
# POST to promiscuus
if ph.trial:
ph.trial_duration = up.trial_recurrence
else:
ph.trial_duration = 0
resp_promiscuus = post_to_promiscuus(ph, 'payment_commit')
if resp_promiscuus['status'] == 'error':
ph.message = "%s - Promiscuus error: %s" % (
ph.message, resp_promiscuus['message'])
ph.save()
context = {'redirect_url': failed_url}
return render(request, template, context)
######## Metodo GET ########
elif request.method == 'GET':
user = User.get(request.GET['user_id'])
template = Form.get_template(user, request.GET['token'])
baseurl = Setting.get_var('baseurl')
if template is None:
message = 'form not available'
body = {'status': 'error', 'message': message}
return HttpResponse(json.dumps(body),
content_type='application/json',
status=http_BAD_REQUEST)
context = {
'country': user.country.code,
'email': user.email,
'baseurl': baseurl
}
return render(request, template, context)
def userpayment_form_prisma_view(request):
######## Metodo POST ########
if request.method == 'POST':
data = request.POST
template = 'prisma/redirect.html'
# Verifico las key mandatorias
keys = [
'card_number', 'card_expiration_month', 'card_expiration_year',
'security_code', 'card_holder_name', 'card_type', 'id_type',
'id_number', 'user_id', 'token'
]
json_loader = __validate_json(data, keys)
if json_loader['status'] == 'error':
return HttpResponse(json.dumps(json_loader),
content_type='application/json',
status=http_BAD_REQUEST)
# Obtengo el id de la tarjeta
payment_method_id = get_prisma_card_id(data['card_type'])
if payment_method_id is None:
message = 'invalid payment method ID'
body = {'status': 'error', 'message': message}
return HttpResponse(json.dumps(body),
content_type='application/json',
status=http_BAD_REQUEST)
# Obtengo el usuario y el form vinculado al token
user = User.get(data['user_id'])
form = Form.get(user, data['token'])
if form is None:
message = 'form not available'
body = {'status': 'error', 'message': message}
return HttpResponse(json.dumps(body),
content_type='application/json',
status=http_BAD_REQUEST)
# Verifico que no tenga un User Payment activo
active_up = UserPayment.get_active(user)
if active_up is not None:
message = 'enabled user payment already exists'
body = {'status': 'error', 'message': message}
return HttpResponse(json.dumps(body),
content_type='application/json',
status=http_BAD_REQUEST)
up = form.user_payment
# Obtengo settings del integrator
public_apikey = IntegratorSetting.get_var(form.integrator,
'public_apikey')
private_apikey = IntegratorSetting.get_var(form.integrator,
'private_apikey')
success_url = IntegratorSetting.get_var(form.integrator,
'redirect_url_success')
failed_url = IntegratorSetting.get_var(form.integrator,
'redirect_url_failed')
endpoint = IntegratorSetting.get_var(form.integrator, 'endpoint')
prisma_gw = PrismaGateway(endpoint, public_apikey, private_apikey)
# Obtengo Token de pago
prisma_token = PrismaPaymentToken(data['card_number'],
data['card_expiration_month'],
data['card_expiration_year'],
data['security_code'],
data['card_holder_name'],
data['id_type'], data['id_number'])
try:
ret, content = prisma_gw.get_payment_token(
prisma_token.serialize()) # Revisar que devuelve
if not ret:
up.reply_error(json.dumps(content))
context = {'redirect_url': failed_url}
return render(request, template, context)
payment_token = content['id']
except Exception as e:
message = {
'status': 'error',
'message': 'get_payment_token(): %s' % e
}
up.reply_error(json.dumps(message))
context = {'redirect_url': failed_url}
return render(request, template, context)
# Realizo primer pago para tokenizar tarjeta
payment_id = "PH_%s_%dc" % (user.user_id, int(time()))
cc_bin = data['card_number'][:6]
add_card_amount = 10 * 100
add_card_tx = PrismaTx(user.user_id, user.email, payment_id,
payment_token, cc_bin, add_card_amount,
payment_method_id)
try:
ret, content = prisma_gw.add_card(add_card_tx.serialize())
if not ret:
up.reply_error(json.dumps(content))
context = {'redirect_url': failed_url}
return render(request, template, context)
card_token = content['customer_token']
if card_token is None:
message = 'add card error - payment(): card token is null'
up.reply_error(message)
context = {'redirect_url': failed_url}
return render(request, template, context)
except Exception as e:
message = 'add card error - payment(): %s' % e
up.reply_error(message)
context = {'redirect_url': failed_url}
return render(request, template, context)
# Habilito tarjeta en UP
up.enabled_card = True
# Deshabilito cualquier tarjeta existente
cards = Card.objects.filter(user=user, enabled=True)
for card in cards:
card.disable()
# Creo la tarjeta o la obtengo si ya existe
card = Card.get_by_token(up.user, card_token)
if card is not None:
card.enable()
else:
card_exp = "%s/%s" % (data['card_expiration_month'],
data['card_expiration_month'])
card = Card.create_with_token(user, card_token,
data['card_number'][-4:], card_exp,
data['card_type'], form.integrator,
data['security_code'],
data['card_number'][:6])
# Verifico si es un pago futuro
if up.payment_date > timezone.now().date():
context = {'redirect_url': success_url}
return render(request, template, context)
# Verifico si es trial y aplico descuento si corresponde
if up.is_trial:
trial_flag = True
disc_flag = False
disc_pct = 0
else:
trial_flag = False
if up.has_discount:
disc_flag = True
disc_pct = up.disc_pct
else:
disc_pct = 0
disc_flag = False
# Genero tx id sumando al userid el timestamp
payment_id = "PH_%s_%d" % (user.user_id, int(time()))
# Creo el registro en PaymentHistory
ph = PaymentHistory.create(up, payment_id, form.integrator, card,
disc_pct)
if ph.amount > 0:
# Obtengo nuevo Token de pago
payment_data = {'token': card.token, 'security_code': card.cvv}
try:
ret, content = prisma_gw.get_recurrence_token(
payment_data) # Revisar que devuelve
if not ret:
up.reply_error(json.dumps(content))
context = {'redirect_url': failed_url}
return render(request, template, context)
payment_token = content['id']
except Exception as e:
message = 'ERROR get_recurrence_token(): %s' % e
up.reply_error(message)
context = {'redirect_url': failed_url}
return render(request, template, context)
# Realizo pago
final_amount = int(ph.amount * 100) - add_card_amount
prisma_tx = PrismaTx(user.user_id, user.email, payment_id,
payment_token, cc_bin, final_amount,
payment_method_id)
try:
ret, content = prisma_gw.payment(prisma_tx.serialize())
if not ret:
up.reply_error(json.dumps(content))
context = {'redirect_url': failed_url}
return render(request, template, context)
card_token = content['customer_token']
except Exception as e:
message = 'ERROR payment(): %s' % e
up.reply_error(message)
ph.error('', message)
return False
else:
ret = True
content = {"status": "approved", "code": '-10'}
if ret:
# Obtengo los valores segun la respuesta de Prisma
pr = prisma_translator(content)
# Seteo los valores de la UserPayment
up.status = pr["up_status"]
up.message = pr["up_message"]
up.enabled = pr["up_recurrence"]
if up.status == 'AC':
# calcular next_payment_day
up.payment_date = up.calc_payment_date()
# Fija la fecha de expiration del usuario
user.set_expiration(up.payment_date)
if disc_flag:
up.disc_counter -= 1
if trial_flag:
up.trial_counter -= 1
else:
up.channel = 'R'
up.save()
# Seteo los valores del PaymentHistory
ph.status = pr["ph_status"]
ph.gateway_id = pr["ph_gatewayid"]
ph.message = pr["ph_message"]
ph.save()
if ph.status == 'A':
redirect_url = success_url
else:
redirect_url = failed_url
if pr["user_expire"]:
user.expire()
# POST to promiscuus
if ph.trial:
ph.trial_duration = up.trial_recurrence
else:
ph.trial_duration = 0
resp_promiscuus = post_to_promiscuus(ph, 'payment_commit')
if resp_promiscuus['status'] == 'error':
ph.message = "%s - Promiscuus error: %s" % (
ph.message, resp_promiscuus['message'])
ph.save()
context = {'redirect_url': redirect_url}
return render(request, template, context)
else:
message = json.dumps(content)
up.reply_error(message)
ph.error('', message)
# POST to promiscuus
if ph.trial:
ph.trial_duration = up.trial_recurrence
else:
ph.trial_duration = 0
resp_promiscuus = post_to_promiscuus(ph, 'payment_commit')
if resp_promiscuus['status'] == 'error':
ph.message = "%s - Promiscuus error: %s" % (
ph.message, resp_promiscuus['message'])
ph.save()
context = {'redirect_url': failed_url}
return render(request, template, context)
######## Metodo GET ########
elif request.method == 'GET':
user = User.get(request.GET['user_id'])
template = Form.get_template(user, request.GET['token'])
baseurl = Setting.get_var('baseurl')
if template is None:
message = 'form not available'
body = {'status': 'error', 'message': message}
return HttpResponse(json.dumps(body),
content_type='application/json',
status=http_BAD_REQUEST)
context = {
'country': user.country.code,
'email': user.email,
'baseurl': baseurl
}
return render(request, template, context)
