def create_payment_intent(request): stripe.api_key = settings.STRIPE_KEY value = request.POST.get("value", None) if not value: return Response({'error': 'Value must exist.'}, status=status.HTTP_200_OK) value = int(value) * 100 if value < 1: return Response({'error': 'Value must be greater than or equal to 1.'}, status=status.HTTP_200_OK) uuid = request.POST.get("user", None) if not uuid: return Response({'error': 'ID must exist.'}, status=status.HTTP_200_OK) profile = Profile.objects.filter(uuid=uuid) if not profile: return Response({'error': 'This profile doesn\'t exist.'}, status=status.HTTP_200_OK) profile = profile.first() payment = Payment() payment.entertainer = profile payment.save() session = stripe.checkout.Session.create( payment_method_types=['card'], line_items=[{ 'name': 'Donation to ' + profile.entertainer_name, 'amount': value, 'currency': 'aud', 'quantity': 1, 'description': 'Thank you for your donation to ' + profile.entertainer_name, 'images': [ "{0}{1}{2}".format(settings.BASE_API_URL, settings.MEDIA_URL, profile.logo) ], }], payment_intent_data={ 'application_fee_amount': int(0.02 * value), 'transfer_data': { 'destination': profile.stripe_id, }, }, success_url=settings.BASE_URL + 'confirmation/' + str(payment.uuid), cancel_url=settings.BASE_URL + 'tip-user/' + str(profile.uuid), ) payment.stripe_id = session.payment_intent payment.save() return Response({'client_secret': session}, status=status.HTTP_200_OK)
def create(self, validated_data): """Crear pago de especialista.""" match = validated_data.pop('match') instance = Payment(**validated_data) instance.save() match.status = 5 if 'test' not in sys.argv: client_id = match.client_id specialist_id = match.specialist_id qset_client = Client.objects.filter(pk=client_id) qset_spec = Specialist.objects.filter(pk=specialist_id) dict_pending = NotificationClientSerializer(qset_client).data dict_pending_sp = NotificationSpecialistSerializer(qset_spec).data badge_count = dict_pending["queries_pending"] + dict_pending[ "match_pending"] badge_count_sp = dict_pending_sp[ "queries_pending"] + dict_pending_sp["match_pending"] disp_name = display_specialist_name(match) disp_name_to_specialist = display_client_name(match.client) data_notif_push = { "title": disp_name, "body": match.subject, "sub_text": "", "ticker": trans("successful hiring"), "badge": badge_count, "icon": match.category.image, "type": Params.TYPE_NOTIF["match_success"], "queries_pending": dict_pending["queries_pending"], "match_pending": dict_pending["match_pending"], "match_id": match.id } data_specialist = { "title": disp_name_to_specialist, "body": match.subject, "sub_text": "", "ticker": trans("successful hiring"), "badge": badge_count_sp, "icon": match.category.image, "type": Params.TYPE_NOTIF["match_success"], "queries_pending": dict_pending_sp["queries_pending"], "match_pending": dict_pending_sp["match_pending"], "match_id": match.id } # envio de notificacion push Notification.fcm_send_data(user_id=client_id, data=data_notif_push) Notification.fcm_send_data(user_id=specialist_id, data=data_specialist) match.save() sellercontact = match.client.sellercontact_set.get() sellercontact.type_contact = 3 sellercontact.save() sale = match.sale_detail.sale sale.status = 3 sale.save() return instance
def add_payment(request): payment = Payment( date=request.GET['date'], pay_out=request.GET['pay_out'], pay_in=request.GET['pay_in'], ) payment.save() return HttpResponse("OK")
def order_payment(request): token = request.headers.get('token') token = Token.objects.filter(token=token) if token.exists(): if request.method == 'POST': try: info = loads(request.body.decode('utf-8')) user = token[0].user o_id = info['orderId'] trans_id = info['transactionId'] trans_time = info['transactionTime'] st = info['status'] amount = info['amount'] payment = Payment(user=user, order_id=o_id, trans_id=trans_id, status=st, amount=amount, trans_time=trans_time) payment.save() if st == 'FAILED': return my_response(False, 'transaction failed', payment.to_json()) else: o = Order.objects.filter(order_id=o_id) o.update(completed=True) o = o.first() notif_to_admin( orderId=o_id, title='order payment', message='user paid for his order with trackId: ' + str(o.track_id)) return my_response(True, 'success', payment.to_json()) except Exception as e: return my_response( False, 'error in payment order, check body send, ' + str(e), {}) elif request.method == 'GET': if token[0].is_admin: pays = Payment.objects.all() else: pays = Payment.objects.filter(user=token[0].user) _list = [] for p in pays: _list.append(p.to_json()) return my_response(True, 'success', _list) else: return my_response(False, 'invalid method', {}) else: return my_response(False, 'token not exist', {})
def import_payments(request): if request.method == 'POST': Employee.objects.all().delete() req_body = request.FILES['file'].read() payments_dict = simplexml.loads(req_body)['payments'] for p in payments_dict: payment_tosave = Payment(method=p['method'], raw_salary=p['raw_salary'], tax_rate=p['tax_rate']) payment_tosave.save() return HttpResponse(status=200) return HttpResponse(status=400)
def create(self, validated_data): """Metodo para confirmar pago.""" fee = validated_data["monthly_fee"] # cambio el estatus de la cuota a pago # 2 PAID fee.status = 2 fee.save() qsetdetail = SaleDetail.objects.filter(sale=fee.sale) # devolver plan name, validity_months, y query quantity de los productos adquiridos # mostrarlos en la data data = {'qset': qsetdetail} # envio codigo pin por correo y aviso en push notification if fee.sale.status == 1: body = "Revisa tu correo, te enviamos tu codigo PIN" if qsetdetail.count() > 1: body = "Revisa tu correo, te enviamos tus codigos PIN" mail = BasicEmailAmazon( subject="Confirmación de pago. Productos comprados", to=fee.sale.client.username, template='email/pin_code') if 'test' not in sys.argv: mail.sendmail(args=data) qset_client = Client.objects.filter(pk=fee.sale.client_id) dict_pending = NotificationClientSerializer(qset_client).data badge_count = dict_pending["queries_pending"] + dict_pending[ "match_pending"] data_notif_push = { "title": "Se ha validado tu pago", "body": body, "sub_text": "", "ticker": "", "badge": badge_count, "icon": 'http://linkup-lb-09-916728193.us-east-1.elb.amazonaws.com/static/dashboard/dist/img/logo_grande.png', "type": Params.TYPE_NOTIF["PIN"], "queries_pending": dict_pending["queries_pending"], "match_pending": dict_pending["match_pending"] } # envio de notificacion push Notification.fcm_send_data(user_id=fee.sale.client_id, data=data_notif_push) # buscar contacto efectivo para acualitzar estado a efectivo cliente # filtar por el correo del id del cliente SellerContact.objects.filter( email_exact=fee.sale.client.username).update(type_contact=3) # compruebo si no hay mas cuotas pendientes por pagar if MonthlyFee.objects.filter(sale=fee.sale, status=1).exists(): # cambio el estatus de la ventas # 2 Progreso Sale.objects.filter(pk=fee.sale_id).update(status=2) else: # 3 pagada Sale.objects.filter(pk=fee.sale_id).update(status=3) for detail in qsetdetail: qacd = QueryPlansAcquired.objects.get(sale_detail=detail, queryplansclient__owner=True) qpclient = qacd.queryplansclient_set.get() # debo chequear si es por cuotas o no if fee.sale.is_fee: new_queries = qacd.query_plans.query_quantity / qacd.query_plans.validity_months # libero el numero de consultas que corresponde qacd.available_queries += new_queries # actualizo cuantas consultas faltan por pagar qacd.queries_to_pay -= new_queries else: # libero el numero de consultas que corresponde qacd.available_queries = qacd.query_plans.query_quantity # actualizo cuantas consultas faltan por pagar qacd.queries_to_pay = 0 if fee.sale.status == 1: qacd.status = 3 qacd.save() # actualizo a pyrebase si es el elegido if 'test' not in sys.argv: if qpclient.is_chosen: pyrebase.chosen_plan( fee.sale.client.id, {"available_queries": qacd.available_queries}) # cambio el codigo del usuario user = User.objects.get(pk=fee.sale.client_id) if fee.sale.client.type_client == 'b': user.code = Params.CODE_PREFIX["client"] + user.ruc else: user.code = Params.CODE_PREFIX["client"] + user.document_number user.save() validated_data["status"] = 2 instance = Payment(**validated_data) instance.save() return instance
def create(self, validated_data): """Crear pago de especialista.""" match = validated_data.pop('match') # import pdb; pdb.set_trace() match = Match.objects.get(pk=match.id) instance = Payment(**validated_data) instance.save() match.specialist_payment = instance client = match.client # se verifica si ya fue cliente el usuario que solicito el match # si ya lo fue pasa a status 5 directo sino pasa a 4. pendiente de pago is_client = Sale.objects.filter(saledetail__is_billable=True, client=client, status__range=(2, 3)).exists() if is_client: match.status = 5 disp_name_to_client = display_specialist_name(match) ticker_client = trans("successful hiring") disp_name_to_specialist = display_client_name(client) ticker_specialist = trans("successful hiring") else: match.status = 4 disp_name_to_client = "Sube el recibo de tu pago" ticker_client = "Realiza tu pago, procederemos con tu solicitud" ticker_specialist = "Espera por el pago del cliente" disp_name_to_specialist = "Se autorizo pago" sale = Sale.objects.create(place="BCP", total_amount=match.price, reference_number=increment_reference(), description='pago de match', client=match.client, status=1) sale_detail = SaleDetail.objects.create( price=match.price, description="Contratacion de especialista", discount=float(0), pin_code='XXXXXX', is_billable=True, product_type_id=2, sale=sale) if 'test' not in sys.argv: client_id = match.client_id specialist_id = match.specialist_id qset_client = Client.objects.filter(pk=client_id) qset_spec = Specialist.objects.filter(pk=specialist_id) dict_pending_cl = NotificationClientSerializer(qset_client).data dict_pending_sp = NotificationSpecialistSerializer(qset_spec).data badge_count = dict_pending_cl["queries_pending"] + dict_pending_cl[ "match_pending"] badge_count_sp = dict_pending_sp[ "queries_pending"] + dict_pending_sp["match_pending"] data_client = { "title": disp_name_to_client, "body": match.subject, "sub_text": "", "ticker": ticker_client, "badge": badge_count, "icon": match.category.image, "type": Params.TYPE_NOTIF["match_success"], "queries_pending": dict_pending_cl["queries_pending"], "match_pending": dict_pending_cl["match_pending"], "match_id": match.id } data_specialist = { "title": disp_name_to_specialist, "body": match.subject, "sub_text": "", "ticker": ticker_specialist, "badge": badge_count_sp, "icon": match.category.image, "type": Params.TYPE_NOTIF["match_success"], "queries_pending": dict_pending_sp["queries_pending"], "match_pending": dict_pending_sp["match_pending"], "match_id": match.id } # envio de notificacion push Notification.fcm_send_data(user_id=client_id, data=data_client) Notification.fcm_send_data(user_id=specialist_id, data=data_specialist) match.save() return instance