def put(self, request, pk):
"""Elegir el plan requrido y desactivar los demas."""
client_id = Operations.get_id(self, request)
data = request.data
plan = self.get_object(pk)
try:
plan_client = QueryPlansClient.objects.get(client=client_id, acquired_plan=plan.id)
# import pdb; pdb.set_trace()
except QueryPlansClient.DoesNotExist:
raise Http404
# valido el plan que se desea activar
if (plan.is_active is True and plan_client.client_id == client_id and
plan.expiration_date >= datetime.now().date()):
# Activar Plan
serializer = QueryPlansClientSerializer(plan_client, data, partial=True)
if serializer.is_valid():
serializer.save()
if 'test' not in sys.argv:
# sincronizo en pyrebase
plan_chosen = get_query_set_plan()
plan_active = plan_chosen.filter(queryplansclient__client=client_id, is_active=True,
queryplansclient__is_chosen=True)
serializer_plan_acquired = QueryPlansAcquiredSerializer(plan_active[0])
pyrebase.chosen_plan(client_id, serializer_plan_acquired.data)
result_data = serializer_plan_acquired.data
else:
result_data = {}
return Response(result_data)
else:
return Response(serializer.errors, HTTP_400_BAD_REQUEST)
raise Http404
def put(self, request, code):
"""Activar producto, via codigo PIN."""
data = request.data
client = request.user.id
has_chosen = False
# activation_date = datetime.now().date()
if self.get_some_chosen_plan(client):
has_chosen = True
is_chosen = False
else:
is_chosen = True
plan_acquired = self.get_detail_plan(code, client)
query_set = self.get_object(plan_acquired['id'])
serializer = ActivePlanSerializer(query_set, data,
context={
'is_chosen': is_chosen,
'client': client
},
partial=True)
if serializer.is_valid():
serializer.save()
if not has_chosen:
if 'test' not in sys.argv:
pyrebase.chosen_plan(client, serializer.data)
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create(self, validated_data):
"""Redefinido metodo create."""
# Buscamos el especialista principal de la especialidad dada
specialist = Specialist.objects.get(
type_specialist="m", category_id=validated_data["category"])
data_messages = validated_data.pop('message')
# Buscamos el plan activo y elegido
acq_plan = QueryPlansAcquired.objects.get(
queryplansclient__is_chosen=True,
queryplansclient__client=validated_data["client"])
validated_data["specialist"] = specialist
validated_data["status"] = 1
validated_data["acquired_plan"] = acq_plan
# Creamos la consulta y sus mensajes
validated_data["available_requeries"] = acq_plan.available_requeries
query = Query.objects.create(**validated_data)
# creamos el grupo para ese mensaje
group = GroupMessage.objects.create(status=1)
# Generar codigo de usuario para chat
code_user = generate_message_code_user(validated_data["client"],
acq_plan)
# Recorremos los mensajes para crearlos todos
for data_message in data_messages:
# por defecto el tipo de mensaje al crearse
# debe de ser pregunta ('q')
data_message["msg_type"] = "q"
# data_message["specialist"] = specialist
# armamos la sala para el usuario
data_message["room"] = Params.PREFIX['client'] + str(
validated_data["client"].id
) + '-' + Params.PREFIX['category'] + str(
validated_data["category"].id)
# data_message["code"] = validated_data["client"].code
data_message["code"] = code_user
# self.context["user_id"] = validated_data["client"].id
Message.objects.create(query=query, group=group, **data_message)
# restamos una consulta disponible al plan adquirido
acq_plan.available_queries = acq_plan.available_queries - 1
# si el plan queda en 0 consultas, pasa a culminado
if acq_plan.available_queries == 0 and acq_plan.queries_to_pay == 0:
acq_plan.status = 5
acq_plan.save()
if 'test' not in sys.argv:
pyrebase.chosen_plan(
validated_data["client"].id,
{"available_queries": acq_plan.available_queries})
return query
def create(self, validated_data):
"""Metodo para guardar en venta."""
products = validated_data.pop("products")
total_amount = self.get_total_amount(products)
validated_data["total_amount"] = total_amount
instance = Sale(**validated_data)
instance.save()
sale_detail = {}
client = validated_data["client"]
max_fee_product = 0
for product in products:
plan_acquired = {}
for prx in range(product["quantity"]):
# verificamos si el producto es plan de consultass
if product["product_type"].id == 1:
sale_detail["pin_code"] = generate_pin_code()
sale_detail["description"] = product["product_type"].description
sale_detail["price"] = float(product["plan_id"].price)
sale_detail["is_billable"] = product["is_billable"]
# comparo si es promocional o no
if product["is_billable"]:
sale_detail["discount"] = 0.0
plan_acquired["is_active"] = False
plan_acquired["available_queries"] = 0
plan_acquired["queries_to_pay"] = product["plan_id"].query_quantity
plan_acquired["status"] = 1
is_chosen = False
else:
# es plan promocional
plan_acquired["available_queries"] = product["plan_id"].query_quantity
plan_acquired["queries_to_pay"] = 0
validated_data["is_fee"] = False
plan_acquired["activation_date"] = date.today()
plan_acquired["status"] = date.today()
plan_acquired["expiration_date"] = get_date_by_time(product["plan_id"].validity_months)
# se activa automaticamente por ser promocional
plan_acquired["is_active"] = True
plan_acquired["status"] = 4
plan_promotionals = SellerNonBillablePlans.objects.get(
seller=validated_data["seller"],
number_month=hoy.month, number_year=hoy.year)
plan_promotionals.quantity = plan_promotionals.quantity - 1
plan_promotionals.save()
if not has_chosen_plan(validated_data["client"]):
is_chosen = True
else:
is_chosen = False
sale_detail["discount"] = float(product["plan_id"].price)
sale_detail["product_type"] = product["product_type"]
sale_detail["sale"] = instance
# creamos la instancia de detalle
instance_sale = SaleDetail.objects.create(**sale_detail)
# Calculamos la mayor cantidad de vigencias para el descuento
validity_months = product["plan_id"].validity_months
if validity_months > max_fee_product:
max_fee_product = validity_months
# llenamos data del plan adquirido
plan_acquired["validity_months"] = validity_months
plan_acquired["query_quantity"] = product["plan_id"].query_quantity
plan_acquired["available_requeries"] = 10 # harcoded. CAMBIAR
plan_acquired["maximum_response_time"] = 24 # harcoded.CAMBIAR
plan_acquired["plan_name"] = product["plan_id"].name
plan_acquired["query_plans"] = product["plan_id"]
plan_acquired["sale_detail"] = instance_sale
ins_plan = QueryPlansAcquired.objects.create(**plan_acquired)
QueryPlansClient.objects.create(
acquired_plan=ins_plan, status=1, is_chosen=is_chosen,
client=validated_data["client"])
if is_chosen:
if 'test' not in sys.argv:
ser = QueryPlansAcquiredSerializer(ins_plan)
new_ser = ser.data.copy()
new_ser["is_chosen"] = is_chosen
pyrebase.chosen_plan(client.id, new_ser)
# Crear cuotas
if validated_data["is_fee"]:
n_fees = max_fee_product
else:
n_fees = 1
# solo si no es promocional
if product["is_billable"]:
for i in range(1, n_fees+1):
if n_fees == 1:
# Si la venta es de una sola cuota
fee_amount = float(instance.total_amount)
else:
# Calcular el monto a pagar
fee_amount = 0
for product in products:
price = float(product["plan_id"].price)
validity_months = int(product["plan_id"].validity_months)
quantity = int(product["quantity"])
# Se Toman en cuenta solo planes con cuotas
if validity_months >= i:
fee_amount = (price/validity_months)*quantity + fee_amount
pay_day = date.today() + relativedelta(months=i-1) # Hardcoded cambiar la cantidad de dias
sale_id = instance
MonthlyFee.objects.create(fee_amount=fee_amount,
fee_order_number=i, status=1,
sale=sale_id,
pay_before=pay_day,
fee_quantity=n_fees)
return instance
def post(self, request):
"""Obtener la lista con todos los planes del cliente."""
client = Operations.get_id(self, request)
data = request.data
if not 'acquired_plan' in data:
raise serializers.ValidationError({'acquired_plan': [self.required]})
if 'client' in data:
clients = data['client']
if type(clients) is str:
clients = json.loads(clients)
if type(clients) is not list:
raise serializers.ValidationError({'client': [self.required]})
try:
acquired_plan = QueryPlansAcquired.objects.get(pk=data['acquired_plan'],
queryplansclient__client=client, queryplansclient__share=True)
acquired_plan_client = QueryPlansClient.objects.get(acquired_plan=acquired_plan,
client=client)
except QueryPlansAcquired.DoesNotExist:
raise Http404
try:
client_obj = Client.objects.get(pk=client)
except Client.DoesNotExist:
raise Http404
errors = {}
serializer_data = {}
# Validar cantidad total de consultas
acumulator = 0
for client_data in clients:
if 'count' in client_data:
acumulator += int(client_data['count'])
if acumulator > acquired_plan.available_queries:
raise serializers.ValidationError({'count': [self.to_much_query_share]})
for client_data in clients:
# Validamos si enviar el correo del cliente
if 'email_receiver' in client_data:
email_receiver = client_data['email_receiver']
else:
errors[email_receiver] = {'email_receiver': [self.required]}
continue
# Se valida que enviaron la cantidad
if 'count' in client_data:
count = int(client_data['count'])
else:
errors[email_receiver] = {'count': [self.required]}
continue
# Traer cliente by email si existe!
try:
receiver = Client.objects.get(email_exact=email_receiver)
status_transfer = 1
qset_client = Client.objects.filter(pk=receiver.id)
except Client.DoesNotExist:
status_transfer = 3
receiver = None
# No realizar operacion si tiene operacioens previas para este plan
plan_manage = QueryPlansManage.objects.filter(
Q(receiver=receiver, status=1) | Q(email_receiver=email_receiver, status=3)).filter(
acquired_plan=acquired_plan.id, sender=client)
if plan_manage and plan_manage[0].type_operation == 3:
errors[email_receiver] = {'email_receiver': [self.already_exists_empower]}
continue
elif not plan_manage:
plan_manage = None
else:
plan_manage = plan_manage[0]
checker = CheckEmailOperationPlan(2, email_receiver, acquired_plan, client_obj, receiver)
if not checker.is_valid():
errors[email_receiver] = checker.errors
continue
data_manage = {
'type_operation': 2, # Compartir
'status': status_transfer,
'acquired_plan': acquired_plan.id,
'new_acquired_plan': None,
'sender': client,
'receiver': receiver,
'email_receiver': email_receiver,
'count_queries': count
}
data_context = {}
data_context['client_receiver'] = {
'is_chosen': False,
'owner': False,
'transfer': False,
'share': False,
'empower': False,
'status': status_transfer,
'acquired_plan': None,
'client': receiver
}
data_context['count'] = count
data_context['acquired_plan'] = acquired_plan
data_context['plan_manage'] = plan_manage
serializer = QueryPlansShareSerializer(data=data_manage, context=data_context)
if serializer.is_valid():
serializer_data[email_receiver] = serializer
else:
errors[email_receiver] = serializer.errors
# Se retornan los errores que se acumularon
if errors:
return Response(errors, status=status.HTTP_400_BAD_REQUEST)
else:
# Para cada uno de los correos guardados
for email_receiver in serializer_data:
if 'test' not in sys.argv:
# Envio de correos notificacion
mail = BasicEmailAmazon(subject=str(self.subject), to=email_receiver,
template='email/share')
if receiver is not None:
arguments = {'message':self.default_message, 'link':WEB_HOST}
else:
arguments = {'message':REGISTRATION_MESSAGE, 'link':REGISTER_LINK}
mail.sendmail(args=arguments)
# Ejecutamos el serializer
serializer_data[email_receiver].save()
if 'test' not in sys.argv:
if status_transfer == 1:
new_acquired = serializer_data[email_receiver].data["new_acquired_plan"]
reciever_id = serializer_data[email_receiver].data["receiver"]
dict_pending = NotificationClientSerializer(qset_client).data
badge_count = dict_pending["queries_pending"] + dict_pending["match_pending"]
data_notif_push = {
"title": "Se te han compartido consultas",
"body": display_client_name(client_obj),
"sub_text": "",
"ticker": "",
"badge": badge_count,
"icon": client_obj.photo,
"plan_id": new_acquired,
"type": Params.TYPE_NOTIF["plan"],
"queries_pending": dict_pending["queries_pending"],
"match_pending": dict_pending["match_pending"]
}
# envio de notificacion push
Notification.fcm_send_data(user_id=reciever_id,
data=data_notif_push)
if acquired_plan_client.is_chosen:
data_plan = {
'available_queries': acquired_plan.available_queries
}
pyrebase.chosen_plan(client, data_plan)
return Response({})
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